diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index d3f836973158..b6514cc59f8a 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -69,9 +69,8 @@
     "check:test:ui": "npm run test:ui",
     "check:test:desktop:platforms": "npm run test:desktop:platforms",
     "check:test:desktop:all": "npm run test:desktop:all",
-    "check:test:plugins": "node --test src/plugins/*/tests/*.test.mjs",
     "check:lint": "npm run typecheck && npm run lint",
-    "check": "npm run check:lint && npm run test:ui && npm run test:desktop:platforms && npm run test:desktop:all && npm run check:test:plugins",
+    "check": "npm run check:lint && npm run test:ui && npm run test:desktop:platforms && npm run test:desktop:all",
     "test:e2e": "npm run build && playwright test e2e/",
     "test:e2e:visual": "npm run build && WLR_BACKENDS=headless WLR_NO_HARDWARE_CURSORS=1 cage -- npx playwright test e2e/ --reporter=list",
     "test:e2e:update-snapshots": "npm run build && WLR_BACKENDS=headless WLR_NO_HARDWARE_CURSORS=1 cage -- npx playwright test e2e/ --reporter=list --update-snapshots",
diff --git a/apps/desktop/src/app/chat/composer/index.tsx b/apps/desktop/src/app/chat/composer/index.tsx
index 35e9fcfb3739..3764633db6d3 100644
--- a/apps/desktop/src/app/chat/composer/index.tsx
+++ b/apps/desktop/src/app/chat/composer/index.tsx
@@ -13,6 +13,7 @@ import { PR_COMMENT_URL_RE } from '@/lib/chat-runtime'
 import { sanitizeComposerInput } from '@/lib/composer-input-sanitize'
 import { DATA_IMAGE_URL_RE } from '@/lib/embedded-images'
 import { triggerHaptic } from '@/lib/haptics'
+import { useStoresSelector } from '@/lib/use-session-slice'
 import { cn } from '@/lib/utils'
 import { interceptsTypedVoiceStop } from '@/lib/voice-stop-word'
 import { sessionCompacting } from '@/store/compaction'
@@ -23,6 +24,7 @@ import { $hudMode } from '@/store/hud'
 import { sessionBlockingPrompt } from '@/store/prompts'
 import { toggleReview } from '@/store/review'
 import { $gatewayState } from '@/store/session'
+import { $botChatSessionIds, $sessionStates, $sessionTiles, isBotChatSession } from '@/store/session-states'
 import { $threadScrolledUp } from '@/store/thread-scroll'
 import { $autoSpeakReplies } from '@/store/voice-prefs'
 import { useTheme } from '@/themes'
@@ -945,6 +947,14 @@ export function ChatBar({
     handleInputDrop
   } = useComposerDrop({ cwd, insertInlineRefs, onAttachDroppedItems, requestMainFocus })
 
+  // A bot chat is a companion conversation, not a working session, so it has no
+  // repo to speak of — see the blank repoPath handed to CodingStatusRow below.
+  // Three stores: the scope set records the answer, and resolving this runtime
+  // id to the stored one it is filed under reads the other two.
+  const botChat = useStoresSelector([$botChatSessionIds, $sessionStates, $sessionTiles], () =>
+    isBotChatSession(sessionId)
+  )
+
   // Branch / worktree hand-offs (CodingStatusRow). Owns the worktree open +
   // branch-off/convert/list/switch actions; draft travels into the new session.
   const { handleBranchOff, handleConvertBranch, handleListBranches, handleSwitchBranch, openInWorktree } =
@@ -1316,7 +1326,10 @@ export function ChatBar({
                   onOpen={() => toggleReview(scope.target === 'main' ? null : (cwd ?? null), scope.target)}
                   onOpenWorktree={openInWorktree}
                   onSwitchBranch={handleSwitchBranch}
-                  repoPath={cwd}
+                  // Blank in a bot chat: the row hides itself without a repo,
+                  // and stops probing git / GitHub for a surface that has no
+                  // branch to show. Cheaper than a second composer.
+                  repoPath={botChat ? undefined : cwd}
                 />
                 <div
                   className={cn(
diff --git a/apps/desktop/src/app/chat/pane-mirror.test.ts b/apps/desktop/src/app/chat/pane-mirror.test.ts
deleted file mode 100644
index eeceb0899489..000000000000
--- a/apps/desktop/src/app/chat/pane-mirror.test.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import { atom } from 'nanostores'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { contributesToWorkspace } from '@/components/pane-shell/workspace-scope'
-import { registry } from '@/contrib/registry'
-
-import { paneMirror } from './pane-mirror'
-
-interface Tile {
-  id: string
-  owner?: string
-}
-
-const cleanupSources: Array<ReturnType<typeof atom<Tile[]>>> = []
-let sequence = 0
-
-function setup(options: {
-  workspaceMode?: 'sessions' | 'bots' | ((tile: Tile) => 'sessions' | 'bots' | undefined)
-  workspaceOwnerKey?: string | ((tile: Tile) => string | undefined)
-}) {
-  const source = atom<Tile[]>([])
-  const prefix = `pane-mirror-scope-${sequence++}`
-  cleanupSources.push(source)
-
-  paneMirror<Tile>({
-    source,
-    key: tile => tile.id,
-    prefix,
-    minWidth: '10rem',
-    title: key => key,
-    render: () => null,
-    close: () => undefined,
-    ...options
-  })()
-
-  return {
-    source,
-    contribution: (id: string) => registry.getArea('panes').find(entry => entry.id === `${prefix}:${id}`)
-  }
-}
-
-afterEach(() => {
-  for (const source of cleanupSources.splice(0)) {
-    source.set([])
-  }
-})
-
-describe('paneMirror workspace scope', () => {
-  it('forwards a static workspace mode', () => {
-    const mirror = setup({ workspaceMode: 'sessions' })
-    mirror.source.set([{ id: 'one' }])
-
-    expect(mirror.contribution('one')).toMatchObject({
-      workspaceMode: 'sessions',
-      workspaceOwnerKey: undefined
-    })
-  })
-
-  it('resolves owner callbacks per tile and refreshes an unchanged title', () => {
-    const mirror = setup({
-      workspaceMode: 'bots',
-      workspaceOwnerKey: tile => tile.owner
-    })
-
-    mirror.source.set([{ id: 'one', owner: 'connection-a::default' }])
-    expect(mirror.contribution('one')?.workspaceOwnerKey).toBe('connection-a::default')
-
-    mirror.source.set([{ id: 'one', owner: 'connection-b::default' }])
-    expect(mirror.contribution('one')?.workspaceOwnerKey).toBe('connection-b::default')
-  })
-
-  it('leaves existing callers unscoped when options are omitted', () => {
-    const mirror = setup({})
-    mirror.source.set([{ id: 'one' }])
-
-    expect(mirror.contribution('one')).toMatchObject({
-      workspaceMode: undefined,
-      workspaceOwnerKey: undefined
-    })
-  })
-
-  it('keeps an unscoped Browser tile visible in Bot Mode', () => {
-    const mirror = setup({})
-    mirror.source.set([{ id: 'url:browser' }])
-
-    const pane = mirror.contribution('url:browser')
-
-    expect(contributesToWorkspace(pane, 'sessions')).toBe(true)
-    expect(contributesToWorkspace(pane, 'bots', 'bot:connection-a::default')).toBe(true)
-  })
-
-  it('hides a Sessions-only Browser tile from Bot Mode', () => {
-    const mirror = setup({ workspaceMode: 'sessions' })
-    mirror.source.set([{ id: 'url:browser' }])
-
-    const pane = mirror.contribution('url:browser')
-
-    expect(contributesToWorkspace(pane, 'sessions')).toBe(true)
-    expect(contributesToWorkspace(pane, 'bots', 'bot:connection-a::default')).toBe(false)
-  })
-})
diff --git a/apps/desktop/src/app/chat/pane-mirror.ts b/apps/desktop/src/app/chat/pane-mirror.ts
index c0886ff77113..96657794ee34 100644
--- a/apps/desktop/src/app/chat/pane-mirror.ts
+++ b/apps/desktop/src/app/chat/pane-mirror.ts
@@ -12,23 +12,13 @@ import type { ReactElement, ReactNode, PointerEvent as ReactPointerEvent } from
 import { registerPaneCloser, removeTreePane, treePanesWithPrefix } from '@/components/pane-shell/tree/store'
 import type { MenuKit } from '@/components/ui/actions-menu'
 import { registry } from '@/contrib/registry'
-import type { WorkspaceMode } from '@/contrib/types'
 import type { TileDock } from '@/store/session-states'
 
-type WorkspaceValue<T, V> = V | ((tile: T) => V | undefined)
-
-const workspaceValue = <T, V>(value: WorkspaceValue<T, V> | undefined, tile: T): V | undefined =>
-  typeof value === 'function' ? (value as (tile: T) => V | undefined)(tile) : value
-
 export interface PaneMirror<T> {
   /** Reactive source list. */
   source: ReadableAtom<T[]>
   /** Extra atoms whose changes should re-sync (e.g. titles living elsewhere). */
   also?: ReadableAtom<unknown>[]
-  /** Workspace surface this tile belongs to. Omit for a global pane. */
-  workspaceMode?: WorkspaceValue<T, WorkspaceMode>
-  /** Exact opaque owner inside Bot Mode. Omit outside an owner-scoped pane. */
-  workspaceOwnerKey?: WorkspaceValue<T, string>
   /** Stable key + pane-id seed for a tile. */
   key: (tile: T) => string
   /** Pane-id namespace — the id is `${prefix}:${key}`. */
@@ -67,10 +57,7 @@ export interface PaneMirror<T> {
 /** Build a `watch*` fn: syncs once, then re-syncs on every source/also change.
  *  Module-level state lives in the returned closure, so call it once per app. */
 export function paneMirror<T>(cfg: PaneMirror<T>): () => void {
-  const registered = new Map<
-    string,
-    { dispose: () => void; title: string; workspaceMode?: WorkspaceMode; workspaceOwnerKey?: string }
-  >()
+  const registered = new Map<string, { dispose: () => void; title: string }>()
 
   const paneId = (key: string) => `${cfg.prefix}:${key}`
 
@@ -81,17 +68,10 @@ export function paneMirror<T>(cfg: PaneMirror<T>): () => void {
     for (const tile of tiles) {
       const key = cfg.key(tile)
       const title = cfg.title(key)
-      const workspaceMode = workspaceValue(cfg.workspaceMode, tile)
-      const workspaceOwnerKey = workspaceValue(cfg.workspaceOwnerKey, tile)
       const current = registered.get(key)
 
       // register() replaces same-id in place — safe for live title refreshes.
-      if (
-        current &&
-        current.title === title &&
-        current.workspaceMode === workspaceMode &&
-        current.workspaceOwnerKey === workspaceOwnerKey
-      ) {
+      if (current && current.title === title) {
         continue
       }
 
@@ -119,12 +99,10 @@ export function paneMirror<T>(cfg: PaneMirror<T>): () => void {
           tabMenuPrefix: cfg.tabMenuPrefix?.(key),
           tabWrap: cfg.tabWrap ? (tab: ReactElement) => cfg.tabWrap!(key, tab) : undefined
         },
-        render: () => cfg.render(key),
-        workspaceMode,
-        workspaceOwnerKey
+        render: () => cfg.render(key)
       })
 
-      registered.set(key, { dispose, title, workspaceMode, workspaceOwnerKey })
+      registered.set(key, { dispose, title })
 
       if (!current) {
         registerPaneCloser(paneId(key), () => cfg.close(key))
diff --git a/apps/desktop/src/app/chat/preview-tile.test.ts b/apps/desktop/src/app/chat/preview-tile.test.ts
index 51073def256e..d5cea44709f5 100644
--- a/apps/desktop/src/app/chat/preview-tile.test.ts
+++ b/apps/desktop/src/app/chat/preview-tile.test.ts
@@ -8,7 +8,6 @@ vi.mock('./right-rail/preview-console-store', () => ({
   forgetPreviewConsole: () => undefined
 }))
 
-import { contributesToWorkspace } from '@/components/pane-shell/workspace-scope'
 import { registry } from '@/contrib/registry'
 import { $previewTabs, closeRightRail, noteBrowserPage, openPreview } from '@/store/preview'
 
@@ -22,28 +21,6 @@ afterEach(() => {
   closeRightRail()
 })
 
-// By prefix, not by a literal id: a Browser tab's id is minted per tab now
-// that there can be more than one of them.
-function browserPane() {
-  return registry.getArea('panes').find(entry => entry.id.startsWith('preview-tile:url:'))
-}
-
-describe('preview tiles in Bot Mode', () => {
-  it('registers the in-app Browser as a global pane so Bot Mode can show it', () => {
-    openPreview(
-      { kind: 'url', label: 'example.com', source: 'https://example.com', url: 'https://example.com' },
-      'explicit-link'
-    )
-
-    const pane = browserPane()
-
-    expect(pane).toBeTruthy()
-    expect(pane?.workspaceMode).toBeUndefined()
-    expect(contributesToWorkspace(pane, 'sessions')).toBe(true)
-    expect(contributesToWorkspace(pane, 'bots', 'bot:connection-a::default')).toBe(true)
-  })
-})
-
 describe('browserTabLabel', () => {
   const target = { kind: 'url', label: 'Browser', source: 'about:blank', url: 'about:blank' } as const
 
diff --git a/apps/desktop/src/app/chat/route-tile.tsx b/apps/desktop/src/app/chat/route-tile.tsx
index f2af03527a24..1388f48c0425 100644
--- a/apps/desktop/src/app/chat/route-tile.tsx
+++ b/apps/desktop/src/app/chat/route-tile.tsx
@@ -86,7 +86,6 @@ function RouteTilePane({ path }: { path: string }) {
 /** Keep pane contributions mirroring `$routeTiles`. Call once from the root. */
 export const watchRouteTiles = paneMirror<RouteTile>({
   source: $routeTiles,
-  workspaceMode: 'sessions',
   key: t => t.path,
   prefix: 'route-tile',
   dir: t => t.dir,
diff --git a/apps/desktop/src/app/chat/session-tile.tsx b/apps/desktop/src/app/chat/session-tile.tsx
index 7678cd13b9d3..d58c4584fe96 100644
--- a/apps/desktop/src/app/chat/session-tile.tsx
+++ b/apps/desktop/src/app/chat/session-tile.tsx
@@ -646,8 +646,6 @@ export function WorkspaceTabMenu({ children }: { children: React.ReactElement })
  *  `$sessions`). Tiles dock against main on the chosen edge, flex width. */
 export const watchSessionTiles = paneMirror<SessionTile>({
   source: $sessionTiles,
-  workspaceMode: tile => tile.workspaceMode ?? 'sessions',
-  workspaceOwnerKey: tile => tile.workspaceOwnerKey,
   // $projectTree: a tile whose session is older than the recents page resolves
   // its title through the tree, which loads after the tiles register. (The tab's
   // status dot subscribes to color/state itself, so it needs no `also` entry.)
diff --git a/apps/desktop/src/app/chat/sidebar/chrome.tsx b/apps/desktop/src/app/chat/sidebar/chrome.tsx
index 56887360046e..3b6d90c9bb9e 100644
--- a/apps/desktop/src/app/chat/sidebar/chrome.tsx
+++ b/apps/desktop/src/app/chat/sidebar/chrome.tsx
@@ -9,6 +9,14 @@ import { compactNumber } from '@/lib/format'
 import { cn } from '@/lib/utils'
 import { $sidebarRowMeta } from '@/store/layout'
 
+import {
+  SIDEBAR_ROW_INSET,
+  SIDEBAR_ROW_LABEL,
+  SIDEBAR_ROW_LEAD,
+  SIDEBAR_ROW_MIN_H,
+  SIDEBAR_ROW_PAD_TRAIL
+} from './row-geometry'
+
 // Shared, content-agnostic sidebar chrome — used by both the flat session
 // sections and the project/workspace tree, so it lives outside either to keep
 // imports one-directional (no index <-> projects cycle).
@@ -18,39 +26,10 @@ export function SidebarSectionMeta({ children }: { children: React.ReactNode })
   return <span className="shrink-0 text-[0.6875rem] font-medium text-(--ui-text-quaternary)">{children}</span>
 }
 
-// ── Row geometry (session row is canonical — everything composes these) ─────
-//
-// Height lives ONLY on SidebarRowShell (min-h-[1.625rem]). Inset children
-// stretch to fill the cell and center content internally — never items-center
-// on the shell grid, or short clusters (projects) float 1–2px off sessions.
-//
-// `rowPadX` is the BODY's padding: the lead's inset, plus the gap the label
-// keeps from the actions column, both inside the row's click target.
-// `rowPadTrail` is the row's own trailing inset and belongs to the SHELL — the
-// only box containing both the actions column AND the card's in-body cluster,
-// so one class insets every trailing thing a row can render. Owned anywhere
-// else, the age / chips / kebab sit flush on the border box, which is exactly
-// where a working row paints its arc (`.arc-row` has zero standoff) — the ring
-// ran through the text.
-
-const rowMinH = 'min-h-[1.625rem]'
-const rowPadX = 'pl-2 pr-2'
-const rowPadTrail = 'pr-2'
-const rowGap = 'gap-1.5'
-const rowLead = 'grid size-3.5 shrink-0 place-items-center'
-const rowInset = cn(rowPadX, rowGap, 'flex h-full min-w-0 items-center self-stretch py-0.5')
-// `truncate` is overflow:hidden. `leading-none` (line-height: 1) makes the
-// line box equal the em-square, so glyph ink that sticks out — Segoe UI on
-// Windows is ~1.33em — gets shaved. 1.35 leaves room; the shell still owns
-// row height, so the extra leading just centers.
-export const SIDEBAR_TRUNCATED_LEADING = 'leading-[1.35]' as const
-const rowLabel = cn('min-w-0 truncate text-[0.8125rem] text-(--ui-text-secondary)', SIDEBAR_TRUNCATED_LEADING)
-
-/** Inbox-style card (workspace + age, title + preview, model + size). */
-export const SIDEBAR_ROW_CARD_MIN_H = 'min-h-[3.375rem]' as const
-
-/** Codicon size in sidebar row leads — matches the file tree (`tree.tsx`). */
-export const SIDEBAR_LEAD_ICON_SIZE = '0.875rem' as const
+// Row geometry lives in `row-geometry.ts` — see that file for why each class
+// belongs to the box it belongs to. Re-exported here because this module is
+// where callers already look for row chrome.
+export { SIDEBAR_LEAD_ICON_SIZE, SIDEBAR_ROW_CARD_MIN_H, SIDEBAR_TRUNCATED_LEADING } from './row-geometry'
 
 /** Vertical stack of rows (gap-px, single column). */
 export function SidebarRowStack({ className, ...props }: React.ComponentProps<'div'>) {
@@ -100,7 +79,12 @@ export function SidebarRowShell({
 }: React.ComponentProps<'div'> & { actions?: React.ReactNode; actionsClassName?: string }) {
   return (
     <div
-      className={cn(rowMinH, rowPadTrail, 'grid grid-cols-[minmax(0,1fr)_auto] items-stretch rounded-md', className)}
+      className={cn(
+        SIDEBAR_ROW_MIN_H,
+        SIDEBAR_ROW_PAD_TRAIL,
+        'grid grid-cols-[minmax(0,1fr)_auto] items-stretch rounded-md',
+        className
+      )}
       {...props}
     >
       {children}
@@ -115,12 +99,12 @@ export function SidebarRowShell({
 
 /** Multi-control left cluster (project rows). */
 export function SidebarRowCluster({ className, ...props }: React.ComponentProps<'div'>) {
-  return <div className={cn(rowInset, className)} {...props} />
+  return <div className={cn(SIDEBAR_ROW_INSET, className)} {...props} />
 }
 
 /** Session row main tap target. */
 export function SidebarRowBody({ className, ...props }: React.ComponentProps<'button'>) {
-  return <RowButton className={cn(rowInset, 'bg-transparent text-left', className)} {...props} />
+  return <RowButton className={cn(SIDEBAR_ROW_INSET, 'bg-transparent text-left', className)} {...props} />
 }
 
 /** Tappable label — underline/truncate live on the inner span, not the button. */
@@ -132,19 +116,19 @@ export function SidebarRowLink({
 }: React.ComponentProps<'button'> & { labelClassName?: string }) {
   return (
     <RowButton className={cn('min-w-0 shrink bg-transparent p-0 text-left', className)} {...props}>
-      <span className={cn(rowLabel, labelClassName)}>{children}</span>
+      <span className={cn(SIDEBAR_ROW_LABEL, labelClassName)}>{children}</span>
     </RowButton>
   )
 }
 
 /** Fixed leading column (dot, icon, drag handle). */
 export function SidebarRowLead({ className, ...props }: React.ComponentProps<'span'>) {
-  return <span className={cn(rowLead, className)} {...props} />
+  return <span className={cn(SIDEBAR_ROW_LEAD, className)} {...props} />
 }
 
 /** Standard row label typography. */
 export function SidebarRowLabel({ className, ...props }: React.ComponentProps<'span'>) {
-  return <span className={cn(rowLabel, className)} {...props} />
+  return <span className={cn(SIDEBAR_ROW_LABEL, className)} {...props} />
 }
 
 /** What a group's sessions add up to, for the Show options that count something. */
diff --git a/apps/desktop/src/app/chat/sidebar/connection-glyph.tsx b/apps/desktop/src/app/chat/sidebar/connection-glyph.tsx
index f553d7f6f09a..4fd338145ae5 100644
--- a/apps/desktop/src/app/chat/sidebar/connection-glyph.tsx
+++ b/apps/desktop/src/app/chat/sidebar/connection-glyph.tsx
@@ -1,11 +1,21 @@
 import type { DesktopRegistryConnection } from '@/global'
 import { Cloud, Monitor, Network, Terminal } from '@/lib/icons'
+import { cn } from '@/lib/utils'
+
+import { SIDEBAR_ROW_LEAD } from './row-geometry'
 
 // One glyph per connection kind — device, cloud, network, terminal — shared by
-// the statusbar switcher, its menu, and the fleet profile rail so a gateway
-// looks the same wherever it is named. Dependency-free on purpose (icons and
-// a type only) so light components can use it without pulling in stores.
-export function ConnectionGlyph({ connection }: { connection: Pick<DesktopRegistryConnection, 'kind'> }) {
+// the statusbar switcher, its menu, the fleet profile rail and the Bots rail so
+// a gateway looks the same wherever it is named. Dependency-free on purpose
+// (icons, a type and class strings) so light components can use it without
+// pulling in stores.
+export function ConnectionGlyph({
+  className,
+  connection
+}: {
+  className?: string
+  connection: Pick<DesktopRegistryConnection, 'kind'>
+}) {
   const Icon =
     connection.kind === 'local'
       ? Monitor
@@ -18,7 +28,7 @@ export function ConnectionGlyph({ connection }: { connection: Pick<DesktopRegist
   return (
     <span
       aria-hidden="true"
-      className="grid size-3.5 shrink-0 place-items-center text-(--ui-text-quaternary)"
+      className={cn(SIDEBAR_ROW_LEAD, 'text-(--ui-text-quaternary)', className)}
       data-connection-kind={connection.kind}
       data-slot="connection-glyph"
     >
diff --git a/apps/desktop/src/app/chat/sidebar/row-geometry.ts b/apps/desktop/src/app/chat/sidebar/row-geometry.ts
new file mode 100644
index 000000000000..f6be97af3612
--- /dev/null
+++ b/apps/desktop/src/app/chat/sidebar/row-geometry.ts
@@ -0,0 +1,55 @@
+import { cn } from '@/lib/utils'
+
+// The sidebar row's measurements, in one place. The session row is canonical
+// and everything else composes these — a row that spells its own geometry
+// floats 1–2px off the sessions above it, which is how the drift starts.
+//
+// Split out of `chrome.tsx` so the literals are reachable without the
+// components: light, store-free callers (a connection glyph) and the plugin
+// SDK both need the lead cell, and neither should have to pull nanostores to
+// line up with a session row.
+//
+// Height lives ONLY on the shell (`SIDEBAR_ROW_MIN_H`). Inset children stretch
+// to fill the cell and center content internally — never `items-center` on the
+// shell grid, or short clusters (projects) float off sessions.
+//
+// `SIDEBAR_ROW_PAD_X` is the BODY's padding: the lead's inset, plus the gap the
+// label keeps from the actions column, both inside the row's click target.
+// `SIDEBAR_ROW_PAD_TRAIL` is the row's own trailing inset and belongs to the
+// SHELL — the only box containing both the actions column AND the card's
+// in-body cluster, so one class insets every trailing thing a row can render.
+// Owned anywhere else, the age / chips / kebab sit flush on the border box,
+// which is exactly where a working row paints its arc (`.arc-row` has zero
+// standoff) — the ring ran through the text.
+
+export const SIDEBAR_ROW_MIN_H = 'min-h-[1.625rem]' as const
+export const SIDEBAR_ROW_PAD_X = 'pl-2 pr-2' as const
+export const SIDEBAR_ROW_PAD_TRAIL = 'pr-2' as const
+export const SIDEBAR_ROW_GAP = 'gap-1.5' as const
+
+/** Fixed leading cell — dot, icon, drag handle. Every row's label starts at the
+ *  same left edge because they all reserve this exact box. */
+export const SIDEBAR_ROW_LEAD = 'grid size-3.5 shrink-0 place-items-center' as const
+
+export const SIDEBAR_ROW_INSET = cn(
+  SIDEBAR_ROW_PAD_X,
+  SIDEBAR_ROW_GAP,
+  'flex h-full min-w-0 items-center self-stretch py-0.5'
+)
+
+// `truncate` is overflow:hidden. `leading-none` (line-height: 1) makes the line
+// box equal the em-square, so glyph ink that sticks out — Segoe UI on Windows
+// is ~1.33em — gets shaved. 1.35 leaves room; the shell still owns row height,
+// so the extra leading just centers.
+export const SIDEBAR_TRUNCATED_LEADING = 'leading-[1.35]' as const
+
+export const SIDEBAR_ROW_LABEL = cn(
+  'min-w-0 truncate text-[0.8125rem] text-(--ui-text-secondary)',
+  SIDEBAR_TRUNCATED_LEADING
+)
+
+/** Inbox-style card (workspace + age, title + preview, model + size). */
+export const SIDEBAR_ROW_CARD_MIN_H = 'min-h-[3.375rem]' as const
+
+/** Codicon size in sidebar row leads — matches the file tree (`tree.tsx`). */
+export const SIDEBAR_LEAD_ICON_SIZE = '0.875rem' as const
diff --git a/apps/desktop/src/app/contrib/controller.tsx b/apps/desktop/src/app/contrib/controller.tsx
index 30fd949c5eaa..8c19c58eccf4 100644
--- a/apps/desktop/src/app/contrib/controller.tsx
+++ b/apps/desktop/src/app/contrib/controller.tsx
@@ -177,7 +177,6 @@ registry.registerMany([
   {
     id: 'workspace',
     area: 'panes',
-    workspaceMode: 'sessions',
     // Live-retitled to the loaded session by syncWorkspaceTitle below.
     title: NEW_SESSION_TITLE,
     data: {
@@ -488,7 +487,6 @@ const syncWorkspaceTitle = () => {
   registry.register({
     id: 'workspace',
     area: 'panes',
-    workspaceMode: 'sessions',
     // The placeholder, not the draft's live name — `tabTitle` below renders
     // that. Keeping it here would re-register the pane on every keystroke.
     title: stored ? storedSessionTitle(stored) : NEW_SESSION_TITLE,
diff --git a/apps/desktop/src/app/contrib/wiring.tsx b/apps/desktop/src/app/contrib/wiring.tsx
index 1da332aca62f..06da62c96e2f 100644
--- a/apps/desktop/src/app/contrib/wiring.tsx
+++ b/apps/desktop/src/app/contrib/wiring.tsx
@@ -46,7 +46,7 @@ import { requestVoiceConversationStart } from '@/store/composer'
 import { $activeConnectionId } from '@/store/connections'
 import { $cronReviewRequest, setCronFocusJobId } from '@/store/cron'
 import { $pinnedSessionIds, pinSession, restoreWorktree, unpinSession } from '@/store/layout'
-import { notify, notifyError } from '@/store/notifications'
+import { notifyError } from '@/store/notifications'
 import { $previewTarget } from '@/store/preview'
 import {
   $activeGatewayProfile,
@@ -875,24 +875,17 @@ export function ContribWiring({ children }: { children: ReactNode }) {
   // the sidebar until its first message persists a turn and a refresh surfaces
   // it — Cursor-style. Every click opens a fresh "New session" tab (multiple
   // empty tabs are fine since none touch the session list).
+  //
+  // Bot Mode aims the "+" at the selected bot's own profile. Anything short of
+  // an exact route — a group chat's `blocked` target, an orphaned roster row —
+  // falls THROUGH to the ordinary session rather than refusing: the main strip
+  // carries plain session tabs alongside bot chats, so a "+" there must never
+  // be dead just because the sidebar's current selection has nowhere to route.
   const openNewSessionTab = useCallback(() => {
-    const workspaceMode = $workspaceMode.get()
     const workspaceOwnerKey = $workspaceOwnerKey.get()
     const workspaceNewSessionTarget = $workspaceNewSessionTarget.get()
 
-    if (workspaceMode === 'bots') {
-      if (workspaceNewSessionTarget?.kind !== 'route' || !workspaceOwnerKey) {
-        notify({
-          kind: 'info',
-          message:
-            workspaceNewSessionTarget?.kind === 'blocked'
-              ? workspaceNewSessionTarget.message
-              : 'Select a Bot or group first.'
-        })
-
-        return
-      }
-
+    if ($workspaceMode.get() === 'bots' && workspaceNewSessionTarget?.kind === 'route' && workspaceOwnerKey) {
       void openNewSessionTile('center', {
         listed: false,
         route: workspaceNewSessionTarget.route,
diff --git a/apps/desktop/src/components/assistant-ui/chat-empty-slot.test.tsx b/apps/desktop/src/components/assistant-ui/chat-empty-slot.test.tsx
new file mode 100644
index 000000000000..38e6a7afdd3e
--- /dev/null
+++ b/apps/desktop/src/components/assistant-ui/chat-empty-slot.test.tsx
@@ -0,0 +1,76 @@
+/**
+ * The `chat.empty` slot mounts EVERY contributor, not just the first.
+ *
+ * Ownership of an empty transcript is per session and is not known until each
+ * plugin has loaded its own data, so a first-wins slot let whichever plugin
+ * happened to register first suppress the one that actually owns the chat —
+ * silently, permanently, and only for some users, since registration order
+ * depends on which plugins are installed.
+ */
+
+import { render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { registry } from '@/contrib'
+import { CHAT_EMPTY_AREA, type ChatEmptyContribution } from '@/lib/chat-empty'
+
+import { ChatEmptySlot } from './chat-empty-slot'
+
+const disposers: (() => void)[] = []
+
+function contribute(id: string, render: ChatEmptyContribution['render']) {
+  disposers.push(registry.register({ area: CHAT_EMPTY_AREA, data: { render }, id }))
+}
+
+afterEach(() => {
+  for (const dispose of disposers.splice(0)) {
+    dispose()
+  }
+})
+
+describe('an empty transcript asks every contributor', () => {
+  it('renders the owner even when an earlier contributor declined', () => {
+    contribute('declines', () => null)
+    contribute('owns', ({ sessionId }) => <span data-testid="owner">owner of {sessionId}</span>)
+
+    render(<ChatEmptySlot sessionId="s-1" />)
+
+    expect(screen.getByTestId('owner').textContent).toBe('owner of s-1')
+  })
+
+  it('renders nothing when everyone declines', () => {
+    contribute('a', () => null)
+    contribute('b', () => null)
+
+    const { container } = render(<ChatEmptySlot sessionId="s-1" />)
+
+    expect(container.textContent).toBe('')
+  })
+
+  it('renders nothing when nobody contributes at all', () => {
+    const { container } = render(<ChatEmptySlot sessionId="s-1" />)
+
+    expect(container.textContent).toBe('')
+  })
+
+  it('shows a conflict rather than hiding one of the claimants', () => {
+    contribute('first', () => <span>first</span>)
+    contribute('second', () => <span>second</span>)
+
+    render(<ChatEmptySlot sessionId="s-1" />)
+
+    expect(screen.getByText('first')).toBeTruthy()
+    expect(screen.getByText('second')).toBeTruthy()
+  })
+
+  it('isolates a throwing contributor from the ones beside it', () => {
+    contribute('boom', () => {
+      throw new Error('contributor exploded')
+    })
+    contribute('owns', () => <span data-testid="owner">still here</span>)
+
+    render(<ChatEmptySlot sessionId="s-1" />)
+
+    expect(screen.getByTestId('owner').textContent).toBe('still here')
+  })
+})
diff --git a/apps/desktop/src/components/assistant-ui/chat-empty-slot.tsx b/apps/desktop/src/components/assistant-ui/chat-empty-slot.tsx
new file mode 100644
index 000000000000..cccdb9f76290
--- /dev/null
+++ b/apps/desktop/src/components/assistant-ui/chat-empty-slot.tsx
@@ -0,0 +1,55 @@
+import type { FC } from 'react'
+import { useMemo } from 'react'
+
+import { useContributions } from '@/contrib'
+import { ContribBoundary, ContribRender } from '@/contrib/react/boundary'
+import { CHAT_EMPTY_AREA, type ChatEmptyContribution } from '@/lib/chat-empty'
+
+/**
+ * The empty transcript's contributed slot. Mounts every registration and lets
+ * each decide — it renders the session's empty state, or nothing at all if the
+ * session isn't one it owns.
+ *
+ * Deliberately a mount rather than a claim the transcript resolves up front:
+ * whether a session has an empty state depends on data the plugin loads on its
+ * own clock (a bot chat's roster lands after the transcript), and only a
+ * mounted component can subscribe and appear when it arrives.
+ *
+ * That same asynchrony is why the slot cannot mount only the first
+ * registration. Ownership is per session and is not known until each has
+ * loaded, so first-wins would let a plugin that DECLINES a session suppress the
+ * one that owns it, permanently and silently, purely on registration order.
+ * Mounting all of them means disjoint owners each work; two claiming the same
+ * session render both, which is a visible conflict rather than a silent drop.
+ */
+const ChatEmptyEntry: FC<{ id: string; render: ChatEmptyContribution['render']; sessionId: string }> = ({
+  id,
+  render,
+  sessionId
+}) => {
+  // Stable component identity: ContribRender mounts this AS a component, so a
+  // fresh closure per render would remount the empty state on every tick.
+  const renderEmpty = useMemo(() => () => render({ sessionId }), [render, sessionId])
+
+  return (
+    <ContribBoundary id={id}>
+      <ContribRender render={renderEmpty} />
+    </ContribBoundary>
+  )
+}
+
+export const ChatEmptySlot: FC<{ sessionId: string }> = ({ sessionId }) => {
+  const contributions = useContributions(CHAT_EMPTY_AREA)
+
+  return (
+    <>
+      {contributions.map(contribution => {
+        const render = (contribution.data as ChatEmptyContribution | undefined)?.render
+
+        return render ? (
+          <ChatEmptyEntry id={contribution.id} key={contribution.id} render={render} sessionId={sessionId} />
+        ) : null
+      })}
+    </>
+  )
+}
diff --git a/apps/desktop/src/components/assistant-ui/thread/index.tsx b/apps/desktop/src/components/assistant-ui/thread/index.tsx
index e67683eb1ffc..188f3d1e255d 100644
--- a/apps/desktop/src/components/assistant-ui/thread/index.tsx
+++ b/apps/desktop/src/components/assistant-ui/thread/index.tsx
@@ -1,5 +1,6 @@
 import { createContext, memo, useCallback, useContext, useMemo, useRef, useState } from 'react'
 
+import { ChatEmptySlot } from '@/components/assistant-ui/chat-empty-slot'
 import { AssistantMessage } from '@/components/assistant-ui/thread/assistant-message'
 import { ThreadMessageList } from '@/components/assistant-ui/thread/list'
 import { BackgroundResumeNotice, CenteredThreadSpinner } from '@/components/assistant-ui/thread/status'
@@ -147,9 +148,15 @@ export const Thread = memo(function Thread({
     [hasBranchInNewChat, hasCancel, hasDismissError, hasRestoreToMessage, requestRestoreConfirm]
   )
 
-  const emptyPlaceholder = intro ? (
+  // Core's splash belongs to a fresh draft; a session that exists but has
+  // nothing in it yet gets whichever plugin owns it. The slot often renders
+  // nothing, which costs an empty container — harmless, since there is no
+  // content to lay out until the first message swaps this branch out.
+  const emptyBody = intro ? <Intro {...intro} /> : sessionId ? <ChatEmptySlot sessionId={sessionId} /> : null
+
+  const emptyPlaceholder = emptyBody ? (
     <div className="flex min-h-0 w-full flex-col items-center justify-center pt-[var(--composer-measured-height)]">
-      <Intro {...intro} />
+      {emptyBody}
     </div>
   ) : undefined
 
diff --git a/apps/desktop/src/components/assistant-ui/tool/delegate.tsx b/apps/desktop/src/components/assistant-ui/tool/delegate.tsx
index 8ec3d92b243c..2c756176282a 100644
--- a/apps/desktop/src/components/assistant-ui/tool/delegate.tsx
+++ b/apps/desktop/src/components/assistant-ui/tool/delegate.tsx
@@ -6,7 +6,7 @@ import { type FC, type ReactNode, useMemo } from 'react'
 import { useSessionView } from '@/app/chat/session-view'
 import { useElapsedSeconds } from '@/components/chat/activity-timer'
 import { ActivityTimerText } from '@/components/chat/activity-timer-text'
-import { SCAFFOLD_LABEL_CLASS, SCAFFOLD_META_CLASS } from '@/components/chat/scaffold-row'
+import { SCAFFOLD_GLYPH_CLASS, SCAFFOLD_LABEL_CLASS, SCAFFOLD_META_CLASS } from '@/components/chat/scaffold-row'
 import { FadeText } from '@/components/ui/fade-text'
 import { GlyphSpinner } from '@/components/ui/glyph-spinner'
 import { useI18n } from '@/i18n'
@@ -88,7 +88,7 @@ function DelegateRowView({ row }: { row: DelegateRow }) {
   return (
     <div className="grid min-w-0 max-w-full gap-0.5" data-conversation-scaffold="">
       <div className="flex min-w-0 max-w-full items-center gap-1.5">
-        <span className="grid size-3.5 shrink-0 place-items-center">{statusGlyph(row.status, statusLabel)}</span>
+        <span className={SCAFFOLD_GLYPH_CLASS}>{statusGlyph(row.status, statusLabel)}</span>
         <button
           className={cn(
             SCAFFOLD_LABEL_CLASS,
diff --git a/apps/desktop/src/components/assistant-ui/tool/fallback.tsx b/apps/desktop/src/components/assistant-ui/tool/fallback.tsx
index b2c94ecf69a1..fd26087e27fb 100644
--- a/apps/desktop/src/components/assistant-ui/tool/fallback.tsx
+++ b/apps/desktop/src/components/assistant-ui/tool/fallback.tsx
@@ -24,7 +24,12 @@ import { ActivityTimerText } from '@/components/chat/activity-timer-text'
 import { CompactMarkdown } from '@/components/chat/compact-markdown'
 import { FileDiffPanel } from '@/components/chat/diff-lines'
 import { DisclosureRow } from '@/components/chat/disclosure-row'
-import { SCAFFOLD_LABEL_CLASS, SCAFFOLD_META_CLASS, ScaffoldRow } from '@/components/chat/scaffold-row'
+import {
+  SCAFFOLD_GLYPH_CLASS,
+  SCAFFOLD_LABEL_CLASS,
+  SCAFFOLD_META_CLASS,
+  ScaffoldRow
+} from '@/components/chat/scaffold-row'
 import { ZoomableImage } from '@/components/chat/zoomable-image'
 import { Button } from '@/components/ui/button'
 import { Codicon } from '@/components/ui/codicon'
@@ -84,7 +89,7 @@ const SEARCH_HIT_TITLE_CLASS =
 const TOOL_HEADER_SUBTITLE_CLASS =
   'text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)'
 
-const TOOL_HEADER_GLYPH_WRAP_CLASS = 'grid size-3.5 shrink-0 place-items-center self-center'
+const TOOL_HEADER_GLYPH_WRAP_CLASS = cn(SCAFFOLD_GLYPH_CLASS, 'self-center')
 
 // Glass-style section label that sits above any pre/JSON/output block.
 // Lowercase tracking + tiny size so it reads as a quiet field label rather
diff --git a/apps/desktop/src/components/chat/intro.tsx b/apps/desktop/src/components/chat/intro.tsx
index 6dc365e644fd..dd675e32dbc6 100644
--- a/apps/desktop/src/components/chat/intro.tsx
+++ b/apps/desktop/src/components/chat/intro.tsx
@@ -1,8 +1,9 @@
-import { type CSSProperties, useState } from 'react'
+import { useState } from 'react'
 
 import { capitalize, normalize } from '@/lib/text'
 
 import introCopyJsonl from './intro-copy.jsonl?raw'
+import { Wordmark } from './wordmark'
 
 type IntroCopy = {
   headline: string
@@ -166,16 +167,7 @@ export function Intro({ personality, seed }: IntroProps) {
       data-slot="aui_intro"
     >
       <div className="w-full min-w-0">
-        <p
-          aria-label={WORDMARK}
-          className="fit-text mx-auto mb-1 w-[calc(100%-1rem)] font-['Collapse'] font-bold uppercase leading-[0.9] tracking-[0.08em] text-midground mix-blend-plus-lighter dark:text-foreground/90"
-          style={{ '--fit-min': '2.75rem' } as CSSProperties}
-        >
-          <span>
-            <span>{WORDMARK}</span>
-          </span>
-          <span aria-hidden="true">{WORDMARK}</span>
-        </p>
+        <Wordmark className="mb-1" text={WORDMARK} />
 
         <p className="m-0 text-center leading-normal tracking-tight">{copy.body}</p>
       </div>
diff --git a/apps/desktop/src/components/chat/scaffold-row.tsx b/apps/desktop/src/components/chat/scaffold-row.tsx
index e192837511e9..c16bf3187529 100644
--- a/apps/desktop/src/components/chat/scaffold-row.tsx
+++ b/apps/desktop/src/components/chat/scaffold-row.tsx
@@ -22,6 +22,10 @@ export const SCAFFOLD_LABEL_CLASS =
 /** Durations, counts and diff stats trailing a scaffold label. */
 export const SCAFFOLD_META_CLASS = 'shrink-0 text-[0.625rem] tabular-nums text-(--conversation-scaffold-meta)'
 
+/** The fixed cell a scaffold line's leading glyph sits in — status dot, tool
+ *  icon, spinner. Same box on every line, so the labels share a left edge. */
+export const SCAFFOLD_GLYPH_CLASS = 'grid size-3.5 shrink-0 place-items-center'
+
 /**
  * One scaffold line. `children` is the label and whatever trails it in flow
  * (meta, diff counts); `trailing` reserves a right-side slot for a live timer.
diff --git a/apps/desktop/src/components/chat/wordmark.tsx b/apps/desktop/src/components/chat/wordmark.tsx
new file mode 100644
index 000000000000..6be1230e8c37
--- /dev/null
+++ b/apps/desktop/src/components/chat/wordmark.tsx
@@ -0,0 +1,45 @@
+import type { CSSProperties } from 'react'
+
+import { cn } from '@/lib/utils'
+
+/**
+ * The oversized display lettering of an empty chat — the Collapse face that
+ * writes "HERMES AGENT" across a fresh draft, and a bot's name across its own
+ * empty chat.
+ *
+ * The doubled children are load-bearing, not a typo: `.fit-text` sizes the
+ * visible span from a container query and needs the `aria-hidden` twin laid
+ * out beside it as the width reference. Anything that renders this lettering
+ * comes through here rather than restating that structure.
+ */
+export function Wordmark({
+  className,
+  fitMin = '2.75rem',
+  text,
+  width = 'calc(100% - 1rem)'
+}: {
+  className?: string
+  /** Floor for the fitted font size, as a CSS length. */
+  fitMin?: string
+  text: string
+  /** How much of the column the lettering spans. `.fit-text` sizes to fill
+   *  this, so a short word set at full width comes out enormous — a name gets
+   *  less room than a twelve-character wordmark. */
+  width?: string
+}) {
+  return (
+    <p
+      aria-label={text}
+      className={cn(
+        'wordmark fit-text mx-auto text-midground mix-blend-plus-lighter dark:text-foreground/90',
+        className
+      )}
+      style={{ '--fit-min': fitMin, width } as CSSProperties}
+    >
+      <span>
+        <span>{text}</span>
+      </span>
+      <span aria-hidden="true">{text}</span>
+    </p>
+  )
+}
diff --git a/apps/desktop/src/components/pane-shell/tree/renderer/main-placement-floor.test.tsx b/apps/desktop/src/components/pane-shell/tree/renderer/main-placement-floor.test.tsx
new file mode 100644
index 000000000000..a23e3244c4f7
--- /dev/null
+++ b/apps/desktop/src/components/pane-shell/tree/renderer/main-placement-floor.test.tsx
@@ -0,0 +1,98 @@
+import { cleanup, render } from '@testing-library/react'
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { registry } from '@/contrib/registry'
+import { stubResizeObserver } from '@/test/jsdom'
+
+import { group, split } from '../model'
+import { $hiddenTreePanes, $layoutTree } from '../store'
+
+import { subtreeGone, type TrackContext } from './track-model'
+import { TreeSplit } from './tree-split'
+
+// Ground truth for "the main pane always shows, no matter what". Emptying the
+// main strip must never let a sibling absorb the center — the failure Bot Mode
+// shipped, where closing the last bot chat left the roster sidebar stretched
+// across the whole window. Chrome toggles over a tool panel must still collapse.
+
+beforeAll(() => {
+  stubResizeObserver()
+  // jsdom lacks CSS.escape, which tab-strip-scroll uses in a layout effect.
+  vi.stubGlobal('CSS', { ...globalThis.CSS, escape: (value: string) => value })
+})
+
+const disposers: (() => void)[] = []
+
+beforeEach(() => {
+  window.localStorage.clear()
+  $hiddenTreePanes.set(new Set())
+
+  for (const [id, data] of [
+    ['sessions', { placement: 'left', width: '237px' }],
+    ['workspace', { placement: 'main', uncloseable: true }],
+    ['session-tile:a', { placement: 'main' }],
+    ['terminal', { placement: 'bottom', height: '38vh' }]
+  ] as const) {
+    disposers.push(registry.register({ area: 'panes', data, id, render: () => null, title: id }))
+  }
+})
+
+afterEach(() => {
+  cleanup()
+  $hiddenTreePanes.set(new Set())
+  $layoutTree.set(null)
+  disposers.splice(0).forEach(dispose => dispose())
+})
+
+/** The split-child WRAPPER the renderer sizes — `display:none` on it is what
+ *  hands a zone's space to its siblings. */
+const zoneWrapper = (groupId: string) =>
+  document.querySelector<HTMLElement>(`[data-tree-group="${groupId}"]`)?.closest<HTMLElement>('[style]')
+
+const ctx = (gone: string[]): TrackContext => ({
+  overrides: {},
+  paneFor: id => registry.getArea('panes').find(pane => pane.id === id),
+  paneGone: id => gone.includes(id)
+})
+
+describe('subtreeGone', () => {
+  it('keeps a main-bearing subtree even when every one of its panes is gone', () => {
+    const main = group(['workspace', 'session-tile:a'], { id: 'grp-main' })
+
+    expect(subtreeGone(main, ctx(['workspace', 'session-tile:a']))).toBe(false)
+  })
+
+  it('still collapses a tool zone whose panes a chrome toggle hid', () => {
+    expect(subtreeGone(group(['terminal'], { id: 'grp-tools' }), ctx(['terminal']))).toBe(true)
+  })
+
+  it('still collapses a main pane whose plugin has not registered yet', () => {
+    // No contribution means no placement to read — the zone stays folded until
+    // the plugin loads rather than flashing an empty placeholder.
+    expect(subtreeGone(group(['plugin-workspace:late'], { id: 'grp-late' }), ctx(['plugin-workspace:late']))).toBe(true)
+  })
+})
+
+describe('the main placement floor in the renderer', () => {
+  it('renders the main zone with every main tab hidden, and leaves tool zones absorbable', () => {
+    const tree = split('row', [
+      group(['sessions'], { id: 'grp-sessions' }),
+      split('column', [
+        group(['workspace', 'session-tile:a'], { id: 'grp-main' }),
+        group(['terminal'], { id: 'grp-tools' })
+      ])
+    ])
+
+    $layoutTree.set(tree)
+    $hiddenTreePanes.set(new Set(['workspace', 'session-tile:a', 'terminal']))
+
+    render(<TreeSplit node={tree} root rootRow />)
+
+    const main = zoneWrapper('grp-main')
+
+    expect(main).toBeTruthy()
+    expect(main!.style.display).not.toBe('none')
+    expect(zoneWrapper('grp-sessions')?.style.display).not.toBe('none')
+    expect(zoneWrapper('grp-tools')?.style.display).toBe('none')
+  })
+})
diff --git a/apps/desktop/src/components/pane-shell/tree/renderer/track-model.ts b/apps/desktop/src/components/pane-shell/tree/renderer/track-model.ts
index 1a0dacc02304..a6be611dd85e 100644
--- a/apps/desktop/src/components/pane-shell/tree/renderer/track-model.ts
+++ b/apps/desktop/src/components/pane-shell/tree/renderer/track-model.ts
@@ -47,6 +47,11 @@ export interface PaneSizing {
 interface PaneChrome extends PaneSizing {
   /** Leaves the grid on narrow viewports; revealed as an edge overlay. */
   collapsible?: boolean
+  /** Arrive minimized — a rail tab rather than an open zone. For a pane that
+   *  docks to an edge this is the vertical strip; the user's first expand is
+   *  persisted on the zone and wins from then on. Applied when the pane ENTERS
+   *  the tree, not on every boot, so it is a default and not an invariant. */
+  defaultCollapsed?: boolean
   /** Extra ids accepted from PANE_TOGGLE_REVEAL_EVENT (the real app's pane
    *  ids, e.g. `chat-sidebar` for `sessions`). */
   revealAliases?: string[]
@@ -283,11 +288,27 @@ export function fixedTrackSize(node: LayoutNode, axis: 'row' | 'column', ctx: Tr
   return cssMax(sizes) ?? null
 }
 
-/** True when every pane in the subtree is hidden/narrow-collapsed. */
+/**
+ * True when every pane in the subtree is hidden/narrow-collapsed — the zone
+ * renders `display:none` and its siblings absorb the space.
+ *
+ * MAIN IS THE FLOOR. A subtree that hosts a registered `placement: 'main'`
+ * pane never goes, however many of its tabs are gone: absorbing the main zone
+ * leaves the window with nothing but chrome, and the sidebar stretched across
+ * where the app used to be. (Bot Mode reached exactly that state by filtering
+ * every sessions-scoped tile out of the center and then closing its last bot
+ * chat.) An emptied main zone renders its own placeholder instead. Chrome
+ * toggles over a terminal, a review rail or an unregistered plugin pane still
+ * collapse and still hand their space to their neighbors.
+ */
 export function subtreeGone(node: LayoutNode, ctx: TrackContext): boolean {
   const ids = allPaneIds(node)
 
-  return ids.length > 0 && ids.every(ctx.paneGone)
+  if (ids.length === 0 || !ids.every(ctx.paneGone)) {
+    return false
+  }
+
+  return !ids.some(id => paneChrome(ctx.paneFor(id)).placement === 'main')
 }
 
 /**
diff --git a/apps/desktop/src/components/pane-shell/tree/renderer/tree-group.tsx b/apps/desktop/src/components/pane-shell/tree/renderer/tree-group.tsx
index 354ab4562320..d5f9428a4cac 100644
--- a/apps/desktop/src/components/pane-shell/tree/renderer/tree-group.tsx
+++ b/apps/desktop/src/components/pane-shell/tree/renderer/tree-group.tsx
@@ -39,7 +39,6 @@ import { hiddenPaneProps, PaneGroupContext, PaneLifecycleContext, PaneVisibleCon
 import {
   $workspaceMode,
   $workspaceOwnerKey,
-  contributesToWorkspace,
   rememberActivePane,
   resolveRememberedActivePane,
   workspaceScopeKey
@@ -268,10 +267,7 @@ export function TreeGroup({
   // Edit mode forces toggle-hidden panes visible so they can be rearranged
   // (mirrors tree-split's paneGone) — restores itself on exit.
   const paneShown = (id: string) =>
-    Boolean(paneFor(id)) &&
-    contributesToWorkspace(paneFor(id), workspaceMode, workspaceOwnerKey) &&
-    (editMode || !hiddenPanes.has(id)) &&
-    !(narrow && paneChrome(paneFor(id)).collapsible)
+    Boolean(paneFor(id)) && (editMode || !hiddenPanes.has(id)) && !(narrow && paneChrome(paneFor(id)).collapsible)
 
   const shown = node.panes.filter(paneShown)
   const memoryKey = workspaceScopeKey(workspaceMode, workspaceOwnerKey)
diff --git a/apps/desktop/src/components/pane-shell/tree/renderer/tree-split.tsx b/apps/desktop/src/components/pane-shell/tree/renderer/tree-split.tsx
index c72faa80f853..15b44edf02c7 100644
--- a/apps/desktop/src/components/pane-shell/tree/renderer/tree-split.tsx
+++ b/apps/desktop/src/components/pane-shell/tree/renderer/tree-split.tsx
@@ -17,7 +17,6 @@ import { cn } from '@/lib/utils'
 import { $paneStates, type PaneStateSnapshot, setPaneHeightOverride, setPaneWidthOverride } from '@/store/panes'
 
 import { $layoutEditMode } from '../../edit-mode'
-import { $workspaceMode, $workspaceOwnerKey, contributesToWorkspace } from '../../workspace-scope'
 import type { LayoutNode, SplitNode } from '../model'
 import { allPaneIds } from '../model'
 import {
@@ -92,8 +91,6 @@ export function TreeSplit({ node, root, rootRow }: { node: SplitNode; root?: boo
   const panes = useContributions('panes')
   const hiddenPanes = useStore($hiddenTreePanes)
   const narrow = useStore($narrowViewport)
-  const workspaceMode = useStore($workspaceMode)
-  const workspaceOwnerKey = useStore($workspaceOwnerKey)
   // Scoped to THIS subtree's panes: a sash drag writes size overrides on every
   // pointermove, but only the splits whose subtree actually resized should
   // re-render — not every split in the tree.
@@ -128,10 +125,7 @@ export function TreeSplit({ node, root, rootRow }: { node: SplitNode; root?: boo
   // closed) visible so they're rearrangeable — only truly-absent (unregistered)
   // or narrow-collapsed panes stay gone. Restores itself on exit (render-only).
   const paneGone = (id: string) =>
-    !paneFor(id) ||
-    !contributesToWorkspace(paneFor(id), workspaceMode, workspaceOwnerKey) ||
-    (!editMode && hiddenPanes.has(id)) ||
-    (narrow && Boolean(paneChrome(paneFor(id)).collapsible))
+    !paneFor(id) || (!editMode && hiddenPanes.has(id)) || (narrow && Boolean(paneChrome(paneFor(id)).collapsible))
 
   const trackCtx: TrackContext = { paneFor, paneGone, overrides }
 
diff --git a/apps/desktop/src/components/pane-shell/tree/renderer/workspace-scope.test.tsx b/apps/desktop/src/components/pane-shell/tree/renderer/workspace-scope.test.tsx
deleted file mode 100644
index 1f88eb5628c4..000000000000
--- a/apps/desktop/src/components/pane-shell/tree/renderer/workspace-scope.test.tsx
+++ /dev/null
@@ -1,139 +0,0 @@
-import { act, type ReactNode } from 'react'
-import { createRoot, type Root } from 'react-dom/client'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import { setWorkspaceScope } from '@/components/pane-shell/workspace-scope'
-import { registry } from '@/contrib/registry'
-
-import type { GroupNode } from '../model'
-
-import { TreeGroup } from './tree-group'
-
-let root: null | Root = null
-let container: HTMLDivElement | null = null
-const disposers: Array<() => void> = []
-
-function render(ui: ReactNode) {
-  if (!container) {
-    container = globalThis.document.createElement('div')
-    globalThis.document.body.append(container)
-    root = createRoot(container)
-  }
-
-  act(() => root!.render(ui))
-}
-
-function register(
-  id: string,
-  title: string,
-  scope: { workspaceMode?: 'sessions' | 'bots'; workspaceOwnerKey?: string } = {}
-) {
-  disposers.push(
-    registry.register({
-      area: 'panes',
-      data: { placement: 'main' },
-      id,
-      render: () => <div>{title} content</div>,
-      title,
-      ...scope
-    })
-  )
-}
-
-const group = (active: string): GroupNode => ({
-  active,
-  id: 'workspace-scope-zone',
-  panes: ['session-a', 'bot-a', 'bot-b'],
-  tabStrip: 'always',
-  type: 'group'
-})
-
-const visibleTabs = () =>
-  [...globalThis.document.querySelectorAll<HTMLElement>('[data-tree-tab]')].map(tab => tab.dataset.treeTab)
-
-afterEach(() => {
-  if (root) {
-    act(() => root!.unmount())
-  }
-
-  container?.remove()
-  disposers.splice(0).forEach(dispose => dispose())
-  act(() => {
-    setWorkspaceScope('sessions')
-  })
-  root = null
-  container = null
-  vi.unstubAllGlobals()
-})
-
-describe('TreeGroup workspace scope', () => {
-  it('renders only the current workspace owner and restores owner activity', () => {
-    vi.stubGlobal('CSS', { escape: (value: string) => value })
-    register('session-a', 'Session A', { workspaceMode: 'sessions' })
-    register('bot-a', 'Bot A', { workspaceMode: 'bots', workspaceOwnerKey: 'connection-a::default' })
-    register('bot-b', 'Bot B', { workspaceMode: 'bots', workspaceOwnerKey: 'connection-b::default' })
-
-    render(<TreeGroup node={group('session-a')} parentAxis="column" />)
-    expect(visibleTabs()).toEqual(['session-a'])
-    expect(container?.textContent).toContain('Session A content')
-
-    act(() => setWorkspaceScope('bots', 'connection-a::default'))
-    render(<TreeGroup node={group('bot-a')} parentAxis="column" />)
-    expect(visibleTabs()).toEqual(['bot-a'])
-    expect(container?.textContent).toContain('Bot A content')
-
-    act(() => setWorkspaceScope('bots', 'connection-b::default'))
-    render(<TreeGroup node={group('bot-b')} parentAxis="column" />)
-    expect(visibleTabs()).toEqual(['bot-b'])
-    expect(container?.textContent).toContain('Bot B content')
-
-    act(() => setWorkspaceScope('bots', 'connection-a::default'))
-    render(<TreeGroup node={group('bot-b')} parentAxis="column" />)
-    expect(visibleTabs()).toEqual(['bot-a'])
-    expect(container?.textContent).toContain('Bot A content')
-
-    act(() => setWorkspaceScope('sessions'))
-    render(<TreeGroup node={group('bot-b')} parentAxis="column" />)
-    expect(visibleTabs()).toEqual(['session-a'])
-    expect(container?.textContent).toContain('Session A content')
-  })
-
-  it('keeps a global Browser pane visible in Bot Mode', () => {
-    vi.stubGlobal('CSS', { escape: (value: string) => value })
-    register('bot-a', 'Bot A', { workspaceMode: 'bots', workspaceOwnerKey: 'connection-a::default' })
-    register('preview-tile:url:browser', 'Browser')
-
-    const node: GroupNode = {
-      active: 'bot-a',
-      id: 'workspace-scope-zone',
-      panes: ['bot-a', 'preview-tile:url:browser'],
-      tabStrip: 'always',
-      type: 'group'
-    }
-
-    act(() => setWorkspaceScope('bots', 'connection-a::default'))
-    render(<TreeGroup node={node} parentAxis="column" />)
-
-    expect(visibleTabs()).toEqual(['bot-a', 'preview-tile:url:browser'])
-  })
-
-  it('hides a Sessions-only Browser pane in Bot Mode', () => {
-    vi.stubGlobal('CSS', { escape: (value: string) => value })
-    register('bot-a', 'Bot A', { workspaceMode: 'bots', workspaceOwnerKey: 'connection-a::default' })
-    register('preview-tile:url:browser', 'Browser', { workspaceMode: 'sessions' })
-
-    const node: GroupNode = {
-      active: 'bot-a',
-      id: 'workspace-scope-zone',
-      panes: ['bot-a', 'preview-tile:url:browser'],
-      tabStrip: 'always',
-      type: 'group'
-    }
-
-    act(() => setWorkspaceScope('bots', 'connection-a::default'))
-    render(<TreeGroup node={node} parentAxis="column" />)
-
-    expect(visibleTabs()).toEqual(['bot-a'])
-    expect(container?.textContent).not.toContain('Browser content')
-  })
-})
diff --git a/apps/desktop/src/components/pane-shell/tree/store.ts b/apps/desktop/src/components/pane-shell/tree/store.ts
index 931d712003f3..a451e570e338 100644
--- a/apps/desktop/src/components/pane-shell/tree/store.ts
+++ b/apps/desktop/src/components/pane-shell/tree/store.ts
@@ -1326,7 +1326,8 @@ function adoptContributedPanes(): void {
   const panes = registry.getArea('panes')
 
   const dataOf = (paneId: string) =>
-    panes.find(c => c.id === paneId)?.data as { placement?: string; dock?: PaneDockHint } | undefined
+    panes.find(c => c.id === paneId)?.data as
+      { defaultCollapsed?: boolean; dock?: PaneDockHint; placement?: string } | undefined
 
   const placementOf = (paneId: string) => dataOf(paneId)?.placement
   const mainId = panes.find(c => placementOf(c.id) === 'main')?.id
@@ -1392,6 +1393,17 @@ function adoptContributedPanes(): void {
   if (next !== tree) {
     commit(next)
   }
+
+  // After the commit, so the zone exists to minimize. `defaultCollapsed` is the
+  // pane's arrival state, not a standing invariant: it runs on the adoption
+  // that put the pane in the tree, and a pane already in the tree is never
+  // re-adopted — so a user's expand persists with the layout and is never
+  // overruled on a later boot.
+  for (const pane of missing) {
+    if (dataOf(pane.id)?.defaultCollapsed) {
+      setPaneCollapsed(pane.id, true)
+    }
+  }
 }
 
 /** Adopt now + on every registry change (call once from the app root). */
diff --git a/apps/desktop/src/components/pane-shell/workspace-scope.test.ts b/apps/desktop/src/components/pane-shell/workspace-scope.test.ts
index 49686f0f7bda..e90d5cb02a8a 100644
--- a/apps/desktop/src/components/pane-shell/workspace-scope.test.ts
+++ b/apps/desktop/src/components/pane-shell/workspace-scope.test.ts
@@ -4,8 +4,6 @@ import {
   $workspaceMode,
   $workspaceNewSessionTarget,
   $workspaceOwnerKey,
-  contributesToWorkspace,
-  filterContributionsForWorkspace,
   forgetActivePane,
   forgetRememberedPane,
   rememberActivePane,
@@ -14,23 +12,6 @@ import {
   setWorkspaceScope
 } from './workspace-scope'
 
-interface ScopedContribution {
-  id: string
-  workspaceMode?: 'sessions' | 'bots'
-  workspaceOwnerKey?: string
-}
-
-const contribution = (
-  id: string,
-  scope?: Pick<ScopedContribution, 'workspaceMode' | 'workspaceOwnerKey'>
-): ScopedContribution => ({ id, ...scope })
-
-const bot = (ownerKey: string, suffix: string) =>
-  contribution(`bot:${suffix}`, {
-    workspaceMode: 'bots',
-    workspaceOwnerKey: ownerKey
-  })
-
 afterEach(() => {
   setWorkspaceScope('sessions')
 })
@@ -76,7 +57,7 @@ describe('workspace scope', () => {
     expect($workspaceNewSessionTarget.get()).toBeNull()
   })
 
-  it('keeps a group owner explicit while blocking generic session creation', () => {
+  it('keeps a group owner explicit while publishing why it has no generic route', () => {
     const target = { kind: 'blocked' as const, message: 'New group conversations start in the group composer.' }
 
     setWorkspaceScope('bots', 'group:room-1', target)
@@ -84,73 +65,6 @@ describe('workspace scope', () => {
     expect($workspaceOwnerKey.get()).toBe('group:room-1')
     expect($workspaceNewSessionTarget.get()).toEqual(target)
   })
-
-  it('keeps global contributions visible in both modes', () => {
-    expect(contributesToWorkspace(undefined, 'sessions', null)).toBe(true)
-    expect(contributesToWorkspace(undefined, 'bots', 'bot-a')).toBe(true)
-  })
-
-  it('separates sessions and bots contributions by mode', () => {
-    const sessionsOnly = contribution('sessions-pane', { workspaceMode: 'sessions' })
-    const botsOnly = bot('bot-a', 'pane')
-
-    expect(contributesToWorkspace(sessionsOnly, 'sessions')).toBe(true)
-    expect(contributesToWorkspace(sessionsOnly, 'bots', 'bot-a')).toBe(false)
-    expect(contributesToWorkspace(botsOnly, 'sessions')).toBe(false)
-    expect(contributesToWorkspace(botsOnly, 'bots', 'bot-a')).toBe(true)
-  })
-
-  it('requires an exact non-empty owner match for bots contributions', () => {
-    const scoped = bot('bot-a', 'pane')
-
-    expect(contributesToWorkspace(scoped, 'bots', 'bot-b')).toBe(false)
-    expect(contributesToWorkspace(scoped, 'bots', null)).toBe(false)
-    expect(contributesToWorkspace(scoped, 'bots', '')).toBe(false)
-    expect(contributesToWorkspace(scoped, 'bots', 'bot-a')).toBe(true)
-
-    // A bots-scoped contribution with an empty owner key never participates.
-    const noOwner = contribution('no-owner', { workspaceMode: 'bots' })
-    expect(contributesToWorkspace(noOwner, 'bots', 'bot-a')).toBe(false)
-  })
-
-  it('does not collide on shared profile suffixes across connection-qualified keys', () => {
-    // Same profile suffix, different connections — opaque exact strings only.
-    const localProfile = bot('local:main', 'main')
-    const remoteProfile = bot('ssh:server:main', 'main')
-
-    expect(contributesToWorkspace(localProfile, 'bots', 'ssh:server:main')).toBe(false)
-    expect(contributesToWorkspace(remoteProfile, 'bots', 'local:main')).toBe(false)
-    expect(contributesToWorkspace(localProfile, 'bots', 'local:main')).toBe(true)
-    expect(contributesToWorkspace(remoteProfile, 'bots', 'ssh:server:main')).toBe(true)
-  })
-})
-
-describe('filterContributionsForWorkspace', () => {
-  it('filters to the current mode and preserves input order', () => {
-    const contributions = [
-      bot('bot-a', 'zeta'),
-      contribution('global-1'),
-      contribution('sessions-only', { workspaceMode: 'sessions' }),
-      bot('bot-a', 'alpha')
-    ]
-
-    expect(filterContributionsForWorkspace(contributions, 'bots', 'bot-a').map(c => c.id)).toEqual([
-      'bot:zeta',
-      'global-1',
-      'bot:alpha'
-    ])
-    expect(filterContributionsForWorkspace(contributions, 'sessions', null).map(c => c.id)).toEqual([
-      'global-1',
-      'sessions-only'
-    ])
-  })
-
-  it('returns the original array reference on a no-op', () => {
-    const contributions: ScopedContribution[] = [contribution('a'), contribution('b')]
-
-    expect(filterContributionsForWorkspace(contributions, 'sessions', null)).toBe(contributions)
-    expect(filterContributionsForWorkspace(contributions, 'bots', 'anything').length).toBe(2)
-  })
 })
 
 describe('remembered active panes', () => {
diff --git a/apps/desktop/src/components/pane-shell/workspace-scope.ts b/apps/desktop/src/components/pane-shell/workspace-scope.ts
index c9770d8977c2..7b62390908a8 100644
--- a/apps/desktop/src/components/pane-shell/workspace-scope.ts
+++ b/apps/desktop/src/components/pane-shell/workspace-scope.ts
@@ -1,11 +1,14 @@
 /**
- * Workspace scoping for contributions.
- *
- * Pure presentation-ownership helpers: which workspace surface (sessions vs
- * bots) a contribution belongs to, and — within the bots surface — which exact
- * bot it belongs to. Owner keys are opaque exact strings supplied by callers;
+ * Which workspace surface the window is looking at — sessions, or one exact
+ * bot inside Bot Mode. Owner keys are opaque exact strings supplied by callers;
  * this module never parses profile names or infers connections.
  *
+ * This is a SIGNAL, not a filter: consumers adapt to it — the `+` routes a new
+ * session at the selected bot's profile — but nothing here decides whether a
+ * pane renders. Scoping panes by workspace is how the main zone came to vanish
+ * when Bot Mode's last chat closed; bot chats are ordinary tabs in the main
+ * strip, beside session tabs.
+ *
  * No persistence here by design: the remembered active-pane map is window-local
  * memory so a switch away and back can restore where the user was, without any
  * of it surviving the window.
@@ -33,12 +36,14 @@ export interface WorkspaceSessionRoute {
   targetProfile?: string
 }
 
-/** What the shared `+` / session.newTab command means in this workspace. */
+/** Where the shared `+` / session.newTab command should aim in this workspace.
+ *  `blocked` states why this owner has no route of its own (a group chat, an
+ *  orphaned roster row) — it never disables the `+`, which falls back to an
+ *  ordinary session: bot chats and session tabs share the one main strip. */
 export type WorkspaceNewSessionTarget =
   { kind: 'blocked'; message: string } | { kind: 'route'; route: WorkspaceSessionRoute }
 
-/** Sessions uses its established ambient behavior (`null`). Bots publishes an
- *  exact route or a concise reason that a generic session is unavailable. */
+/** Sessions uses its established ambient behavior (`null`). */
 export const $workspaceNewSessionTarget = atom<WorkspaceNewSessionTarget | null>(null)
 
 /** One key for window-local active-pane memory. Owner keys stay opaque. */
@@ -71,9 +76,9 @@ function sameNewSessionTarget(a: WorkspaceNewSessionTarget | null, b: WorkspaceN
   return false
 }
 
-/** Publish one coherent presentation and creation scope without an
- *  intermediate mixed frame. Sessions always retains its existing ambient
- *  new-session behavior; alternate workspaces must state their intent. */
+/** Publish one coherent surface and creation scope without an intermediate
+ *  mixed frame. Sessions always retains its existing ambient new-session
+ *  behavior; alternate workspaces must state their intent. */
 export function setWorkspaceScope(
   mode: WorkspaceMode,
   ownerKey: string | null = null,
@@ -99,78 +104,6 @@ export function setWorkspaceScope(
   return true
 }
 
-/**
- * The slice of {@link Contribution} metadata that scopes it to a workspace.
- * A contribution with neither field set is global: it participates in every
- * workspace, preserving pre-existing behavior.
- */
-export interface WorkspaceScope {
-  /** Surface this contribution belongs to. Omit for global visibility. */
-  workspaceMode?: WorkspaceMode
-  /** Exact opaque owner key within the `'bots'` surface. Ignored otherwise. */
-  workspaceOwnerKey?: string
-}
-
-/**
- * Whether a contribution participates in the given workspace.
- *
- * - Unscoped/global (no `workspaceMode`) => always participates.
- * - Scoped with a mode mismatch => does not participate.
- * - Sessions match => participates.
- * - Bots match => participates only when the owner key is non-empty and equals
- *   the current owner key (exact string equality).
- *
- * Defaults reflect the un-switched window state when omitted.
- */
-export function contributesToWorkspace(
-  scope: WorkspaceScope | undefined,
-  mode: WorkspaceMode = $workspaceMode.get(),
-  ownerKey: string | null = $workspaceOwnerKey.get()
-): boolean {
-  const { workspaceMode, workspaceOwnerKey } = scope ?? {}
-
-  if (workspaceMode == null) {
-    return true
-  }
-
-  if (workspaceMode !== mode) {
-    return false
-  }
-
-  if (workspaceMode === 'sessions') {
-    return true
-  }
-
-  return Boolean(workspaceOwnerKey) && workspaceOwnerKey === ownerKey
-}
-
-/**
- * Filter contributions down to those participating in the given workspace,
- * preserving input order.
- *
- * Preserves reference identity on a no-op (every contribution participates),
- * so callers can hand the result straight to React without a wasted re-render.
- */
-export function filterContributionsForWorkspace<T extends WorkspaceScope>(
-  contributions: readonly T[],
-  mode: WorkspaceMode,
-  ownerKey: string | null
-): readonly T[] {
-  let filtered: T[] | null = null
-
-  for (let i = 0; i < contributions.length; i += 1) {
-    if (contributesToWorkspace(contributions[i], mode, ownerKey)) {
-      filtered?.push(contributions[i])
-
-      continue
-    }
-
-    filtered ??= contributions.slice(0, i)
-  }
-
-  return filtered ?? contributions
-}
-
 /**
  * Window-local memory of the active pane per exact workspace owner key.
  * Keys are opaque exact strings; similar-looking keys never collide because
diff --git a/apps/desktop/src/contrib/types.ts b/apps/desktop/src/contrib/types.ts
index 0958073bfabc..2cd87dc3d196 100644
--- a/apps/desktop/src/contrib/types.ts
+++ b/apps/desktop/src/contrib/types.ts
@@ -10,9 +10,10 @@ import type { ReactNode } from 'react'
 export type ContributionSource = 'core' | (string & {})
 
 /**
- * Which workspace surface a contribution targets. `'sessions'` is the classic
- * session workspace; `'bots'` scopes content to an individual bot identified
- * by an opaque owner key.
+ * Which workspace surface the window is looking at. `'sessions'` is the classic
+ * session workspace; `'bots'` means Bot Mode has one exact bot selected,
+ * identified by an opaque owner key. Consumers ADAPT to this — it steers where
+ * the `+` routes — but it never decides whether a pane renders.
  */
 export type WorkspaceMode = 'sessions' | 'bots'
 
@@ -47,16 +48,4 @@ export interface Contribution {
    * themes, commands — anything consumed by an engine rather than rendered.
    */
   data?: unknown
-  /**
-   * Which workspace surface this contribution belongs to. Omit for a global
-   * contribution that participates in every workspace (pre-existing behavior).
-   * Presentation ownership hint only.
-   */
-  workspaceMode?: WorkspaceMode
-  /**
-   * Exact opaque owner key within the `'bots'` surface (e.g. a
-   * connection-qualified profile id). Never parsed here; compared exactly.
-   * Presentation ownership hint only.
-   */
-  workspaceOwnerKey?: string
 }
diff --git a/apps/desktop/src/lib/chat-empty.ts b/apps/desktop/src/lib/chat-empty.ts
new file mode 100644
index 000000000000..adacd0df8806
--- /dev/null
+++ b/apps/desktop/src/lib/chat-empty.ts
@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react'
+
+/**
+ * CHAT EMPTY STATE — the blank transcript as a contribution area.
+ *
+ * Core owns exactly one empty state: the intro splash, which belongs to a
+ * fresh draft with no session selected. A session that exists but has nothing
+ * in it yet falls outside that — and whoever opened it is the only one who
+ * knows what should stand in the gap. A bot's chat wants the bot's face and
+ * name; core has neither, and should not learn them.
+ *
+ * So the slot is contributed. A plugin claims the sessions it owns by
+ * returning an element for them and `null` for everything else, which is also
+ * how it stands down while the transcript is still hydrating.
+ *
+ * Ownership is per session, so EVERY registration is mounted and each answers
+ * for itself. Declining is free; two plugins claiming one session render both,
+ * which is the visible cost of never letting registration order silently
+ * suppress the plugin that actually owns the chat.
+ */
+
+export const CHAT_EMPTY_AREA = 'chat.empty'
+
+/** Props handed to a chat-empty contribution's `render`. */
+export interface ChatEmptyProps {
+  /** The live session whose transcript is empty. */
+  sessionId: string
+}
+
+/** Payload of a `chat.empty` contribution's `data`. */
+export interface ChatEmptyContribution {
+  /** Renders the empty state, or returns `null` to decline the session and
+   *  leave the transcript blank. Mounted as a component inside the
+   *  contribution error boundary, so it can subscribe to its own stores and
+   *  appear once they load — the roster a bot chat needs arrives after the
+   *  transcript does. A throw degrades to an inline error, not a dead chat. */
+  render: (props: ChatEmptyProps) => ReactNode
+}
diff --git a/apps/desktop/src/lib/katex-memo.ts b/apps/desktop/src/lib/katex-memo.ts
index 7143fbff905f..a7bba94f9bc5 100644
--- a/apps/desktop/src/lib/katex-memo.ts
+++ b/apps/desktop/src/lib/katex-memo.ts
@@ -45,6 +45,8 @@ import type { Pluggable } from 'unified'
 import { SKIP, visitParents } from 'unist-util-visit-parents'
 import type { VFile } from 'vfile'
 
+import { LruCache } from '@/lib/lru-cache'
+
 interface KatexMemoOptions {
   /**
    * Color used for KaTeX errors when we fall back to the lenient parser.
@@ -69,40 +71,7 @@ type CachedRender = ElementContent[]
 
 const CACHE_LIMIT = 512
 
-class LruCache<K, V> {
-  private readonly map = new Map<K, V>()
-
-  get(key: K): undefined | V {
-    const value = this.map.get(key)
-
-    if (value === undefined) {
-      return undefined
-    }
-
-    // Refresh recency by re-inserting at the tail. Map iteration order is
-    // insertion order, so the oldest entry is at the head.
-    this.map.delete(key)
-    this.map.set(key, value)
-
-    return value
-  }
-
-  set(key: K, value: V): void {
-    if (this.map.has(key)) {
-      this.map.delete(key)
-    } else if (this.map.size >= CACHE_LIMIT) {
-      const oldest = this.map.keys().next().value
-
-      if (oldest !== undefined) {
-        this.map.delete(oldest)
-      }
-    }
-
-    this.map.set(key, value)
-  }
-}
-
-const cache = new LruCache<string, CachedRender>()
+const cache = new LruCache<string, CachedRender>(CACHE_LIMIT)
 
 function cacheKey(displayMode: boolean, value: string): string {
   // `\u0001` is a control character that (a) won't appear in normal
diff --git a/apps/desktop/src/lib/lru-cache.test.ts b/apps/desktop/src/lib/lru-cache.test.ts
new file mode 100644
index 000000000000..f0529130925a
--- /dev/null
+++ b/apps/desktop/src/lib/lru-cache.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest'
+
+import { LruCache } from './lru-cache'
+
+describe('LruCache', () => {
+  it('never grows past its ceiling', () => {
+    const cache = new LruCache<number, string>(3)
+
+    for (let key = 0; key < 100; key += 1) {
+      cache.set(key, `v${key}`)
+    }
+
+    expect(cache.size).toBe(3)
+    expect([...cache.keys()]).toEqual([97, 98, 99])
+  })
+
+  it('evicts the least recently READ entry, not the least recently written', () => {
+    const cache = new LruCache<string, number>(2)
+
+    cache.set('a', 1)
+    cache.set('b', 2)
+    cache.get('a')
+    cache.set('c', 3)
+
+    expect(cache.get('a')).toBe(1)
+    expect(cache.get('b')).toBeUndefined()
+    expect(cache.get('c')).toBe(3)
+  })
+
+  it('overwrites in place rather than evicting a live neighbour', () => {
+    const cache = new LruCache<string, number>(2)
+
+    cache.set('a', 1)
+    cache.set('b', 2)
+    cache.set('a', 9)
+
+    expect(cache.size).toBe(2)
+    expect(cache.get('a')).toBe(9)
+    expect(cache.get('b')).toBe(2)
+  })
+
+  it('answers membership without promoting the entry', () => {
+    const cache = new LruCache<string, number>(2)
+
+    cache.set('a', 1)
+    cache.set('b', 2)
+    expect(cache.has('a')).toBe(true)
+    cache.set('c', 3)
+
+    expect(cache.has('a')).toBe(false)
+    expect(cache.has('b')).toBe(true)
+  })
+
+  it('frees the slot on delete', () => {
+    const cache = new LruCache<string, number>(2)
+
+    cache.set('a', 1)
+
+    expect(cache.delete('a')).toBe(true)
+    expect(cache.delete('a')).toBe(false)
+    expect(cache.size).toBe(0)
+
+    cache.set('b', 2)
+    cache.set('c', 3)
+
+    expect([...cache.keys()]).toEqual(['b', 'c'])
+  })
+})
diff --git a/apps/desktop/src/lib/lru-cache.ts b/apps/desktop/src/lib/lru-cache.ts
new file mode 100644
index 000000000000..1036bc219e5d
--- /dev/null
+++ b/apps/desktop/src/lib/lru-cache.ts
@@ -0,0 +1,67 @@
+/**
+ * A `Map` with a ceiling. The renderer stays open for days, so a module-level
+ * cache keyed by anything user-driven (a URL, a connection id, an equation)
+ * grows for the life of the window unless something evicts.
+ *
+ * Only for values that can be REGENERATED: eviction costs a recompute or a
+ * refetch, never correctness. State whose loss changes behaviour — an unsent
+ * draft, an unread watermark, a freshness fence — is a record, not a cache,
+ * and belongs in a plain `Map`.
+ */
+export class LruCache<K, V> {
+  private readonly entries = new Map<K, V>()
+  private readonly max: number
+
+  constructor(max: number) {
+    this.max = max
+  }
+
+  get size(): number {
+    return this.entries.size
+  }
+
+  /** Read and mark most-recently-used. */
+  get(key: K): undefined | V {
+    const value = this.entries.get(key)
+
+    if (value === undefined) {
+      return undefined
+    }
+
+    // Map iterates in insertion order, so re-inserting moves the entry to the
+    // tail and leaves the least recently used one at the head.
+    this.entries.delete(key)
+    this.entries.set(key, value)
+
+    return value
+  }
+
+  /** Membership WITHOUT touching recency — for the `has` / `set` / `get`
+   *  populate-on-miss shape, where the `get` does the touching. */
+  has(key: K): boolean {
+    return this.entries.has(key)
+  }
+
+  /** Write, evicting the least recently used entry once the cache is full. */
+  set(key: K, value: V): void {
+    if (this.entries.has(key)) {
+      this.entries.delete(key)
+    } else if (this.entries.size >= this.max) {
+      const oldest = this.entries.keys().next().value
+
+      if (oldest !== undefined) {
+        this.entries.delete(oldest)
+      }
+    }
+
+    this.entries.set(key, value)
+  }
+
+  delete(key: K): boolean {
+    return this.entries.delete(key)
+  }
+
+  keys(): IterableIterator<K> {
+    return this.entries.keys()
+  }
+}
diff --git a/apps/desktop/src/lib/use-session-slice.ts b/apps/desktop/src/lib/use-session-slice.ts
index f96d0017420f..a7399f588b35 100644
--- a/apps/desktop/src/lib/use-session-slice.ts
+++ b/apps/desktop/src/lib/use-session-slice.ts
@@ -61,3 +61,42 @@ export function useStoreSelector<T, S>(store: ReadableStore<T>, select: (value:
 
   return useSyncExternalStore(subscribe, () => selectRef.current(store.get()))
 }
+
+/**
+ * `useStoreSelector` for a scalar whose inputs span SEVERAL stores: recomputes
+ * when any of them notifies, still re-rendering only when the scalar changes.
+ *
+ * Subscribing to one store while the selector reads others is the failure this
+ * exists to prevent — it looks correct for as long as the subscribed store
+ * happens to churn on its own, then silently goes stale when it doesn't. If a
+ * selector reads it, list it.
+ */
+export function useStoresSelector<S>(stores: readonly ReadableStore<unknown>[], select: () => S): S {
+  const selectRef = useRef(select)
+  selectRef.current = select
+
+  // Hold the array identity steady: call sites pass an inline literal of
+  // module-level singletons, so only a genuine store swap should resubscribe.
+  const storesRef = useRef(stores)
+
+  if (storesRef.current.length !== stores.length || storesRef.current.some((store, i) => store !== stores[i])) {
+    storesRef.current = stores
+  }
+
+  const stable = storesRef.current
+
+  const subscribe = useCallback(
+    (onChange: () => void) => {
+      const stops = stable.map(store => store.listen(onChange))
+
+      return () => {
+        for (const stop of stops) {
+          stop()
+        }
+      }
+    },
+    [stable]
+  )
+
+  return useSyncExternalStore(subscribe, () => selectRef.current())
+}
diff --git a/apps/desktop/src/lib/use-stores-selector.test.tsx b/apps/desktop/src/lib/use-stores-selector.test.tsx
new file mode 100644
index 000000000000..c50aff16db4d
--- /dev/null
+++ b/apps/desktop/src/lib/use-stores-selector.test.tsx
@@ -0,0 +1,109 @@
+/**
+ * `useStoresSelector` — the multi-store form of `useStoreSelector`.
+ *
+ * It exists because subscribing to one store while the selector reads another
+ * looks correct for exactly as long as the subscribed store happens to churn
+ * on its own. The composer's bot-chat flag was written that way and rode
+ * `$sessionStates`' per-token republish to stay roughly right.
+ */
+
+import { render, screen } from '@testing-library/react'
+import { atom } from 'nanostores'
+import { act } from 'react'
+import { describe, expect, it, vi } from 'vitest'
+
+import { useStoresSelector } from './use-session-slice'
+
+describe('a selector recomputes for every store it was given', () => {
+  it('follows a change in any of them', () => {
+    const left = atom(0)
+    const right = atom(0)
+
+    function Probe() {
+      const total = useStoresSelector([left, right], () => left.get() + right.get())
+
+      return <span data-testid="total">{total}</span>
+    }
+
+    render(<Probe />)
+
+    expect(screen.getByTestId('total').textContent).toBe('0')
+
+    act(() => left.set(2))
+
+    expect(screen.getByTestId('total').textContent).toBe('2')
+
+    // The store a single-subscription version would have missed.
+    act(() => right.set(5))
+
+    expect(screen.getByTestId('total').textContent).toBe('7')
+  })
+
+  it('re-renders only when the derived scalar actually changes', () => {
+    const source = atom(1)
+    const renders = vi.fn()
+
+    function Probe() {
+      const even = useStoresSelector([source], () => source.get() % 2 === 0)
+      renders()
+
+      return <span data-testid="even">{String(even)}</span>
+    }
+
+    render(<Probe />)
+    const baseline = renders.mock.calls.length
+
+    // 1 -> 3: the store moved, the scalar did not.
+    act(() => source.set(3))
+
+    expect(renders.mock.calls.length).toBe(baseline)
+
+    act(() => source.set(4))
+
+    expect(renders.mock.calls.length).toBeGreaterThan(baseline)
+    expect(screen.getByTestId('even').textContent).toBe('true')
+  })
+
+  it('keeps its subscriptions across renders that pass a fresh array literal', () => {
+    const source = atom(0)
+    const listen = vi.spyOn(source, 'listen')
+
+    function Probe({ label }: { label: string }) {
+      const value = useStoresSelector([source], () => source.get())
+
+      return (
+        <span data-testid="value">
+          {label}
+          {value}
+        </span>
+      )
+    }
+
+    const view = render(<Probe label="a" />)
+    const initial = listen.mock.calls.length
+
+    view.rerender(<Probe label="b" />)
+    view.rerender(<Probe label="c" />)
+
+    expect(listen.mock.calls.length).toBe(initial)
+  })
+
+  it('drops every subscription on unmount', () => {
+    const left = atom(0)
+    const right = atom(0)
+
+    function Probe() {
+      return <span>{useStoresSelector([left, right], () => left.get() + right.get())}</span>
+    }
+
+    const view = render(<Probe />)
+
+    expect(left.lc).toBeGreaterThan(0)
+    expect(right.lc).toBeGreaterThan(0)
+
+    view.unmount()
+
+    expect(left.lc).toBe(0)
+    expect(right.lc).toBe(0)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/avatar-image.ts b/apps/desktop/src/plugins/hermes-bots/avatar-image.ts
new file mode 100644
index 000000000000..1e16b0350343
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/avatar-image.ts
@@ -0,0 +1,147 @@
+/**
+ * Image avatars: the device-upload path and the gateway's `image.generate`
+ * backend (probe + generation). Kept apart from `avatar.tsx` so the roster's
+ * render path doesn't drag the picker's network surface along with it.
+ */
+
+import { atom, host } from '@hermes/plugin-sdk'
+
+import { getPluginCtx } from './shared'
+
+// ── image avatars: upload from device + generate via image.generate ─────────
+
+/** Downscale to a small square so plugin storage stays light. */
+export function normalizeAvatarImage(dataUrl: string, edge = 256): Promise<string> {
+  return new Promise(resolve => {
+    const img = new Image()
+
+    img.onload = () => {
+      try {
+        const canvas = document.createElement('canvas')
+        canvas.width = edge
+        canvas.height = edge
+        const ctx2d = canvas.getContext('2d')!
+        const side = Math.min(img.width, img.height)
+        ctx2d.drawImage(img, (img.width - side) / 2, (img.height - side) / 2, side, side, 0, 0, edge, edge)
+        resolve(canvas.toDataURL('image/png'))
+      } catch {
+        resolve(dataUrl)
+      }
+    }
+
+    img.onerror = () => resolve(dataUrl)
+    img.src = dataUrl
+  })
+}
+
+export function pickImageFromDevice(): Promise<null | string> {
+  return new Promise(resolve => {
+    const input = document.createElement('input')
+    input.type = 'file'
+    input.accept = 'image/png,image/jpeg,image/webp,image/gif'
+
+    input.onchange = () => {
+      const file = input.files?.[0]
+
+      if (!file) {
+        return resolve(null)
+      }
+
+      if (file.size > 15_000_000) {
+        host.notify({
+          kind: 'error',
+          message: getPluginCtx()?.i18n?.t('avatar.imageTooLarge') ?? 'Image too large (max 15MB).'
+        })
+
+        return resolve(null)
+      }
+
+      const reader = new FileReader()
+      reader.onload = () => resolve(typeof reader.result === 'string' ? reader.result : null)
+      reader.onerror = () => resolve(null)
+      reader.readAsDataURL(file)
+    }
+
+    input.click()
+  })
+}
+
+/** Cached probe: does the gateway have an image backend? A `false` answer
+ *  is re-checked on every dialog open — the gateway may have been restarted
+ *  (picking up image.generate) or a backend enabled since the last probe.
+ *  Only `true` is sticky. */
+export const $imagenAvailable = atom<boolean | null>(null)
+let imagenProbeInflight: Promise<void> | null = null
+
+export function probeImagen() {
+  if (imagenProbeInflight) {
+    return imagenProbeInflight
+  }
+
+  imagenProbeInflight = host
+    .request<{ available?: boolean }>('image.generate', {
+      probe: true
+    })
+    .then(res => $imagenAvailable.set(Boolean(res?.available)))
+    .catch(() => $imagenAvailable.set(false))
+    .finally(() => {
+      imagenProbeInflight = null
+    })
+
+  return imagenProbeInflight
+}
+
+/** `image.generate`'s reply. `image_data` is a data URL (works over remote
+ *  gateways); `image` is the raw backend URL fallback. */
+export interface GeneratedImage {
+  error?: string
+  image?: string
+  image_data?: string
+  success?: boolean
+}
+
+export async function generateAvatarImage(
+  bot: string,
+  title?: string,
+  description?: string
+): Promise<string | undefined> {
+  const who = [title || bot, description].filter(Boolean).join(' — ')
+
+  const res = await host.request<GeneratedImage>('image.generate', {
+    prompt:
+      `Cute minimal robot avatar for an AI agent named "${who}". ` +
+      'Friendly simple mascot face, bold flat vector style, solid color background, centered, no text.',
+    aspect_ratio: 'square'
+  })
+
+  if (!res?.success) {
+    throw new Error(res?.error || 'generation failed')
+  }
+
+  // image_data (data URL) works over local AND remote gateways; the raw
+  // backend URL is the fallback when the gateway couldn't inline it.
+  return res.image_data || res.image
+}
+
+/** The roster backfill draws the live SVG at 160x160. Pets are 96x104
+ *  and uploads are 256. Use that to tell a still face-copy from a real picture. */
+export function isBackfilledFacePng(dataUrl: null | string | undefined) {
+  if (!dataUrl || typeof dataUrl !== 'string' || !dataUrl.startsWith('data:image/png;base64,')) {
+    return false
+  }
+
+  try {
+    const bin = atob(dataUrl.slice('data:image/png;base64,'.length).slice(0, 48))
+
+    if (bin.length < 24) {
+      return false
+    }
+
+    const w = (bin.charCodeAt(16) << 24) | (bin.charCodeAt(17) << 16) | (bin.charCodeAt(18) << 8) | bin.charCodeAt(19)
+    const h = (bin.charCodeAt(20) << 24) | (bin.charCodeAt(21) << 16) | (bin.charCodeAt(22) << 8) | bin.charCodeAt(23)
+
+    return w === 160 && h === 160
+  } catch {
+    return false
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/avatar-picker.tsx b/apps/desktop/src/plugins/hermes-bots/avatar-picker.tsx
new file mode 100644
index 000000000000..d448db9e6ae6
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/avatar-picker.tsx
@@ -0,0 +1,295 @@
+/**
+ * The avatar editor shared by Edit Profile and New Bot: shape grid + color
+ * swatches, the Generate and Upload tabs, and the petdex Pet tab.
+ */
+
+import {
+  Button,
+  cn,
+  Codicon,
+  ColorSwatches,
+  GlyphSpinner,
+  host,
+  PROFILE_SWATCHES,
+  RowButton,
+  SegmentedControl,
+  Textarea,
+  useValue
+} from '@hermes/plugin-sdk'
+import { useState } from 'react'
+
+import {
+  AVATAR_PICKER_SHAPES,
+  avatarColor,
+  BLOB_KINDS,
+  blobatarSvg,
+  blobShapeString,
+  BotFace,
+  defaultShapeFor,
+  isBlobShape,
+  parseBlobShape
+} from './avatar'
+import {
+  $imagenAvailable,
+  generateAvatarImage,
+  type GeneratedImage,
+  normalizeAvatarImage,
+  pickImageFromDevice,
+  probeImagen
+} from './avatar-image'
+import { useBots } from './i18n'
+import { PetTab } from './pet'
+
+interface AvatarPickerProps {
+  /** `null` = no explicit pick, i.e. the name's deterministic hue. */
+  color: null | string
+  /** Feeds the Generate tab when the user leaves the description blank. */
+  generateSeed?: { description?: string; name?: string; title?: string } | null
+  image: null | string
+  onColor: (color: null | string) => void
+  onImage: (image: null | string) => void
+  onShape: (shape: string) => void
+  shape: string
+}
+
+/** Shape grid + color swatches, shared by Edit Profile and New Bot. */
+export function AvatarPicker({ shape, color, image, onShape, onColor, onImage, generateSeed }: AvatarPickerProps) {
+  const b = useBots()
+  const pickerName = generateSeed?.name || 'agent'
+  const imagen = useValue($imagenAvailable)
+  const [tab, setTab] = useState('bot')
+  const [describe, setDescribe] = useState('')
+  const [genBusy, setGenBusy] = useState(false)
+
+  if (imagen === null) {
+    void probeImagen()
+  }
+
+  // Re-check a stale "unavailable" whenever the user lands on the Generate
+  // tab — the gateway may have restarted with image.generate since.
+  const goTab = (id: string) => {
+    setTab(id)
+
+    if (id === 'generate' && $imagenAvailable.get() === false) {
+      $imagenAvailable.set(null)
+      void probeImagen()
+    }
+  }
+
+  const upload = async () => {
+    const raw = await pickImageFromDevice()
+
+    if (raw) {
+      onImage(await normalizeAvatarImage(raw))
+    }
+  }
+
+  const generate = async () => {
+    if (genBusy) {
+      return
+    }
+
+    setGenBusy(true)
+
+    try {
+      const custom = describe.trim()
+
+      const img = custom
+        ? await (async () => {
+            const res = await host.request<GeneratedImage>('image.generate', {
+              prompt: `${custom}. Avatar for an AI agent: centered, bold flat vector style, solid color background, no text.`,
+              aspect_ratio: 'square'
+            })
+
+            if (!res?.success) {
+              throw new Error(res?.error || 'generation failed')
+            }
+
+            return res.image_data || res.image
+          })()
+        : await generateAvatarImage(generateSeed?.name || 'agent', generateSeed?.title, generateSeed?.description)
+
+      if (img) {
+        onImage(await normalizeAvatarImage(img))
+      }
+    } catch (err) {
+      host.notifyError(err, b.avatar.generationFailed)
+    } finally {
+      setGenBusy(false)
+    }
+  }
+
+  return (
+    <div className="grid justify-items-center gap-3">
+      <SegmentedControl
+        onChange={goTab}
+        options={[
+          { id: 'bot', label: b.avatar.tabBot },
+          { id: 'generate', label: b.avatar.tabGenerate },
+          { id: 'upload', label: b.avatar.upload },
+          { id: 'pet', label: b.avatar.tabPet }
+        ]}
+        value={tab}
+      />
+      {image && tab !== 'generate' ? (
+        <Button onClick={() => onImage(null)} size="sm" type="button" variant="ghost">
+          {b.avatar.removeImage}
+        </Button>
+      ) : null}
+      {tab === 'bot' ? (
+        isBlobShape(shape) && blobatarSvg ? (
+          (() => {
+            const { seedPart, kind } = parseBlobShape(shape, pickerName)
+            const locked = Boolean(seedPart)
+
+            return (
+              <div className="grid justify-items-center gap-3">
+                {/* Silhouette pins: Auto (name decides) + the six blob kinds. */}
+                <div className="grid grid-cols-4 justify-items-center gap-1.5">
+                  {['', ...BLOB_KINDS].map(k => (
+                    <RowButton
+                      className={cn(
+                        'flex items-center justify-center rounded-md transition-colors hover:bg-(--chrome-action-hover)',
+                        k === kind && !image && 'ring-1 ring-(--ui-accent)'
+                      )}
+                      key={k || 'auto'}
+                      onClick={() => {
+                        onImage(null)
+                        onShape(blobShapeString(seedPart, k))
+                      }}
+                      style={{
+                        width: 44,
+                        height: 44
+                      }}
+                      title={k || 'Auto — the name decides'}
+                    >
+                      {k ? (
+                        <BotFace
+                          color={avatarColor(color, pickerName)}
+                          name={pickerName}
+                          shape={blobShapeString(seedPart, k)}
+                          size={32}
+                        />
+                      ) : (
+                        <span className="text-[0.6rem] text-(--ui-text-tertiary)">Auto</span>
+                      )}
+                    </RowButton>
+                  ))}
+                </div>
+                <div className="flex items-center gap-1">
+                  <Button
+                    onClick={() => {
+                      onImage(null)
+                      onShape(blobShapeString(Math.random().toString(36).slice(2, 10), kind))
+                    }}
+                    size="sm"
+                    type="button"
+                    variant="ghost"
+                  >
+                    <Codicon className="mr-1 text-[0.8rem]" name="refresh" />
+                    {b.avatar.randomize}
+                  </Button>
+                  <Button
+                    onClick={() => onShape(blobShapeString(locked ? '' : pickerName, kind))}
+                    size="sm"
+                    title={locked ? b.avatar.unlockFollowsName : 'Keep this exact face even if the name changes'}
+                    type="button"
+                    variant="ghost"
+                  >
+                    <Codicon className="mr-1 text-[0.8rem]" name={locked ? 'unlock' : 'lock'} />
+                    {locked ? 'Unlock' : 'Lock face'}
+                  </Button>
+                </div>
+                <div className="text-center text-[0.65rem] text-(--ui-text-quaternary)">
+                  {locked ? 'Face locked — renaming won\u2019t change it.' : 'Face follows the name.'}
+                </div>
+                <Button
+                  className="text-(--ui-text-tertiary)"
+                  onClick={() => onShape(defaultShapeFor(pickerName))}
+                  size="sm"
+                  type="button"
+                  variant="ghost"
+                >
+                  {b.avatar.classicShapes}
+                </Button>
+              </div>
+            )
+          })()
+        ) : (
+          <div className="grid justify-items-center gap-3">
+            <div className="grid grid-cols-4 justify-items-center gap-1.5">
+              {(blobatarSvg ? ['blobatar', ...AVATAR_PICKER_SHAPES] : AVATAR_PICKER_SHAPES).map(s => (
+                <RowButton
+                  className={cn(
+                    'flex items-center justify-center rounded-md transition-colors hover:bg-(--chrome-action-hover)',
+                    s === shape && !image && 'ring-1 ring-(--ui-accent)'
+                  )}
+                  key={s}
+                  onClick={() => {
+                    onImage(null)
+                    onShape(s)
+                  }}
+                  style={{
+                    width: 44,
+                    height: 44
+                  }}
+                  title={s === 'blobatar' ? b.avatar.blobFromName : undefined}
+                >
+                  <BotFace color={avatarColor(color, pickerName)} name={pickerName} shape={s} size={32} />
+                </RowButton>
+              ))}
+            </div>
+            <ColorSwatches
+              clearLabel={b.avatar.matchTheName}
+              onChange={onColor}
+              swatches={PROFILE_SWATCHES}
+              value={color}
+            />
+          </div>
+        )
+      ) : null}
+      {tab === 'generate' ? (
+        imagen ? (
+          <div className="grid w-full gap-2">
+            <Textarea
+              className="min-h-16 text-xs"
+              onChange={event => setDescribe(event.target.value)}
+              placeholder={b.avatar.describePlaceholder}
+              value={describe}
+            />
+            <Button
+              className="w-full justify-center"
+              disabled={genBusy}
+              onClick={generate}
+              type="button"
+              variant="secondary"
+            >
+              {genBusy ? (
+                <GlyphSpinner className="mr-1 text-[0.8rem]" spinner="breathe" />
+              ) : (
+                <Codicon className="mr-1 text-[0.8rem]" name="sparkle" />
+              )}
+              {genBusy ? 'Generating…' : 'Generate'}
+            </Button>
+            {describe.trim() ? null : (
+              <div className="text-center text-[0.65rem] text-(--ui-text-quaternary)">{b.bot.descriptionHint}</div>
+            )}
+          </div>
+        ) : (
+          <div className="px-2 py-3 text-center text-xs leading-5 text-(--ui-text-tertiary)">
+            {imagen === false
+              ? 'No image model available. If you just enabled one (or updated Hermes), restart the gateway: Ctrl+K → "Restart gateway".'
+              : 'Checking image backend…'}
+          </div>
+        )
+      ) : null}
+      {tab === 'upload' ? (
+        <Button className="w-full justify-center" onClick={upload} type="button" variant="secondary">
+          <Codicon className="mr-1 text-[0.8rem]" name="device-camera" />
+          Choose an image…
+        </Button>
+      ) : null}
+      {tab === 'pet' ? <PetTab image={image} onImage={onImage} /> : null}
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/avatar.face-clock.test.ts b/apps/desktop/src/plugins/hermes-bots/avatar.face-clock.test.ts
new file mode 100644
index 000000000000..f17ae64d59a9
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/avatar.face-clock.test.ts
@@ -0,0 +1,315 @@
+/**
+ * The shared face clock: ONE animation loop for every mounted math face.
+ *
+ * A large roster mounts hundreds of faces, so the clock must not burn frames
+ * (or 1Hz whole-document shadow walks) on faces nobody can see. It therefore
+ * parks itself whenever there is nothing worth animating — no faces mounted,
+ * or none intersecting — and is woken by exactly two events: a `BotFace`
+ * render re-entering `startFaceClock`, and a face scrolling into view.
+ *
+ * Newer desktops delegate scheduling to the SDK's `createBudgetedLoop`
+ * (15fps budget, hidden/minimized pause, dormancy, teardown); older shells
+ * fall back to the hand-rolled rAF path. Both are exercised here, because the
+ * fallback is what every un-upgraded install runs.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { budgetedLoopMock } = vi.hoisted(() => ({ budgetedLoopMock: { impl: undefined as unknown } }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    atom,
+    blobatarSvg: undefined,
+    // A live binding on the real SDK; the getter lets one test file cover both
+    // the budgeted-loop path and the older hand-rolled one.
+    get createBudgetedLoop() {
+      return budgetedLoopMock.impl
+    },
+    host: { state: { connectionId: { get: () => 'local' } } },
+    profileColor: () => '#8b5cf6',
+    PROFILE_SWATCHES: [],
+    queryClient: undefined,
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+interface ObserverEntry {
+  isIntersecting: boolean
+  target: Element
+}
+
+/** The live fake observer, so a test can drive visibility changes. */
+let observer: FakeIntersectionObserver | null = null
+
+class FakeIntersectionObserver {
+  callback: (entries: ObserverEntry[]) => void
+  disconnected = false
+  observed = new Set<Element>()
+
+  constructor(callback: (entries: ObserverEntry[]) => void) {
+    this.callback = callback
+    observer = this
+  }
+
+  disconnect() {
+    this.disconnected = true
+    this.observed.clear()
+  }
+
+  emit(entries: ObserverEntry[]) {
+    this.callback(entries)
+  }
+
+  observe(element: Element) {
+    this.observed.add(element)
+  }
+
+  unobserve(element: Element) {
+    this.observed.delete(element)
+  }
+}
+
+let frames = new Map<number, (now: number) => void>()
+let frameSeq = 0
+let now = 0
+
+/** Run every frame scheduled so far and advance the clock. */
+function pump(advance = 100) {
+  now += advance
+
+  const pending = [...frames.values()]
+
+  frames.clear()
+
+  for (const frame of pending) {
+    frame(now)
+  }
+}
+
+function mountFace() {
+  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+
+  svg.setAttribute('data-hb-math', '1')
+  document.body.append(svg)
+
+  return svg
+}
+
+async function loadClock() {
+  vi.resetModules()
+
+  return import('./avatar')
+}
+
+beforeEach(() => {
+  frames = new Map()
+  frameSeq = 0
+  now = 0
+  observer = null
+  budgetedLoopMock.impl = undefined
+  document.body.innerHTML = ''
+  delete window.__hbFaceClock
+  vi.stubGlobal('IntersectionObserver', FakeIntersectionObserver)
+
+  window.requestAnimationFrame = (callback: FrameRequestCallback) => {
+    frameSeq += 1
+    frames.set(frameSeq, callback)
+
+    return frameSeq
+  }
+
+  window.cancelAnimationFrame = (id: number) => {
+    frames.delete(id)
+  }
+})
+
+afterEach(() => {
+  window.__hbFaceClock?.stop()
+  vi.unstubAllGlobals()
+})
+
+describe('the hand-rolled rAF path (older shells)', () => {
+  it('parks itself when no faces are mounted', async () => {
+    const { startFaceClock } = await loadClock()
+
+    startFaceClock()
+    expect(frames.size).toBe(1)
+
+    pump()
+    expect(frames.size).toBe(0)
+  })
+
+  it('wakes a parked clock when a face mounts', async () => {
+    const { startFaceClock } = await loadClock()
+
+    startFaceClock()
+    pump()
+    expect(frames.size).toBe(0)
+
+    mountFace()
+    // The BotFace render path — re-entry is the wake signal.
+    startFaceClock()
+    expect(frames.size).toBe(1)
+  })
+
+  it('parks when every face scrolls out and the observer wakes it back', async () => {
+    const { startFaceClock } = await loadClock()
+    const face = mountFace()
+
+    startFaceClock()
+    pump()
+    // Observed but not yet intersecting: nothing visible, so park.
+    expect(frames.size).toBe(0)
+
+    observer!.emit([{ isIntersecting: true, target: face }])
+    expect(frames.size).toBe(1)
+
+    pump()
+    expect(frames.size).toBe(1)
+
+    observer!.emit([{ isIntersecting: false, target: face }])
+    pump()
+    pump()
+    expect(frames.size).toBe(0)
+  })
+
+  it('stops cleanly and can be restarted', async () => {
+    const { startFaceClock, stopFaceClock } = await loadClock()
+    const face = mountFace()
+
+    startFaceClock()
+    observer!.emit([{ isIntersecting: true, target: face }])
+    pump()
+    expect(frames.size).toBe(1)
+
+    const first = observer!
+
+    stopFaceClock()
+    expect(frames.size).toBe(0)
+    expect(first.disconnected).toBe(true)
+    expect(window.__hbFaceClock).toBeUndefined()
+
+    // A fresh start after teardown re-initializes rather than hitting a dead
+    // handle left on `window`.
+    startFaceClock()
+    expect(frames.size).toBe(1)
+  })
+
+  it('stops the whole-document walk when a face unmounts', async () => {
+    const { startFaceClock } = await loadClock()
+    const face = mountFace()
+
+    startFaceClock()
+    observer!.emit([{ isIntersecting: true, target: face }])
+    pump()
+
+    face.remove()
+    // The 1Hz rescan drops the node from both caches and parks the clock.
+    pump(1500)
+    pump()
+
+    expect(observer!.observed.has(face)).toBe(false)
+    expect(frames.size).toBe(0)
+  })
+})
+
+describe('the SDK budgeted-loop path', () => {
+  interface CapturedLoop {
+    draw: (now: number) => void
+    idleWhen: () => boolean
+  }
+
+  function captureLoop() {
+    const captured: Partial<CapturedLoop> = {}
+    const calls = { created: 0, dispose: 0, fps: 0, wake: 0 }
+
+    budgetedLoopMock.impl = (draw: (now: number) => void, options: { fps: number; idleWhen: () => boolean }) => {
+      calls.created += 1
+      calls.fps = options.fps
+      captured.draw = draw
+      captured.idleWhen = options.idleWhen
+
+      return {
+        dispose: () => {
+          calls.dispose += 1
+        },
+        isDormant: () => false,
+        wake: () => {
+          calls.wake += 1
+        }
+      }
+    }
+
+    return { calls, captured }
+  }
+
+  it('hands the paint to the SDK loop and schedules no rAF of its own', async () => {
+    const { calls } = captureLoop()
+    const { startFaceClock } = await loadClock()
+
+    mountFace()
+    startFaceClock()
+
+    expect(calls.fps).toBe(15)
+    expect(frames.size).toBe(0)
+  })
+
+  it('reports idleness from visible-face state and wakes on visibility', async () => {
+    const { calls, captured } = captureLoop()
+    const { startFaceClock } = await loadClock()
+    const face = mountFace()
+
+    startFaceClock()
+
+    // The first draw performs the initial scan + observation.
+    captured.draw!(1000)
+    expect(captured.idleWhen!()).toBe(true)
+
+    observer!.emit([{ isIntersecting: true, target: face }])
+    expect(captured.idleWhen!()).toBe(false)
+    expect(calls.wake).toBeGreaterThanOrEqual(1)
+
+    // Re-entry (a BotFace mount) wakes rather than re-initializing.
+    startFaceClock()
+    expect(calls.wake).toBeGreaterThanOrEqual(2)
+  })
+
+  it('disposes the loop and drops the window handle on stop', async () => {
+    const { calls } = captureLoop()
+    const { startFaceClock, stopFaceClock } = await loadClock()
+
+    mountFace()
+    startFaceClock()
+
+    const live = observer!
+
+    stopFaceClock()
+
+    expect(calls.dispose).toBe(1)
+    expect(live.disconnected).toBe(true)
+    expect(window.__hbFaceClock).toBeUndefined()
+  })
+
+  it('keeps a single clock across plugin loads', async () => {
+    // Parked on `window` so a second load adopts the running clock instead of
+    // starting a rival loop.
+    const { calls } = captureLoop()
+    const first = await loadClock()
+
+    mountFace()
+    first.startFaceClock()
+
+    const second = await loadClock()
+
+    second.startFaceClock()
+
+    expect(calls.created).toBe(1)
+    expect(calls.wake).toBeGreaterThanOrEqual(1)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/avatar.test.tsx b/apps/desktop/src/plugins/hermes-bots/avatar.test.tsx
new file mode 100644
index 000000000000..d911f3ad99e6
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/avatar.test.tsx
@@ -0,0 +1,206 @@
+/**
+ * The avatar face: blobatar shape strings, the markup they render to, and the
+ * catchlight polarity fix.
+ *
+ * Shape strings are stored per bot and must round-trip forever —
+ * `blobatar[:seed[:kind]]`, where an unlocked seed follows the bot's name and
+ * an unknown silhouette is ignored rather than trusted. The silhouette is
+ * pinned by handing the library a TRAIT position inside its frozen band, so
+ * the band a kind lands in is a stored-appearance contract, not an
+ * implementation detail.
+ *
+ * Catchlight (image14 report, Aug 2026): the sparkle's contrast follows the
+ * PUPIL, not the body. Dark bodies flip the pupils to light cream, and a white
+ * catchlight on a cream pupil is invisible — maroon/ink/oxblood avatars looked
+ * like they had "no dots in their eyes".
+ */
+
+import { render } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { blobatarSvgMock } = vi.hoisted(() => ({ blobatarSvgMock: vi.fn() }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    atom,
+    blobatarSvg: (seed: string, opts: unknown) => blobatarSvgMock(seed, opts) as string,
+    createBudgetedLoop: undefined,
+    host: { state: { connectionId: { get: () => 'local' } } },
+    profileColor: (name: string) => (name === 'inbox-triage' ? '#38bdf8' : '#8b5cf6'),
+    PROFILE_SWATCHES: ['#38bdf8', '#8b5cf6'],
+    queryClient: undefined,
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+/** The library's frozen band per silhouette (gen2 thresholds). */
+const BANDS: Record<string, [number, number]> = {
+  boxy: [0.48, 0.6],
+  capsule: [0.6, 0.7],
+  cloud: [0.79, 0.86],
+  droplet: [0.86, 0.915],
+  hexagon: [0.915, 0.95],
+  nub: [0.7, 0.79],
+  organic: [0.22, 0.48],
+  round: [0, 0.22],
+  sun: [0.95, 0.98],
+  triangle: [0.98, 1]
+}
+
+interface BlobOptions {
+  size: number
+  traits?: { shape: number }
+}
+
+const lastBlobCall = () => blobatarSvgMock.mock.calls.at(-1) as [string, BlobOptions]
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  blobatarSvgMock.mockReturnValue('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"></svg>')
+})
+
+describe('blob shape strings round-trip through parse/build', () => {
+  it('recognizes only the blobatar family', async () => {
+    const { isBlobShape } = await import('./avatar')
+
+    expect(isBlobShape('blobatar')).toBe(true)
+    expect(isBlobShape('blobatar:seed123')).toBe(true)
+    expect(isBlobShape('blobatar::sun')).toBe(true)
+    expect(isBlobShape('circle')).toBe(false)
+    expect(isBlobShape(undefined)).toBe(false)
+  })
+
+  it('parses the seed/silhouette segments, ignoring an unknown silhouette', async () => {
+    const { parseBlobShape } = await import('./avatar')
+
+    // Unlocked: the seed follows the name.
+    expect(parseBlobShape('blobatar', 'inbox-triage')).toEqual({ kind: '', seed: 'inbox-triage', seedPart: '' })
+    expect(parseBlobShape('blobatar:abc123', 'inbox-triage')).toEqual({
+      kind: '',
+      seed: 'abc123',
+      seedPart: 'abc123'
+    })
+    expect(parseBlobShape('blobatar::cloud', 'inbox-triage')).toEqual({
+      kind: 'cloud',
+      seed: 'inbox-triage',
+      seedPart: ''
+    })
+    expect(parseBlobShape('blobatar:abc:mystery', 'x').kind).toBe('')
+  })
+
+  it('rebuilds every segment combination', async () => {
+    const { blobShapeString } = await import('./avatar')
+
+    expect(blobShapeString('', '')).toBe('blobatar')
+    expect(blobShapeString('abc', '')).toBe('blobatar:abc')
+    expect(blobShapeString('abc', 'sun')).toBe('blobatar:abc:sun')
+    expect(blobShapeString('', 'sun')).toBe('blobatar::sun')
+  })
+})
+
+describe('rendering a blob face', () => {
+  it('tags the markup data-bot-face so the roster PNG backfill can find it', async () => {
+    // pushLocalAvatars → rasterizeSvgToPng queries `svg[data-bot-face=…]`;
+    // without the tag a vector face never reaches the inter-agent notices.
+    const { BotFace } = await import('./avatar')
+    const { container } = render(<BotFace color="#38bdf8" name="inbox-triage" shape="blobatar" size={56} />)
+
+    expect(container.querySelector('svg[data-bot-face="inbox-triage"]')).toBeTruthy()
+
+    const [seed, opts] = lastBlobCall()
+
+    expect(seed).toBe('inbox-triage')
+    expect(opts.size).toBe(56)
+    // No pinned silhouette means no traits at all — the library picks.
+    expect('traits' in opts).toBe(false)
+  })
+
+  it('passes the locked seed and the pinned silhouette’s trait', async () => {
+    const { BotFace } = await import('./avatar')
+
+    render(<BotFace color="#38bdf8" name="inbox-triage" shape="blobatar:abc:sun" size={32} />)
+
+    const [seed, opts] = lastBlobCall()
+
+    expect(seed).toBe('abc')
+    expect(opts.traits?.shape).toBeGreaterThanOrEqual(BANDS.sun[0])
+    expect(opts.traits?.shape).toBeLessThan(BANDS.sun[1])
+  })
+
+  it('puts every silhouette inside its own frozen band', async () => {
+    const { BLOB_KINDS, BotFace } = await import('./avatar')
+
+    for (const kind of BLOB_KINDS) {
+      render(<BotFace color="#38bdf8" name="agent" shape={`blobatar::${kind}`} size={32} />)
+
+      const trait = lastBlobCall()[1].traits?.shape
+
+      expect(typeof trait, kind).toBe('number')
+      expect(trait, kind).toBeGreaterThanOrEqual(BANDS[kind][0])
+      expect(trait, kind).toBeLessThan(BANDS[kind][1])
+    }
+  })
+
+  it('falls back to the legacy math face when the renderer throws', async () => {
+    blobatarSvgMock.mockImplementation(() => {
+      throw new Error('boom')
+    })
+
+    const { BotFace } = await import('./avatar')
+    const { container } = render(<BotFace color="#38bdf8" name="agent" shape="blobatar" size={32} />)
+
+    expect(container.querySelector('svg[data-hb-math]')).toBeTruthy()
+  })
+})
+
+describe('catchlight contrast follows the pupil, not the body', () => {
+  const catchlights = (container: HTMLElement) =>
+    ['l', 'r'].map(side => container.querySelector(`[data-hb-hl-${side}]`)?.getAttribute('fill'))
+
+  it('puts a DARK sparkle on the cream pupils of a dark body', async () => {
+    const { BotFace } = await import('./avatar')
+    const { container } = render(<BotFace color="#3b0910" name="oxblood" shape="circle" />)
+
+    expect(catchlights(container)).toEqual(['rgba(0,0,0,0.6)', 'rgba(0,0,0,0.6)'])
+  })
+
+  it('keeps the white sparkle on the dark pupils of a light body', async () => {
+    const { BotFace } = await import('./avatar')
+    const { container } = render(<BotFace color="#f5e6c8" name="cream" shape="circle" />)
+
+    expect(catchlights(container)).toEqual(['rgba(255,255,255,0.85)', 'rgba(255,255,255,0.85)'])
+  })
+})
+
+// Last: re-mocking the SDK re-links the whole avatar graph, so anything after
+// this would be running against the swapped module.
+describe('an SDK that predates blobatarSvg', () => {
+  it('renders the legacy deterministic shape instead of nothing', async () => {
+    vi.resetModules()
+    vi.doMock('@hermes/plugin-sdk', async () => {
+      const { atom } = await import('nanostores')
+
+      return {
+        atom,
+        blobatarSvg: undefined,
+        createBudgetedLoop: undefined,
+        host: { state: { connectionId: { get: () => 'local' } } },
+        profileColor: () => '#8b5cf6',
+        PROFILE_SWATCHES: [],
+        queryClient: undefined,
+        useQuery: vi.fn(),
+        useValue: vi.fn()
+      }
+    })
+
+    const { BotFace, defaultShapeFor } = await import('./avatar')
+    const { container } = render(<BotFace color="#38bdf8" name="agent" shape="blobatar" size={32} />)
+
+    expect(container.querySelector('svg[data-hb-math]')?.getAttribute('data-hb-shape')).toBe(defaultShapeFor('agent'))
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/avatar.tsx b/apps/desktop/src/plugins/hermes-bots/avatar.tsx
new file mode 100644
index 000000000000..b8aaae9c8e3e
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/avatar.tsx
@@ -0,0 +1,1114 @@
+/**
+ * Bot avatars: the shape/color/eyes vocabulary, the deterministic blobatar
+ * faces, the shared face clock that animates them, and `BotFace` — the one
+ * component every roster row, dialog and tile renders a bot with.
+ *
+ * Render-only. The editor UI that picks these lives in `avatar-picker.tsx`.
+ */
+
+import * as sdk from '@hermes/plugin-sdk'
+import { profileColor } from '@hermes/plugin-sdk'
+
+import type { AvatarAppearance, AvatarShape, BotMeta, FaceMood } from './types'
+
+// Deterministic blob avatars (name → face). Feature-detected: older SDKs
+// without the export fall back to the legacy math-face shapes below.
+export const blobatarSvg = typeof sdk === 'undefined' ? undefined : sdk.blobatarSvg
+// Budgeted render loop (fps cap + observability pause + dormancy + teardown).
+// Feature-detected: older desktops fall back to the hand-rolled clock below.
+const createBudgetedLoop = typeof sdk === 'undefined' ? undefined : sdk.createBudgetedLoop
+
+// ── avatars (shape + color + eyes) ──────────────────────────────────────────
+
+// The original flat shapes. Sigils ('sigil-N') and platonic
+// solids remain render-only so any bot that picked one during the experiments
+// keeps its look.
+const AVATAR_SHAPES: AvatarShape[] = ['circle', 'squircle', 'pill', 'triangle', 'hexagon', 'cloud', 'drop']
+export const AVATAR_PICKER_SHAPES = ['circle', 'blob', 'squircle', 'pill', 'triangle', 'hexagon', 'cloud', 'drop']
+
+/** xorshift PRNG seeded from a string — stable across sessions/platforms. */
+function sigilRng(text: string) {
+  let h = 2166136261
+
+  for (const ch of text) {
+    h ^= ch.charCodeAt(0)
+    h = Math.imul(h, 16777619)
+  }
+
+  let state = h >>> 0 || 88675123
+
+  return () => {
+    state ^= state << 13
+    state ^= state >>> 17
+    state ^= state << 5
+    state >>>= 0
+
+    return state / 4294967296
+  }
+}
+
+interface SigilGeometry {
+  /** The optional diamond ring, as an SVG path. */
+  ring: null | string
+  /** Every stroke joined into one SVG path. */
+  strokes: string
+}
+
+/**
+ * Angular hermetic sigil: strokes on the left half of a 5-column grid,
+ * mirrored right, plus a chance of a diamond ring. Returns SVG path strings.
+ */
+function sigilGeometry(name: string, seed: number): SigilGeometry {
+  const rng = sigilRng(`${name}::${seed}`)
+  const gx = (i: number) => 6 + i * 7 // 5 cols: 6..34
+  const gy = (j: number) => 8 + j * 6 // 5 rows: 8..32
+  const strokes: string[] = []
+  const segments = 4 + Math.floor(rng() * 3)
+
+  for (let k = 0; k < segments; k++) {
+    const x1 = Math.floor(rng() * 3) // left half incl. center
+    const y1 = Math.floor(rng() * 5)
+    const x2 = Math.min(2, Math.max(0, x1 + (rng() > 0.5 ? 1 : -1)))
+    const y2 = Math.min(4, Math.max(0, y1 + Math.floor(rng() * 3) - 1))
+    strokes.push(`M${gx(x1)} ${gy(y1)} L${gx(x2)} ${gy(y2)}`)
+    // mirror (col i → col 4-i)
+    strokes.push(`M${gx(4 - x1)} ${gy(y1)} L${gx(4 - x2)} ${gy(y2)}`)
+
+    // occasional cross-tie through the axis for connectedness
+    if (rng() > 0.6) {
+      strokes.push(`M${gx(x2)} ${gy(y2)} L${gx(4 - x2)} ${gy(y2)}`)
+    }
+  }
+
+  // spine down the axis grounds every variant
+  strokes.push(`M20 ${gy(0)} L20 ${gy(4)}`)
+  const ring = rng() > 0.45 ? 'M20 4 L36 20 L20 36 L4 20 Z' : null
+
+  return {
+    strokes: strokes.join(' '),
+    ring
+  }
+}
+
+/** Perceptual luminance — eyes/pupils flip light on dark bodies (ink, oxblood). */
+function isDarkColor(hex: string) {
+  try {
+    const n = parseInt(hex.slice(1), 16)
+    const r = (n >> 16) & 255
+    const g = (n >> 8) & 255
+    const b = n & 255
+
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b < 110
+  } catch {
+    return false
+  }
+}
+
+export function defaultShapeFor(name: string): AvatarShape {
+  let hash = 0
+
+  for (const ch of name) {
+    hash = (hash * 31 + ch.charCodeAt(0)) >>> 0
+  }
+
+  return AVATAR_SHAPES[hash % AVATAR_SHAPES.length]
+}
+
+// ── blobatar shapes mode (default for new agents) ───────────────────────────
+// Deterministic soft-body faces drawn from a string. Shape strings:
+//   'blobatar'                — the face follows the bot's NAME (renaming the
+//                               bot re-rolls the face, live in the dialog)
+//   'blobatar:<seed>'         — seed locked (the 🔒 lock / 🎲 randomize picks)
+//   'blobatar:<seed>:<kind>'  — plus one of the ten silhouettes pinned
+//   'blobatar::<kind>'        — silhouette pinned, seed still follows the name
+// Bot names are slugs (NAME_RE) and generated seeds are base36, so ':' never
+// appears inside a segment. Colors come from the library's own name-derived
+// palette (contrast-guaranteed) — the classic color swatches don't apply.
+
+export const BLOB_KINDS = [
+  'round',
+  'organic',
+  'boxy',
+  'capsule',
+  'nub',
+  'cloud',
+  'droplet',
+  'hexagon',
+  'sun',
+  'triangle'
+]
+
+// Trait positions at the center of each silhouette band. Band thresholds are
+// frozen per blobatar major (gen2: 0.22 / 0.48 / 0.60 / 0.70 / 0.79 / 0.86 /
+// 0.915 / 0.95 / 0.98).
+// Keyed by BlobKind, but indexed with the free-form segment parseBlobShape
+// pulls out of a stored shape string, which no guard here can narrow.
+const BLOB_KIND_TRAIT: Record<string, number> = {
+  round: 0.11,
+  organic: 0.35,
+  boxy: 0.54,
+  capsule: 0.65,
+  nub: 0.745,
+  cloud: 0.825,
+  droplet: 0.8875,
+  hexagon: 0.9325,
+  sun: 0.965,
+  triangle: 0.99
+}
+
+export function isBlobShape(shape: null | string | undefined) {
+  return shape === 'blobatar' || (typeof shape === 'string' && shape.startsWith('blobatar:'))
+}
+
+interface ParsedBlobShape {
+  /** A BlobKind when the silhouette is pinned, else empty. */
+  kind: string
+  /** The seed actually rendered — the pinned one, else the bot's name. */
+  seed: string
+  /** The pinned seed alone, empty when the face follows the name. */
+  seedPart: string
+}
+
+export function parseBlobShape(shape: null | string | undefined, name: string | undefined): ParsedBlobShape {
+  const parts = typeof shape === 'string' ? shape.split(':') : []
+  const seedPart = parts[1] || ''
+  const kind = BLOB_KINDS.includes(parts[2]) ? parts[2] : ''
+
+  return {
+    seed: seedPart || name || 'agent',
+    seedPart,
+    kind
+  }
+}
+
+export function blobShapeString(seedPart: string, kind: string) {
+  if (kind) {
+    return `blobatar:${seedPart}:${kind}`
+  }
+
+  return seedPart ? `blobatar:${seedPart}` : 'blobatar'
+}
+
+/** Static SVG markup for a blob face, tagged data-bot-face so the roster's
+ *  PNG backfill (pushLocalAvatars → rasterizeSvgToPng) still finds it. */
+function blobMarkup(shape: null | string | undefined, name: string, size: number) {
+  if (!blobatarSvg) {
+    return null
+  }
+
+  const { seed, kind } = parseBlobShape(shape, name)
+
+  const opts: { size: number; traits?: Record<string, number> } = {
+    size
+  }
+
+  if (kind) {
+    opts.traits = {
+      shape: BLOB_KIND_TRAIT[kind]
+    }
+  }
+
+  try {
+    return blobatarSvg(seed, opts).replace('<svg ', '<svg data-bot-face=' + JSON.stringify(name) + ' ')
+  } catch {
+    return null
+  }
+}
+
+/** The SVG presentation props shapeNode spreads onto a <path>. Named so the
+ *  literal join/cap values keep their literal types instead of widening. */
+interface FacePathProps {
+  fill: string
+  stroke: string
+  strokeLinecap?: 'round'
+  strokeLinejoin: 'round'
+  strokeWidth: number
+}
+
+/** The colored body of the avatar (no eyes). Platonic solids are a filled
+ *  silhouette + translucent internal edge lines (the projected wireframe);
+ *  legacy flat shapes keep their old geometry so stored picks still render. */
+function shapeNode(shape: string, color: string, botName = 'agent') {
+  if (shape.startsWith('sigil-')) {
+    const seed = Number(shape.slice(6)) || 0
+    const { strokes, ring } = sigilGeometry(botName, seed)
+
+    const sw: FacePathProps = {
+      fill: 'none',
+      stroke: color,
+      strokeWidth: 2.2,
+      strokeLinecap: 'round',
+      strokeLinejoin: 'round'
+    }
+
+    return (
+      <g>
+        {ring ? <path d={ring} fill="none" opacity={0.5} stroke={color} strokeWidth={1.2} /> : null}
+        <path d={strokes} {...sw} />
+      </g>
+    )
+  }
+
+  const stroke: FacePathProps = {
+    fill: color,
+    stroke: color,
+    strokeWidth: 7,
+    strokeLinejoin: 'round'
+  }
+
+  const edge: FacePathProps = {
+    fill: 'none',
+    stroke: 'rgba(0,0,0,0.4)',
+    strokeWidth: 1.4,
+    strokeLinejoin: 'round',
+    strokeLinecap: 'round'
+  }
+
+  const face: FacePathProps = {
+    fill: color,
+    stroke: 'rgba(0,0,0,0.4)',
+    strokeWidth: 1.4,
+    strokeLinejoin: 'round'
+  }
+
+  switch (shape) {
+    // ── platonic solids ──
+    case 'tetrahedron':
+      return (
+        <g>
+          <path d="M20 5 L36 33 L4 33 Z" {...face} />
+          <path d="M20 5 L20 25 M4 33 L20 25 M36 33 L20 25" {...edge} />
+        </g>
+      )
+
+    case 'cube':
+      return (
+        <g>
+          <path d="M20 4 L33 11 L33 29 L20 36 L7 29 L7 11 Z" {...face} />
+          <path d="M7 11 L20 18 L33 11 M20 18 L20 36" {...edge} />
+        </g>
+      )
+
+    case 'octahedron':
+      return (
+        <g>
+          <path d="M20 3 L36 20 L20 37 L4 20 Z" {...face} />
+          <path d="M4 20 L36 20 M20 3 L20 37" {...edge} />
+        </g>
+      )
+
+    case 'dodecahedron':
+      return (
+        <g>
+          <path
+            d="M20 3 L30 6.2 L36.2 14.7 L36.2 25.3 L30 33.8 L20 37 L10 33.8 L3.8 25.3 L3.8 14.7 L10 6.2 Z"
+            {...face}
+          />
+          <path
+            d={
+              'M20 12 L27.6 17.5 L24.7 26.5 L15.3 26.5 L12.4 17.5 Z ' +
+              'M20 12 L20 3 M27.6 17.5 L36.2 14.7 M24.7 26.5 L30 33.8 M15.3 26.5 L10 33.8 M12.4 17.5 L3.8 14.7'
+            }
+            {...edge}
+          />
+        </g>
+      )
+
+    case 'icosahedron':
+      return (
+        <g>
+          <path d="M20 3 L34.7 11.5 L34.7 28.5 L20 37 L5.3 28.5 L5.3 11.5 Z" {...face} />
+          <path
+            d={
+              'M20 11 L27.8 24.5 L12.2 24.5 Z ' +
+              'M20 11 L20 3 M20 11 L34.7 11.5 M20 11 L5.3 11.5 ' +
+              'M27.8 24.5 L34.7 11.5 M27.8 24.5 L34.7 28.5 M27.8 24.5 L20 37 ' +
+              'M12.2 24.5 L5.3 11.5 M12.2 24.5 L5.3 28.5 M12.2 24.5 L20 37'
+            }
+            {...edge}
+          />
+        </g>
+      )
+
+    // ── legacy flat shapes (stored picks from earlier versions) ──
+    case 'squircle':
+      return <rect fill={color} height={34} rx={11} width={34} x={3} y={3} />
+
+    case 'pill':
+      return <rect fill={color} height={26} rx={13} width={36} x={2} y={7} />
+
+    case 'triangle':
+      return <path d="M20 5.5 L36 33.5 L4 33.5 Z" {...stroke} />
+
+    case 'hexagon':
+      return <path d="M20 3.5 L34.5 11.75 L34.5 28.25 L20 36.5 L5.5 28.25 L5.5 11.75 Z" {...stroke} />
+
+    case 'cloud':
+      return <path d="M11 32 a7.5 7.5 0 0 1 -1 -14.9 A9.5 9.5 0 0 1 29 12.5 A7 7 0 0 1 30 32 Z" fill={color} />
+
+    case 'drop':
+      return <path d="M20 3 C20 3 6 20 6 27 a14 13.5 0 0 0 28 0 C34 20 20 3 20 3 Z" fill={color} />
+
+    default:
+      return <circle cx={20} cy={20} fill={color} r={17.5} />
+  }
+}
+
+/** One point in the 40x40 face box. */
+type FacePoint = [number, number]
+
+function cubicAt(p0: FacePoint, p1: FacePoint, p2: FacePoint, p3: FacePoint, t: number): FacePoint {
+  const u = 1 - t
+
+  return [
+    u * u * u * p0[0] + 3 * u * u * t * p1[0] + 3 * u * t * t * p2[0] + t * t * t * p3[0],
+    u * u * u * p0[1] + 3 * u * u * t * p1[1] + 3 * u * t * t * p2[1] + t * t * t * p3[1]
+  ]
+}
+
+/** Same outline as the old GitHub drop path, so it stays a fat water drop. */
+function sampleDropRing(steps: number): FacePoint[] {
+  const pts: FacePoint[] = []
+  const n = Math.max(8, Math.floor(steps / 3))
+
+  for (let i = 0; i < n; i++) {
+    pts.push(cubicAt([20, 3], [20, 3], [6, 20], [6, 27], i / n))
+  }
+
+  for (let i = 0; i <= n; i++) {
+    const t = (i / n) * Math.PI
+    pts.push([20 - 14 * Math.cos(t), 27 + 13.5 * Math.sin(t)])
+  }
+
+  for (let i = 1; i <= n; i++) {
+    pts.push(cubicAt([34, 27], [34, 20], [20, 3], [20, 3], i / n))
+  }
+
+  return pts
+}
+
+/** A center-parameterized elliptical arc, as sampleArc walks it. */
+interface FaceArc {
+  cx: number
+  cy: number
+  dtheta: number
+  rx: number
+  ry: number
+  theta1: number
+}
+
+function svgArc(
+  x1: number,
+  y1: number,
+  rx: number,
+  ry: number,
+  fa: number,
+  fs: number,
+  x2: number,
+  y2: number
+): FaceArc {
+  const dx = (x1 - x2) / 2
+  const dy = (y1 - y2) / 2
+  let rx2 = rx * rx
+  let ry2 = ry * ry
+  const lam = (dx * dx) / rx2 + (dy * dy) / ry2
+
+  if (lam > 1) {
+    const s = Math.sqrt(lam)
+    rx *= s
+    ry *= s
+    rx2 = rx * rx
+    ry2 = ry * ry
+  }
+
+  const num = rx2 * ry2 - rx2 * dy * dy - ry2 * dx * dx
+  const den = rx2 * dy * dy + ry2 * dx * dx
+  let sq = Math.sqrt(Math.max(0, num / den))
+
+  if (fa === fs) {
+    sq = -sq
+  }
+
+  const cx = sq * ((rx * dy) / ry) + (x1 + x2) / 2
+  const cy = sq * ((-ry * dx) / rx) + (y1 + y2) / 2
+
+  const ang = (ux: number, uy: number, vx: number, vy: number) => {
+    const n = Math.hypot(ux, uy) * Math.hypot(vx, vy) || 1
+    let a = Math.acos(Math.max(-1, Math.min(1, (ux * vx + uy * vy) / n)))
+
+    if (ux * vy - uy * vx < 0) {
+      a = -a
+    }
+
+    return a
+  }
+
+  const theta1 = ang(1, 0, (x1 - cx) / rx, (y1 - cy) / ry)
+  let dtheta = ang((x1 - cx) / rx, (y1 - cy) / ry, (x2 - cx) / rx, (y2 - cy) / ry)
+
+  if (!fs && dtheta > 0) {
+    dtheta -= Math.PI * 2
+  }
+
+  if (fs && dtheta < 0) {
+    dtheta += Math.PI * 2
+  }
+
+  return {
+    cx,
+    cy,
+    rx,
+    ry,
+    theta1,
+    dtheta
+  }
+}
+
+function sampleArc(arc: FaceArc, n: number): FacePoint[] {
+  const pts: FacePoint[] = []
+
+  for (let i = 0; i < n; i++) {
+    const th = arc.theta1 + arc.dtheta * (i / n)
+    pts.push([arc.cx + arc.rx * Math.cos(th), arc.cy + arc.ry * Math.sin(th)])
+  }
+
+  return pts
+}
+
+/** Same outline as the old GitHub cloud path: three puffs and a flat floor. */
+function sampleCloudRing(steps: number): FacePoint[] {
+  const a1 = svgArc(11, 32, 7.5, 7.5, 0, 1, 10, 17.1)
+  const a2 = svgArc(10, 17.1, 9.5, 9.5, 0, 1, 29, 12.5)
+  const a3 = svgArc(29, 12.5, 7, 7, 0, 1, 30, 32)
+  const len1 = Math.abs(a1.dtheta) * a1.rx
+  const len2 = Math.abs(a2.dtheta) * a2.rx
+  const len3 = Math.abs(a3.dtheta) * a3.rx
+  const len4 = 19
+  const total = len1 + len2 + len3 + len4
+  const n = Math.max(64, steps)
+  const n1 = Math.max(8, Math.round((n * len1) / total))
+  const n2 = Math.max(10, Math.round((n * len2) / total))
+  const n3 = Math.max(10, Math.round((n * len3) / total))
+  const n4 = Math.max(4, n - n1 - n2 - n3)
+  const pts: FacePoint[] = []
+  pts.push(...sampleArc(a1, n1))
+  pts.push(...sampleArc(a2, n2))
+  pts.push(...sampleArc(a3, n3))
+
+  for (let i = 0; i < n4; i++) {
+    pts.push([30 + (11 - 30) * (i / n4), 32])
+  }
+
+  return pts
+}
+
+/** Outline of a face in a 40x40 box. Same family as Grok Bot
+ *  (blob / squircle / pebble / \u2026) but sampled from formulas, not
+ *  a dumped point cloud. */
+function sampleFaceRing(shape: null | string | undefined, steps = 52): FacePoint[] {
+  const kind = (shape || '').startsWith('sigil-') ? 'circle' : shape
+
+  if (kind === 'drop' || kind === 'teardrop') {
+    return sampleDropRing(steps)
+  }
+
+  if (kind === 'cloud') {
+    return sampleCloudRing(steps)
+  }
+
+  const pts: FacePoint[] = []
+
+  for (let i = 0; i < steps; i++) {
+    const a = (i / steps) * Math.PI * 2 - Math.PI / 2
+    const c = Math.cos(a)
+    const s = Math.sin(a)
+    let rx = 16
+    let ry = 16
+
+    if (kind === 'circle') {
+      rx = ry = 16.2
+    } else if (kind === 'blob') {
+      rx = ry = 16 + 1.7 * Math.sin(3 * a) + 0.7 * Math.cos(5 * a)
+    } else if (kind === 'squircle') {
+      const p = 5
+      const d = Math.pow(Math.abs(c) ** p + Math.abs(s) ** p, 1 / p) || 1
+      rx = ry = 16.2 / d
+    } else if (kind === 'pill') {
+      const d = Math.pow(Math.abs(c) ** 8 + Math.abs(s / 0.72) ** 8, 1 / 8) || 1
+      rx = ry = 16 / d
+    } else if (kind === 'triangle' || kind === 'tetrahedron' || kind === 'wedge') {
+      const u = (a + Math.PI / 2 + Math.PI * 2) % (Math.PI * 2)
+      const sector = (u / ((Math.PI * 2) / 3)) % 1
+      rx = ry = 13.5 / Math.max(0.42, Math.cos((sector - 0.5) * 1.9))
+    } else if (kind === 'hexagon' || kind === 'hex' || kind === 'icosahedron' || kind === 'dodecahedron') {
+      const seg = Math.PI / 3
+      const hex = Math.cos(seg / 2) / Math.cos(a - seg * Math.round(a / seg))
+      rx = ry = 16.2 * hex
+    } else if (kind === 'cube' || kind === 'octahedron') {
+      const p = 3.1
+      const d = Math.pow(Math.abs(c) ** p + Math.abs(s) ** p, 1 / p) || 1
+      rx = ry = 16 / d
+    } else if (kind === 'pebble') {
+      rx = 16.4 * (1.04 - 0.14 * Math.cos(2 * a))
+      ry = 15.2 * (1.06 + 0.08 * Math.sin(2 * a))
+    } else {
+      rx = ry = 16.2
+    }
+
+    pts.push([20 + rx * c, 20 + ry * s])
+  }
+
+  return pts
+}
+
+function projectFacePoint(x: number, y: number, turn: number, tilt: number, roll: number): FacePoint {
+  const dx = x - 20
+  const dy = y - 20
+  const r = (roll * Math.PI) / 180
+  const xr = dx * Math.cos(r) - dy * Math.sin(r)
+  const yr = dx * Math.sin(r) + dy * Math.cos(r)
+  const sx = 0.74 + 0.26 * Math.abs(Math.cos((turn * Math.PI) / 180))
+  const sy = 0.8 + 0.2 * Math.abs(Math.cos((tilt * Math.PI) / 180))
+
+  return [20 + xr * sx, 20 + yr * sy]
+}
+
+function ringToPath(pts: FacePoint[]) {
+  if (!pts.length) {
+    return ''
+  }
+
+  let d = `M${pts[0][0].toFixed(2)} ${pts[0][1].toFixed(2)}`
+
+  for (let i = 1; i < pts.length; i++) {
+    d += `L${pts[i][0].toFixed(2)} ${pts[i][1].toFixed(2)}`
+  }
+
+  return d + 'Z'
+}
+
+/** One frame of the face: head orientation, gaze offset, blink, and the three
+ *  working dots' opacities. */
+interface FacePose {
+  blink: boolean
+  d0: number
+  d1: number
+  d2: number
+  gazeX: number
+  gazeY: number
+  roll: number
+  tilt: number
+  turn: number
+}
+
+/** Grok-style pose. thinking/working lean and sway. idle is a small sine. */
+function facePose(mood: FaceMood | string, t: number): FacePose {
+  if (mood === 'work') {
+    return {
+      turn: -11 + Math.sin(t * 0.48) * 8,
+      tilt: Math.sin(t * 0.42) * 8 + Math.sin(t * 1.1) * 1.6,
+      roll: Math.sin(t * 0.75) * 4.2,
+      gazeX: Math.sin(t * 0.55) * 3.6,
+      gazeY: -1.6 + Math.sin(t * 0.38) * 2,
+      blink: t % 1.45 > 1.26,
+      d0: 0.2 + 0.8 * Math.max(0, Math.sin(t * 2.6)),
+      d1: 0.2 + 0.8 * Math.max(0, Math.sin(t * 2.6 - 0.7)),
+      d2: 0.2 + 0.8 * Math.max(0, Math.sin(t * 2.6 - 1.4))
+    }
+  }
+
+  return {
+    turn: Math.sin(t * 0.5) * 1.5,
+    tilt: Math.sin(t * 0.27),
+    roll: Math.sin(t * 0.85) * 1.2,
+    gazeX: 0,
+    gazeY: 0,
+    blink: t % 3.2 > 3.02,
+    d0: 0,
+    d1: 0,
+    d2: 0
+  }
+}
+
+/** The eyes and catchlights are positioned with raw numbers.
+ *  `Element.setAttribute` declares a string value and the DOM coerces —
+ *  stringifying at each call site would be a behavior change. */
+interface NumericAttrNode {
+  setAttribute(name: string, value: number | string): void
+}
+
+function paintMathFace(svg: SVGSVGElement, t: number) {
+  const mood = svg.getAttribute('data-hb-mood') || 'idle'
+  const shape = svg.getAttribute('data-hb-shape') || 'circle'
+  const pose = facePose(mood, t)
+  const body = svg.querySelector('[data-hb-body]')
+  const open = svg.querySelector('[data-hb-open]')
+  const shut = svg.querySelector('[data-hb-shut]')
+  const el: NumericAttrNode | null = svg.querySelector('[data-hb-el]')
+  const er: NumericAttrNode | null = svg.querySelector('[data-hb-er]')
+  const dots = svg.querySelectorAll('[data-hb-dot]')
+
+  if (body) {
+    if (shape === 'cloud') {
+      body.setAttribute('d', 'M11 32 a7.5 7.5 0 0 1 -1 -14.9 A9.5 9.5 0 0 1 29 12.5 A7 7 0 0 1 30 32 Z')
+    } else {
+      const ring = sampleFaceRing(shape).map(([x, y]) => projectFacePoint(x, y, pose.turn, pose.tilt, pose.roll))
+      body.setAttribute('d', ringToPath(ring))
+    }
+  }
+
+  const eyeY = (shape === 'cloud' ? 22 : 17.2) + pose.gazeY
+  const eyeL = 15.4 + pose.gazeX
+  const eyeR = 24.6 + pose.gazeX
+
+  if (el) {
+    el.setAttribute('cx', eyeL)
+    el.setAttribute('cy', eyeY)
+  }
+
+  if (er) {
+    er.setAttribute('cx', eyeR)
+    er.setAttribute('cy', eyeY)
+  }
+
+  // Catchlights ride the pupils (upper-left offset) — without this they
+  // stay at the circle-face position and drift outside e.g. the cloud's
+  // lower-set eyes.
+  const hl: NumericAttrNode | null = svg.querySelector('[data-hb-hl-l]')
+  const hr: NumericAttrNode | null = svg.querySelector('[data-hb-hl-r]')
+
+  if (hl) {
+    hl.setAttribute('cx', eyeL - 0.6)
+    hl.setAttribute('cy', eyeY - 0.7)
+  }
+
+  if (hr) {
+    hr.setAttribute('cx', eyeR - 0.6)
+    hr.setAttribute('cy', eyeY - 0.7)
+  }
+
+  if (open) {
+    open.setAttribute('opacity', pose.blink ? '0' : '1')
+  }
+
+  if (shut) {
+    shut.setAttribute(
+      'd',
+      `M${eyeL - 2.6} ${eyeY} L${eyeL + 2.6} ${eyeY} M${eyeR - 2.6} ${eyeY} L${eyeR + 2.6} ${eyeY}`
+    )
+    shut.setAttribute('opacity', pose.blink ? '1' : '0')
+  }
+
+  dots.forEach((dot, i) => {
+    const o = i === 0 ? pose.d0 : i === 1 ? pose.d1 : pose.d2
+    dot.setAttribute('opacity', String(o))
+  })
+  svg.style.transform = `rotate(${pose.tilt}deg)`
+  svg.style.transformOrigin = '50% 70%'
+}
+
+function walkMathFaces(root: Document | ShadowRoot | null, acc: SVGSVGElement[]): SVGSVGElement[] {
+  if (!root || !root.querySelectorAll) {
+    return acc
+  }
+
+  root.querySelectorAll<SVGSVGElement>('svg[data-hb-math]').forEach(node => acc.push(node))
+  root.querySelectorAll('*').forEach(el => {
+    if (el.shadowRoot) {
+      walkMathFaces(el.shadowRoot, acc)
+    }
+  })
+
+  return acc
+}
+
+/** The single shared face clock, parked on `window` so a second plugin load
+ *  adopts the running one instead of starting a rival rAF loop. */
+interface FaceClock {
+  stop: () => void
+  wake: () => void
+}
+
+declare global {
+  interface Window {
+    __hbFaceClock?: FaceClock
+  }
+}
+
+export function startFaceClock() {
+  if (typeof window === 'undefined') {
+    return
+  }
+
+  if (window.__hbFaceClock) {
+    // Already initialized (possibly parked) — make sure it's awake. BotFace
+    // renders route here, so a face mounting is what wakes a dormant clock.
+    window.__hbFaceClock.wake()
+
+    return
+  }
+
+  const t0 = performance.now()
+  // A large roster can mount hundreds of faces. Observe the cached nodes so
+  // off-screen cards do not consume a full animation frame by themselves.
+  let faces: SVGSVGElement[] = []
+  let lastScan = -Infinity
+  // Fed from IntersectionObserver entries, whose `target` is a plain Element.
+  const visibleFaces = new Set<Element>()
+  const observedFaces = new Set<SVGSVGElement>()
+
+  const observer =
+    typeof IntersectionObserver === 'function'
+      ? new IntersectionObserver(entries => {
+          let becameVisible = false
+
+          for (const entry of entries) {
+            if (entry.isIntersecting) {
+              visibleFaces.add(entry.target)
+              becameVisible = true
+            } else {
+              visibleFaces.delete(entry.target)
+            }
+          }
+
+          // A parked clock (no visible faces) resumes when one scrolls in.
+          if (becameVisible) {
+            window.__hbFaceClock?.wake()
+          }
+        })
+      : null
+
+  const scanFaces = () => {
+    faces = walkMathFaces(document, [])
+
+    if (!observer) {
+      return
+    }
+
+    const currentFaces = new Set(faces)
+
+    for (const svg of observedFaces) {
+      if (!currentFaces.has(svg)) {
+        observer.unobserve(svg)
+        observedFaces.delete(svg)
+        visibleFaces.delete(svg)
+      }
+    }
+
+    for (const svg of faces) {
+      if (!observedFaces.has(svg)) {
+        observedFaces.add(svg)
+        observer.observe(svg)
+      }
+    }
+  }
+
+  // Shared painting body for both scheduling paths: 1Hz document rescans,
+  // paint only visible faces (all cached faces when IO is unavailable).
+  const paint = (now: number) => {
+    if (now - lastScan > 1000) {
+      scanFaces()
+      lastScan = now
+    }
+
+    const t = (now - t0) / 1000
+    const facesToPaint = observer ? visibleFaces : faces
+
+    for (const svg of facesToPaint) {
+      if (svg.isConnected) {
+        // Both caches only ever hold nodes matched by `svg[data-hb-math]`.
+        paintMathFace(svg as SVGSVGElement, t)
+      }
+    }
+  }
+
+  // Nothing worth animating: no faces mounted (BotFace wakes us on the next
+  // mount) or none visible (the observer wakes us when one scrolls in).
+  // TODO(bot-mode-types): with faces mounted and IntersectionObserver absent
+  // this returns the null observer rather than false — `observer &&`
+  // short-circuits to the observer itself. createBudgetedLoop declares
+  // idleWhen as `() => boolean`; null is falsy so the loop keeps running as
+  // intended today. Hence the assertion at the idleWhen call below.
+  const idle = () => faces.length === 0 || (observer && visibleFaces.size === 0)
+
+  const teardownCaches = () => {
+    if (observer) {
+      observer.disconnect()
+    }
+
+    visibleFaces.clear()
+    observedFaces.clear()
+    faces = []
+    delete window.__hbFaceClock
+  }
+
+  // Newer desktops: the SDK's budgeted loop owns scheduling (15fps budget,
+  // hidden/minimized/unfocused pause, dormancy, teardown). typeof-guarded so
+  // older shells and the vm test harness use the hand-rolled path below.
+  if (typeof createBudgetedLoop === 'function' && createBudgetedLoop) {
+    const loop = createBudgetedLoop(paint, {
+      fps: 15,
+      idleWhen: idle as () => boolean
+    })
+
+    window.__hbFaceClock = {
+      stop: () => {
+        loop.dispose()
+        teardownCaches()
+      },
+      wake: () => {
+        // Faces may have mounted/unmounted while parked — rescan on wake.
+        lastScan = -Infinity
+        loop.wake()
+      }
+    }
+
+    return
+  }
+
+  // Fallback scheduling for desktops whose SDK predates createBudgetedLoop.
+  let lastPaint = -Infinity
+  let rafId = 0
+  let dormant = false
+  let stopped = false
+
+  const tick = (now: number) => {
+    if (stopped) {
+      return
+    }
+
+    rafId = 0
+
+    // 15fps is smooth at avatar scale and bounds SVG/DOM churn. The clock
+    // still uses rAF so Chromium can pause it when the window is occluded.
+    if (!document.hidden && now - lastPaint >= 1000 / 15) {
+      paint(now)
+      lastPaint = now
+    }
+
+    // Park instead of burning frames + 1Hz whole-document shadow walks.
+    if (idle()) {
+      dormant = true
+
+      return
+    }
+
+    rafId = window.requestAnimationFrame(tick)
+  }
+
+  const wake = () => {
+    if (stopped || !dormant) {
+      return
+    }
+
+    dormant = false
+    // Faces may have mounted/unmounted while parked — rescan on first tick.
+    lastScan = -Infinity
+    rafId = window.requestAnimationFrame(tick)
+  }
+
+  const stop = () => {
+    stopped = true
+
+    if (rafId) {
+      window.cancelAnimationFrame(rafId)
+      rafId = 0
+    }
+
+    teardownCaches()
+  }
+
+  window.__hbFaceClock = {
+    stop,
+    wake
+  }
+  rafId = window.requestAnimationFrame(tick)
+}
+
+/** Tear the face clock down (plugin disable/reload) — cancels the animation
+ *  frame, disconnects the visibility observer, and drops all cached nodes. */
+export function stopFaceClock() {
+  if (typeof window !== 'undefined' && window.__hbFaceClock) {
+    window.__hbFaceClock.stop()
+  }
+}
+
+interface BotFaceProps {
+  color: string
+  image?: null | string
+  mood?: FaceMood
+  name?: string
+  /** Free-form appearance string, not just AvatarShape: also `sigil-<n>`,
+   *  a platonic solid, or `blobatar[:seed[:kind]]`. */
+  shape: string
+  size?: number
+}
+
+/**
+ * Live math face. Photos still use <img>. Shape avatars stay SVG so
+ * the clock can move them (a baked PNG cannot).
+ */
+export function BotFace({ shape, color, image, size = 36, name = 'agent', mood = 'idle' }: BotFaceProps) {
+  startFaceClock()
+
+  if (image) {
+    return (
+      <img
+        alt=""
+        aria-hidden
+        src={image}
+        style={{
+          width: size,
+          height: size,
+          borderRadius: '22%',
+          objectFit: 'cover',
+          display: 'block'
+        }}
+      />
+    )
+  }
+
+  // Blobatar shapes: the library draws the whole face (body + eyes + its own
+  // name-derived palette). Inline SVG via innerHTML so the roster PNG
+  // backfill's `svg[data-bot-face=…]` query still finds it; the math clock
+  // ignores it (no data-hb-math). Falls back to the legacy math face when the
+  // SDK predates the export.
+  if (isBlobShape(shape)) {
+    const markup = blobMarkup(shape, name, size)
+
+    if (markup) {
+      return (
+        <span
+          aria-hidden
+          dangerouslySetInnerHTML={{
+            __html: markup
+          }}
+          style={{
+            width: size,
+            height: size,
+            display: 'block',
+            lineHeight: 0
+          }}
+        />
+      )
+    }
+
+    // Older SDK without blobatar: legacy deterministic shape from the name.
+    shape = defaultShapeFor(name)
+  }
+
+  // Sigils are line art (no filled body) — the math clock rebuilds filled
+  // outlines, which would turn a stored sigil pick into a blank circle.
+  // Keep the legacy static render for them so old picks still draw.
+  if (shape.startsWith('sigil-')) {
+    const eyes = (
+      <g>
+        <circle cx={16} cy={14} fill={color} r={2.4} />
+        <circle cx={24} cy={14} fill={color} r={2.4} />
+      </g>
+    )
+
+    return (
+      <svg aria-hidden data-bot-face={name} height={size} viewBox="0 0 40 40" width={size}>
+        {shapeNode(shape, color, name)}
+        {eyes}
+      </svg>
+    )
+  }
+
+  const working = mood === 'work'
+  const eyeFill = isDarkColor(color) ? 'rgba(232,220,195,0.95)' : 'rgba(0,0,0,0.85)'
+  // Catchlight contrast follows the pupil, not the body: dark pupils get the
+  // white sparkle, light (cream) pupils on dark bodies get a dark one — a
+  // white dot on a cream pupil is invisible, which read as "no eye dots" on
+  // maroon/ink/oxblood avatars.
+  const hlFill = isDarkColor(color) ? 'rgba(0,0,0,0.6)' : 'rgba(255,255,255,0.85)'
+  const ring = sampleFaceRing(shape)
+  const rest = facePose(working ? 'work' : 'idle', 0)
+  // Shape-aware initial eye line — the cloud body sits lower, so its eyes
+  // (and their catchlights) start at the cloud position instead of jumping
+  // there on the first clock paint.
+  const eyeY0 = shape === 'cloud' ? 22 : 17.2
+
+  return (
+    <svg
+      aria-hidden
+      className="block overflow-visible"
+      data-bot-face={name}
+      data-hb-math="1"
+      data-hb-mood={working ? 'work' : 'idle'}
+      data-hb-shape={shape || 'circle'}
+      height={size}
+      viewBox="0 0 40 44"
+      width={size}
+    >
+      <path
+        d={
+          shape === 'cloud'
+            ? 'M11 32 a7.5 7.5 0 0 1 -1 -14.9 A9.5 9.5 0 0 1 29 12.5 A7 7 0 0 1 30 32 Z'
+            : ringToPath(ring)
+        }
+        data-hb-body="1"
+        fill={color}
+      />
+      <g data-hb-open="1">
+        <ellipse cx={15.4} cy={eyeY0} data-hb-el="1" fill={eyeFill} rx={2.2} ry={working ? 2.6 : 2.3} />
+        <ellipse cx={24.6} cy={eyeY0} data-hb-er="1" fill={eyeFill} rx={2.2} ry={working ? 2.6 : 2.3} />
+        <circle cx={14.8} cy={eyeY0 - 0.7} data-hb-hl-l="1" fill={hlFill} r={0.65} />
+        <circle cx={24} cy={eyeY0 - 0.7} data-hb-hl-r="1" fill={hlFill} r={0.65} />
+      </g>
+      <path
+        d={`M12.8 ${eyeY0} L18 ${eyeY0} M22 ${eyeY0} L27.2 ${eyeY0}`}
+        data-hb-shut="1"
+        fill="none"
+        opacity={0}
+        stroke={eyeFill}
+        strokeLinecap="round"
+        strokeWidth={2}
+      />
+      {working ? (
+        <g>
+          <circle cx={16.4} cy={41.2} data-hb-dot="1" fill={color} opacity={rest.d0} r={1.15} />
+          <circle cx={20} cy={41.2} data-hb-dot="1" fill={color} opacity={rest.d1} r={1.15} />
+          <circle cx={23.6} cy={41.2} data-hb-dot="1" fill={color} opacity={rest.d2} r={1.15} />
+        </g>
+      ) : null}
+    </svg>
+  )
+}
+
+/** The friendly violet the primary profile has always worn, and the last
+ *  resort for a draft that has no name to derive a hue from yet. */
+const PRIMARY_AVATAR_COLOR = '#8b5cf6'
+
+/** A picked color wins; with none, fall back to the name's deterministic hue —
+ *  the same one `botAppearance` seeds — so "no choice" means the app's color
+ *  rather than an arbitrary constant. */
+export function avatarColor(color: null | string | undefined, name: string): string {
+  return color || profileColor(name) || PRIMARY_AVATAR_COLOR
+}
+
+export function botAppearance(name: string, meta: BotMeta | null | undefined): AvatarAppearance {
+  // The primary profile is literally named "default"; the SDK's profileColor
+  // can hand it a near-black that renders as an ugly black square, and any
+  // auto-seeded color in local bot-meta would otherwise stick. Give the
+  // primary a nice fixed generic look (a friendly violet squircle). A user's
+  // EXPLICIT customization still wins: an uploaded/generated/pet image, or a
+  // shape/color they set via the editor (tracked by meta.custom === true).
+  const isPrimary = (name || '').trim().toLowerCase() === 'default'
+  const userCustomized = Boolean(meta?.custom)
+
+  if (isPrimary && !userCustomized) {
+    return {
+      shape: 'squircle',
+      color: PRIMARY_AVATAR_COLOR,
+      image: meta?.image || null
+    }
+  }
+
+  return {
+    shape: meta?.shape || defaultShapeFor(name),
+    color: meta?.color || profileColor(name),
+    image: meta?.image || null
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/bot-delete.test.ts b/apps/desktop/src/plugins/hermes-bots/bot-delete.test.ts
new file mode 100644
index 000000000000..fcacba31d4b9
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/bot-delete.test.ts
@@ -0,0 +1,254 @@
+/**
+ * Deleting a bot deletes its Hermes profile, then everything plugin-local
+ * that would otherwise leave stale appearance/unread data behind.
+ *
+ * `host.deleteProfile` is preferred whenever the Desktop build ships it: it
+ * routes through the Electron-intercepted REST delete, which tears the bot's
+ * pool backend down FIRST. The older `cli.exec` path bypasses that
+ * interception, so a backend the roster's hover pre-warm just woke (a
+ * right-click hovers the row!) holds the profile dir open and the CLI's rmtree
+ * races it — that is the "can't delete a bot" error (hermes-agent#52279).
+ *
+ * Ported from tests/bot-delete.test.mjs, which ran the whole plugin.js bundle
+ * under `vm`.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { ProfileRoute, RosterRow } from './types'
+
+const { forgetSessionUnread, invalidateQueries, newChat, overrides, request, stateAtoms } = vi.hoisted(() => {
+  const makeAtom = <T>(initial: T) => {
+    let value = initial
+
+    return {
+      get: () => value,
+      listen: () => () => undefined,
+      set: (next: T) => {
+        value = next
+      }
+    }
+  }
+
+  return {
+    forgetSessionUnread: vi.fn(),
+    invalidateQueries: vi.fn(),
+    newChat: vi.fn(),
+    // Read through a Proxy below so a test can make a host verb *absent* —
+    // `typeof host.deleteProfile === 'function'` is the whole feature gate.
+    overrides: {} as Record<string, unknown>,
+    request: vi.fn(),
+    stateAtoms: {
+      connectionId: makeAtom('local'),
+      focusedSessionOwner: makeAtom<{ connectionId: string; profile: string }>({
+        connectionId: 'local',
+        profile: 'default'
+      }),
+      profile: makeAtom('default')
+    }
+  }
+})
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  overrides.newChat = newChat
+  overrides.request = request
+  overrides.state = { ...sdk.host.state, ...stateAtoms }
+
+  return {
+    ...sdk,
+    forgetSessionUnread,
+    host: new Proxy(sdk.host, {
+      get: (target, prop) => (prop in overrides ? overrides[prop as string] : Reflect.get(target, prop))
+    }),
+    queryClient: { invalidateQueries }
+  }
+})
+
+interface StorageOp {
+  key: string
+  op: 'remove' | 'set'
+  value?: unknown
+}
+
+const remoteRoute: ProfileRoute = {
+  connectionId: 'source-a',
+  mode: 'remote',
+  profile: 'worker',
+  targetProfile: 'backend-worker'
+}
+
+async function loadModules() {
+  vi.resetModules()
+
+  const ops: StorageOp[] = []
+  const [data, profileOps, shared] = await Promise.all([import('./data'), import('./profile-ops'), import('./shared')])
+
+  shared.setPluginCtx({
+    storage: {
+      get: () => null,
+      remove: (key: string) => {
+        ops.push({ key, op: 'remove' })
+      },
+      set: (key: string, value: unknown) => {
+        ops.push({ key, op: 'set', value })
+      }
+    }
+  } as unknown as Parameters<typeof shared.setPluginCtx>[0])
+
+  return { data, ops, profileOps }
+}
+
+// Pay the graph's cold transform once, up front. `loadModules` re-imports on
+// every test, and charging that one-time cost to whichever test happens to run
+// first makes it time out under a loaded runner.
+beforeAll(async () => {
+  await loadModules()
+}, 60_000)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  // Absent by default: the older-desktop shape. Tests opt in to the SDK verb.
+  overrides.deleteProfile = undefined
+  request.mockResolvedValue({ blocked: false, code: 0, output: 'deleted' })
+  stateAtoms.connectionId.set('local')
+  stateAtoms.focusedSessionOwner.set({ connectionId: 'local', profile: 'default' })
+  stateAtoms.profile.set('default')
+})
+
+describe('the SDK delete verb is preferred over the CLI', () => {
+  it('deletes through host.deleteProfile and never shells out', async () => {
+    const deleteProfile = vi.fn()
+
+    overrides.deleteProfile = deleteProfile
+
+    const { profileOps } = await loadModules()
+
+    await profileOps.deleteBot({ name: 'researcher' } as RosterRow)
+
+    expect(deleteProfile.mock.calls).toEqual([['researcher']])
+    expect(request.mock.calls.filter(([method]) => method === 'cli.exec')).toHaveLength(0)
+  })
+
+  it('hands a source-scoped row its whole route, targetProfile included', async () => {
+    const deleteProfile = vi.fn()
+
+    overrides.deleteProfile = deleteProfile
+
+    const { profileOps } = await loadModules()
+
+    await profileOps.deleteBot({ name: 'worker', route: remoteRoute, sourceScoped: true } as RosterRow)
+
+    expect(deleteProfile.mock.calls[0][0]).toMatchObject(remoteRoute)
+  })
+
+  it('falls back to the non-interactive profile CLI on an older desktop', async () => {
+    const { profileOps } = await loadModules()
+
+    await profileOps.deleteBot({ name: 'researcher' } as RosterRow)
+
+    const exec = request.mock.calls.filter(([method]) => method === 'cli.exec')
+
+    expect(exec[0][1]).toEqual({ argv: ['profile', 'delete', 'researcher', '--yes'] })
+  })
+})
+
+describe('deletes that must not happen', () => {
+  it('rejects an alias whose backend target is the default profile', async () => {
+    const deleteProfile = vi.fn()
+
+    overrides.deleteProfile = deleteProfile
+
+    const { profileOps } = await loadModules()
+
+    await expect(
+      profileOps.deleteBot({
+        name: 'worker',
+        route: { ...remoteRoute, targetProfile: 'default' },
+        sourceScoped: true
+      } as RosterRow)
+    ).rejects.toThrow(/default profile cannot be deleted/i)
+
+    expect(deleteProfile).not.toHaveBeenCalled()
+    expect(request.mock.calls.some(([method]) => method === 'cli.exec')).toBe(false)
+  })
+
+  it('fails a source-scoped delete closed rather than shelling out', async () => {
+    const { profileOps } = await loadModules()
+
+    await expect(
+      profileOps.deleteBot({
+        name: 'worker',
+        route: { ...remoteRoute, targetProfile: 'worker' },
+        sourceScoped: true
+      } as RosterRow)
+    ).rejects.toThrow(/source-scoped profile deletion requires host\.deleteProfile/i)
+
+    expect(request.mock.calls.some(([method]) => method === 'cli.exec')).toBe(false)
+  })
+})
+
+describe('plugin-local state is cleaned up behind the delete', () => {
+  it('commits the source-scoped bot-meta-v2 snapshot atomically', async () => {
+    overrides.deleteProfile = vi.fn()
+
+    const { data, ops, profileOps } = await loadModules()
+
+    data.$botMeta.set({
+      'source-a::worker': { title: 'Worker' },
+      'source-a::writer': { title: 'Writer' }
+    })
+
+    await profileOps.deleteBot({ name: 'worker', route: remoteRoute, sourceScoped: true } as RosterRow)
+
+    expect(ops.slice(-3)).toEqual([
+      { key: 'bot-meta-v2-migrated', op: 'remove' },
+      { key: 'bot-meta-v2', op: 'set', value: { 'source-a::writer': { title: 'Writer' } } },
+      { key: 'bot-meta-v2-migrated', op: 'set', value: true }
+    ])
+  })
+
+  it('drops meta, unread and selection, then refreshes the roster', async () => {
+    const { data, ops, profileOps } = await loadModules()
+
+    data.$botMeta.set({ researcher: { title: 'Research' }, writer: { title: 'Writer' } })
+    data.$lastRoster.set([{ name: 'researcher' }, { name: 'writer' }] as RosterRow[])
+
+    const { $selectedBot } = await import('./bot-state')
+
+    $selectedBot.set('researcher')
+
+    await profileOps.deleteBot({
+      canonical_session: { id: 'reg-1', resolved_id: 'tip-9' },
+      name: 'researcher'
+    } as RosterRow)
+
+    expect(data.$botMeta.get().researcher).toBeUndefined()
+    // Unread lives in core's store now; both ids because the marker may have
+    // been filed under either tip of the chat's compression lineage.
+    expect(forgetSessionUnread).toHaveBeenCalledWith(['reg-1', 'tip-9'], 'researcher')
+    expect($selectedBot.get()).toBe('default')
+    expect(ops.at(-1)?.key).toBe('bot-meta')
+    expect((ops.at(-1)?.value as Record<string, unknown>).researcher).toBeUndefined()
+    expect(invalidateQueries).toHaveBeenCalledTimes(1)
+  })
+
+  it('keeps the active chat when the deleted bot is a same-name twin elsewhere', async () => {
+    overrides.deleteProfile = vi.fn()
+    stateAtoms.connectionId.set('source-b')
+    stateAtoms.focusedSessionOwner.set({ connectionId: 'source-b', profile: 'worker' })
+    stateAtoms.profile.set('worker')
+
+    const { profileOps } = await loadModules()
+
+    await profileOps.deleteBot({
+      name: 'worker',
+      route: { ...remoteRoute, targetProfile: 'worker' },
+      sourceScoped: true
+    } as RosterRow)
+
+    expect(newChat).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/bot-open-focus-identity.test.ts b/apps/desktop/src/plugins/hermes-bots/bot-open-focus-identity.test.ts
new file mode 100644
index 000000000000..09ec244831e2
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/bot-open-focus-identity.test.ts
@@ -0,0 +1,97 @@
+/**
+ * First-click home bounce (community report, Aug 2026): clicking a bot whose
+ * canonical Bot Chat had been COMPRESSED landed on the Bots home instead of
+ * the chat, and only a second click got through.
+ *
+ * Root cause: openRosterBot claimed the center with the durable registry id,
+ * but the session-focus edge that the open itself fired reports the
+ * compression-lineage TIP. releaseStaleOpenBotChat compared tip !== registry
+ * id, called the claim stale, released it, and the home reasserted over the
+ * freshly opened chat. The second click "worked" only because the tip was
+ * already focused, so no new focus edge fired to sabotage it.
+ *
+ * The fix is to carry BOTH identities: openBotCanonicalChat returns
+ * registryId + openedId, the claim stores both, and focus on either one keeps
+ * it.
+ *
+ * Ported from tests/bot-open-focus-identity.test.mjs.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+const { ackStoredSessionId, openBotCanonicalChat } = vi.hoisted(() => ({
+  ackStoredSessionId: vi.fn(),
+  openBotCanonicalChat: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  return { ...sdk, ackStoredSessionId }
+})
+
+vi.mock('./canonical-chat', () => ({
+  ensureBotMetadata: vi.fn(async () => ({})),
+  notifyBotOpenFailure: vi.fn(),
+  openBotCanonicalChat,
+  prepareBotSource: vi.fn(async () => undefined),
+  PROFILE_SESSION_LIST_LIMIT: 200
+}))
+
+const { $openBotChat } = await import('./bot-state')
+const { openRosterBot } = await import('./roster-actions')
+const { releaseStaleOpenBotChat } = await import('./roster-pane')
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  $openBotChat.set(null)
+})
+
+describe('an open claims both identities of the chat it opened', () => {
+  it('records the registry row and the lineage tip it actually navigated to', async () => {
+    openBotCanonicalChat.mockResolvedValue({ openedId: 'tip-9', registryId: 'reg-1' })
+
+    await openRosterBot({ connectionId: 'local', name: 'ops' } as RosterRow)
+
+    expect($openBotChat.get()).toMatchObject({ openedRegistryId: 'reg-1', openedSessionId: 'tip-9' })
+  })
+})
+
+describe('focus on either owned identity keeps the claim', () => {
+  it('survives the tip focus edge the open itself fires', () => {
+    $openBotChat.set({ key: 'k', openedRegistryId: 'reg-1', openedSessionId: 'tip-9' })
+
+    releaseStaleOpenBotChat('tip-9')
+
+    expect($openBotChat.get()).not.toBeNull()
+  })
+
+  it('survives focus reported as the durable registry id', () => {
+    $openBotChat.set({ key: 'k', openedRegistryId: 'reg-1', openedSessionId: 'tip-9' })
+
+    releaseStaleOpenBotChat('reg-1')
+
+    expect($openBotChat.get()).not.toBeNull()
+  })
+
+  it('releases on a genuinely foreign session', () => {
+    $openBotChat.set({ key: 'k', openedRegistryId: 'reg-1', openedSessionId: 'tip-9' })
+
+    releaseStaleOpenBotChat('other-session')
+
+    expect($openBotChat.get()).toBeNull()
+  })
+
+  it('releases a legacy draft claim as soon as any session takes focus', () => {
+    // The newChat fallback has no registry id to compare against, so it only
+    // yields once something is actually focused.
+    $openBotChat.set({ key: 'k', openedRegistryId: '' })
+
+    releaseStaleOpenBotChat('any')
+
+    expect($openBotChat.get()).toBeNull()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/bot-row-keeps-closed-chat.test.ts b/apps/desktop/src/plugins/hermes-bots/bot-row-keeps-closed-chat.test.ts
new file mode 100644
index 000000000000..8cab602765e1
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/bot-row-keeps-closed-chat.test.ts
@@ -0,0 +1,191 @@
+/**
+ * A bot row click is "go to this bot", not "open its Bot Chat". Before this,
+ * every click resolved the canonical chat by name and opened it as a tab — and
+ * with no record of a close anywhere (this plugin keeps no closed set; core's
+ * tile bucket only forgets), a Bot Chat the user closed came back beside every
+ * newer thread on every bot switch. Now a bot whose workspace already holds
+ * tabs comes back to the one the user left; the forever-chat is opened only
+ * when nothing is open, or on the explicit ask (the row menu's "Open Bot Chat").
+ *
+ * Ported from tests/bot-row-keeps-closed-chat.test.mjs, which drove a `vm`
+ * copy of plugin.js. Its two source-reading cases are dropped for real
+ * assertions: the menu's call site is now a render in bot-row.test.tsx, and
+ * the reclaim guard's text is asserted here as the claim-shape invariant the
+ * guard actually reads.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+const { openBotCanonicalChat, prepareBotSource } = vi.hoisted(() => ({
+  openBotCanonicalChat: vi.fn(),
+  prepareBotSource: vi.fn()
+}))
+
+vi.mock('./canonical-chat', () => ({
+  ensureBotMetadata: vi.fn(async () => ({})),
+  notifyBotOpenFailure: vi.fn(),
+  openBotCanonicalChat,
+  prepareBotSource,
+  PROFILE_SESSION_LIST_LIMIT: 200
+}))
+
+const { host } = await import('@hermes/plugin-sdk')
+const { $openBotChat, $selectedBot } = await import('./bot-state')
+const { openRosterBot } = await import('./roster-actions')
+
+const bot = { connectionId: 'local', name: 'alpha' } as RosterRow
+
+/** Swap in a focus API for one test, restoring whatever the SDK really has —
+ *  including its absence, which is the older-shell case. */
+function withFocusApi(impl: null | (() => null | string)) {
+  const had = Object.hasOwn(host, 'focusOpenWorkspaceSession')
+  const original = host.focusOpenWorkspaceSession
+
+  if (impl) {
+    host.focusOpenWorkspaceSession = impl
+  } else {
+    // @ts-expect-error — modelling a Desktop old enough to lack the verb.
+    delete host.focusOpenWorkspaceSession
+  }
+
+  return () => {
+    if (had) {
+      host.focusOpenWorkspaceSession = original
+    } else {
+      // @ts-expect-error — same.
+      delete host.focusOpenWorkspaceSession
+    }
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  prepareBotSource.mockResolvedValue(undefined)
+  openBotCanonicalChat.mockResolvedValue({ openedId: 'bot-chat', registryId: 'bot-chat' })
+  $openBotChat.set(null)
+  $selectedBot.set('')
+})
+
+describe('a row click returns to the tabs the bot already has open', () => {
+  it('fronts the remembered tab and resolves no canonical chat', async () => {
+    const focus = vi.fn(() => 'thread-2')
+    const restore = withFocusApi(focus)
+
+    try {
+      await expect(openRosterBot(bot)).resolves.toBe(true)
+
+      expect(focus).toHaveBeenCalledWith('bot:alpha')
+      expect(openBotCanonicalChat).not.toHaveBeenCalled()
+      // Open tabs need no source activation either — the bot is already live.
+      expect(prepareBotSource).not.toHaveBeenCalled()
+    } finally {
+      restore()
+    }
+  })
+
+  it('claims only the fronted tab, with no registry id', async () => {
+    const restore = withFocusApi(() => 'thread-2')
+
+    try {
+      await openRosterBot(bot)
+
+      expect($openBotChat.get()).toEqual({
+        key: 'local::alpha',
+        openedRegistryId: '',
+        openedSessionId: 'thread-2'
+      })
+    } finally {
+      restore()
+    }
+  })
+})
+
+describe('the canonical chat still opens when it is what was asked for', () => {
+  it('opens it when the bot has nothing open', async () => {
+    const restore = withFocusApi(() => null)
+
+    try {
+      await expect(openRosterBot(bot)).resolves.toBe(true)
+
+      expect(openBotCanonicalChat).toHaveBeenCalled()
+      expect($openBotChat.get()?.openedRegistryId).toBe('bot-chat')
+    } finally {
+      restore()
+    }
+  })
+
+  it('skips the open-tab shortcut on the explicit ask', async () => {
+    const focus = vi.fn(() => 'thread-2')
+    const restore = withFocusApi(focus)
+
+    try {
+      await expect(openRosterBot(bot, { canonical: true })).resolves.toBe(true)
+
+      expect(focus).not.toHaveBeenCalled()
+      expect($openBotChat.get()?.openedRegistryId).toBe('bot-chat')
+    } finally {
+      restore()
+    }
+  })
+})
+
+describe('a shell that cannot report open tabs behaves as it did before', () => {
+  it('opens the canonical chat when the verb is missing', async () => {
+    const restore = withFocusApi(null)
+
+    try {
+      await expect(openRosterBot(bot)).resolves.toBe(true)
+
+      expect(openBotCanonicalChat).toHaveBeenCalled()
+    } finally {
+      restore()
+    }
+  })
+
+  it('opens the canonical chat when the verb throws', async () => {
+    const restore = withFocusApi(() => {
+      throw new Error('no tree yet')
+    })
+
+    try {
+      await expect(openRosterBot(bot)).resolves.toBe(true)
+
+      expect(openBotCanonicalChat).toHaveBeenCalled()
+    } finally {
+      restore()
+    }
+  })
+})
+
+describe('the claim a fronted tab records cannot resurrect the closed chat', () => {
+  // The reclaim listener re-resolves the canonical chat for a claim it owns,
+  // and guards on the registry id to avoid doing so for a fronted tab. That
+  // guard is only correct because a fronted-tab claim leaves the id empty
+  // while a real canonical open always fills it — the invariant asserted here.
+  it('leaves the registry id empty for a fronted tab', async () => {
+    const restore = withFocusApi(() => 'thread-2')
+
+    try {
+      await openRosterBot(bot)
+
+      expect($openBotChat.get()?.openedRegistryId).toBe('')
+      expect($openBotChat.get()?.openedSessionId).toBeTruthy()
+    } finally {
+      restore()
+    }
+  })
+
+  it('fills the registry id for a real canonical open', async () => {
+    const restore = withFocusApi(() => null)
+
+    try {
+      await openRosterBot(bot)
+
+      expect($openBotChat.get()?.openedRegistryId).toBeTruthy()
+    } finally {
+      restore()
+    }
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/bot-row.test.tsx b/apps/desktop/src/plugins/hermes-bots/bot-row.test.tsx
new file mode 100644
index 000000000000..ce51a8fe9749
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/bot-row.test.tsx
@@ -0,0 +1,177 @@
+/**
+ * The bot row's two side effects: pre-warming and opening.
+ *
+ * Pre-warm is per-row and hover-scoped. Warming the whole roster on paint
+ * spun up every profile backend the moment the Bots rail rendered, so the row
+ * warms exactly one bot and only once a pointer is actually over it — and a
+ * source-scoped row pre-dials its OWN source rather than the active gateway.
+ *
+ * Opening is delegated whole: the row hands its exact roster row to
+ * openRosterBot and does nothing else. It never activates a connection
+ * itself, which is what keeps a remote row from resolving into the same-named
+ * local bot.
+ *
+ * Ported from tests/profile-prewarm.test.mjs, which sliced BotRow out of the
+ * old plugin.js bundle and rendered it against a hand-built jsx stub.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { fireEvent, render, screen } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { BotRow } from './bot-row'
+import { translateBots } from './i18n-test-helper'
+import type { RosterRow } from './types'
+
+const { ensureAgent, ensureBotMetadata, notifyError, openRosterBot, requestProfile, warmAgent, warmProfile } =
+  vi.hoisted(() => ({
+    ensureAgent: vi.fn(),
+    ensureBotMetadata: vi.fn(),
+    notifyError: vi.fn(),
+    openRosterBot: vi.fn(),
+    requestProfile: vi.fn(),
+    warmAgent: vi.fn(),
+    warmProfile: vi.fn()
+  }))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  return {
+    ...sdk,
+    host: { ...sdk.host, ensureAgent, notifyError, requestProfile, warmAgent, warmProfile },
+    // The plugin bundle normally lands via `ctx.i18n.register` at load, so
+    // without this every localized label in the row renders empty.
+    usePluginI18n: () => translateBots
+  }
+})
+
+vi.mock('./canonical-chat', () => ({
+  ensureBotMetadata,
+  notifyBotOpenFailure: vi.fn(),
+  openBotCanonicalChat: vi.fn(),
+  prepareBotSource: vi.fn(),
+  PROFILE_SESSION_LIST_LIMIT: 200
+}))
+
+vi.mock('./roster-actions', () => ({ openRosterBot }))
+
+const noop = () => undefined
+
+function renderRow(bot: RosterRow) {
+  render(<BotRow bot={bot} onDelete={noop} onEdit={noop} onGroup={noop} />)
+
+  return screen.getByRole('button')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  ensureBotMetadata.mockResolvedValue({ pinned: true })
+  openRosterBot.mockResolvedValue(true)
+  requestProfile.mockResolvedValue({})
+})
+
+describe('pre-warm is hover-scoped, never roster-wide', () => {
+  it('warms nothing on paint and exactly the hovered bot on pointer entry', async () => {
+    const row = renderRow({ name: 'alpha' } as RosterRow)
+
+    expect(warmProfile).not.toHaveBeenCalled()
+
+    fireEvent.pointerEnter(row)
+
+    expect(warmProfile.mock.calls).toEqual([['alpha']])
+    expect(warmAgent).not.toHaveBeenCalled()
+  })
+
+  it('pre-dials a source-scoped row on its own source', async () => {
+    const row = renderRow({
+      connectionId: 'work',
+      connectionLabel: 'Work',
+      name: 'research',
+      remoteSource: true,
+      sourceScoped: true
+    } as RosterRow)
+
+    fireEvent.pointerEnter(row)
+
+    expect(warmAgent.mock.calls).toEqual([['work', 'research']])
+    expect(warmProfile).not.toHaveBeenCalled()
+  })
+})
+
+describe('the row delegates the open and claims no activation authority', () => {
+  it('hands a remote Connections row to openRosterBot without activating it', async () => {
+    const bot = {
+      connectionId: 'work',
+      connectionLabel: 'Work',
+      name: 'research',
+      remoteSource: true,
+      sourceScoped: true
+    } as RosterRow
+
+    fireEvent.click(renderRow(bot))
+
+    expect(ensureAgent).not.toHaveBeenCalled()
+    expect(openRosterBot.mock.calls).toEqual([[bot]])
+  })
+
+  it('never resolves a remote default into the same-named local bot', async () => {
+    const bot = {
+      connectionId: 'mac-mini',
+      connectionLabel: 'Mac Mini',
+      name: 'default',
+      remoteSource: true,
+      sourceScoped: true
+    } as RosterRow
+
+    fireEvent.click(renderRow(bot))
+
+    expect(ensureAgent).not.toHaveBeenCalled()
+    expect(openRosterBot.mock.calls[0][0].connectionId).toBe('mac-mini')
+    expect(notifyError).not.toHaveBeenCalled()
+  })
+})
+
+describe('the menu carries the explicit ask for the forever-chat', () => {
+  it('opens the canonical chat, which a plain row click deliberately does not', async () => {
+    const bot = { name: 'alpha' } as RosterRow
+
+    fireEvent.contextMenu(renderRow(bot))
+    fireEvent.click(await screen.findByText('Open Bot Chat'))
+
+    expect(openRosterBot.mock.calls).toEqual([[bot, { canonical: true }]])
+  })
+})
+
+describe('context-menu mutations hydrate the alias first', () => {
+  it('reads the backend row before toggling pin, and writes to the alias target', async () => {
+    // A non-identity alias (Desktop calls it `worker`, the backend calls it
+    // `backend-worker`) must have its CURRENT state hydrated from its own
+    // source before the toggle — flipping a locally-assumed value would
+    // fight whatever the backend actually holds.
+    const bot = {
+      connectionId: 'remote-a',
+      name: 'worker',
+      remoteSource: true,
+      route: { connectionId: 'remote-a', mode: 'remote', profile: 'worker', targetProfile: 'backend-worker' },
+      sourceScoped: true
+    } as RosterRow
+
+    fireEvent.contextMenu(renderRow(bot))
+    // The label reads from LOCAL meta (unpinned here); the toggle reads from
+    // the hydrated backend row, which says pinned. That divergence is the
+    // point — an alias whose state lives elsewhere must not be flipped
+    // against a locally-assumed value.
+    fireEvent.click(await screen.findByText('Pin to top'))
+    await vi.waitFor(() =>
+      expect(requestProfile.mock.calls.some(([, method]) => method === 'profiles.configure')).toBe(true)
+    )
+
+    expect(ensureBotMetadata).toHaveBeenCalledWith(bot)
+
+    const [route, , params] = requestProfile.mock.calls.find(([, method]) => method === 'profiles.configure')!
+
+    expect(route.profile).toBe('worker')
+    expect(params).toMatchObject({ name: 'backend-worker', ui_meta: { 'hermes-bots': { pinned: false } } })
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/bot-row.tsx b/apps/desktop/src/plugins/hermes-bots/bot-row.tsx
new file mode 100644
index 000000000000..06a21cd3e421
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/bot-row.tsx
@@ -0,0 +1,518 @@
+/**
+ * The two rows the Bots rail lists: one bot, and one group chat.
+ *
+ * Rows only. Both take their bot or room and their context-menu callbacks as
+ * props and own no roster state, so the pane above them decides what to list
+ * and the row decides only how it reads.
+ */
+
+import {
+  cn,
+  coarseElapsed,
+  Codicon,
+  ContextMenu,
+  ContextMenuContent,
+  ContextMenuItem,
+  ContextMenuSeparator,
+  ContextMenuTrigger,
+  haptic,
+  host,
+  queryClient,
+  RowButton,
+  SessionStatusDot,
+  SidebarRowLead,
+  Tip,
+  useI18n,
+  useValue
+} from '@hermes/plugin-sdk'
+
+import { avatarColor, botAppearance, BotFace } from './avatar'
+import { isBackfilledFacePng } from './avatar-image'
+import {
+  $botChatFocused,
+  $focusedBotOwner,
+  $selectedRosterKey,
+  focusedRosterOwner,
+  saveSelectedRosterBot
+} from './bot-state'
+import { ensureBotMetadata } from './canonical-chat'
+import {
+  $botAttention,
+  $botMeta,
+  $lastRoster,
+  BOT_ATTENTION_HINTS,
+  botActivitySession,
+  botHandle,
+  botRosterKey,
+  botSelectionKey,
+  botSourceStatus,
+  isActiveRosterBot,
+  isDefaultBot,
+  newBotChat,
+  ROSTER_KEY,
+  saveBotMeta
+} from './data'
+import { $groupChats, $groupChatWorkspace } from './group-chat'
+import { botGroups, groupLastActivity } from './group-membership'
+import { fallbackSelectionAfterHide, isBotHidden, isBotPinned } from './hidden-bots'
+import { useBots } from './i18n'
+import { displayName, stripPreviewMarkdown } from './labels'
+import { duplicateBot } from './profile-ops'
+import { openRosterBot } from './roster-actions'
+import { botRosterMeta, botWorkspaceOwnerKey, setBotsWorkspaceOwner } from './routing'
+import { A2A_PREFIX_RE, botCanonicalSessionId, botRowOwnsWorkspace, previewKind, workerActiveAt } from './row-helpers'
+import type { GroupMember, RosterRow, SidebarRowLabels } from './types'
+
+// ── bot row ──────────────────────────────────────────────────────────────────
+
+/** Row age in the sidebar's compact form ("now", "52m", "3h", "18d").
+ *  Deliberately the same `coarseElapsed` + suffix pair the session rows
+ *  directly above use, so the two lists in one rail don't disagree about how
+ *  an age is spelled. Not `relativeTime` — that's the bidirectional Intl form
+ *  ("in 14 hr"), which belongs on a scheduled next-run. */
+function rowAge(ms: number, r: SidebarRowLabels): string {
+  const { unit, value } = coarseElapsed(Date.now() - ms)
+
+  return unit === 'second' ? r.ageNow : `${value}${unit === 'day' ? r.ageDay : unit === 'hour' ? r.ageHour : r.ageMin}`
+}
+
+interface BotRowProps {
+  bot: RosterRow
+  onDelete: (bot: RosterRow) => void
+  onEdit: (bot: RosterRow) => void
+  onGroup: (bot: RosterRow) => void
+  showHandle?: boolean
+}
+
+export function BotRow({ bot, onDelete, onEdit, onGroup, showHandle }: BotRowProps) {
+  const { t } = useI18n()
+  const b = useBots()
+  const activeProfile = useValue(host.state.profile)
+  const focusedOwner = focusedRosterOwner(useValue($focusedBotOwner))
+  const selectedRosterKey = useValue($selectedRosterKey)
+  const botChatFocused = useValue($botChatFocused)
+  const activeGroup = useValue($groupChatWorkspace)
+  const allMeta = useValue($botMeta)
+  const meta = botRosterMeta(bot, allMeta)
+  const hidden = isBotHidden(bot, allMeta)
+  const pinned = isBotPinned(bot, allMeta)
+  const sourceStatus = botSourceStatus(bot)
+  const groups = botGroups(meta)
+  const last = bot.last_session
+  // Highlight follows the chat on screen (focused session's owner), not the
+  // gateway socket's home — a focused tab doesn't swap the socket, and on the
+  // old keying the wrong bot stayed highlighted while you read another's chat.
+  // A selected group chat suppresses every bot-row highlight: the group row
+  // owns the selection then (#88979).
+  const activeConnectionId = String(host.state.connectionId?.get?.() || 'local').trim()
+  // The highlight follows whoever owns the MAIN workspace. While a chat owns
+  // it, that chat's profile wins (a stale roster click must not key the
+  // highlight to a bot you are not reading). With no focused chat, the
+  // source-qualified selection is the owner — and it is the only rule that
+  // can highlight a remote row, which has no focusable local chat.
+  const isActive = botRowOwnsWorkspace(bot, activeGroup, botChatFocused, focusedOwner, selectedRosterKey)
+
+  // Turn-busy is a SOCKET fact: only the gateway-home profile can be mid-turn.
+  const isGatewayHome =
+    !bot.remoteSource &&
+    bot.name === activeProfile &&
+    isActiveRosterBot(bot, {
+      name: activeProfile,
+      connectionId: activeConnectionId
+    })
+
+  const { shape, color, image } = botAppearance(bot.name, meta)
+  // Keep user photos/pets. Drop the 160px SVG backfill so the math face can move.
+  const photo = Boolean(image && !isBackfilledFacePng(image))
+  const gatewayState = useValue(host.state.gateway)
+  // Preview identity must match click identity (#88200): when the backend
+  // resolved the pinned canonical chat, preview THAT session — not the
+  // profile's most recent (but unrelated) activity. Activity signals
+  // (age label, pulse dot) follow the same rule via botActivitySession:
+  // the canonical Bot Chat is hidden from last_session, so keying age off
+  // last_session alone shows "6d ago" on a bot you just messaged.
+  const previewSession = bot.canonical_session || last
+  const activitySession = botActivitySession(bot)
+  // A live kanban/tool worker counts as activity (#90268): fresh age while it
+  // runs, falling back to chat activity when it ends.
+  const workerActive = workerActiveAt(bot)
+
+  const rowAgeTs = workerActive
+    ? Math.max(activitySession?.last_active || 0, bot.worker_session?.last_active || 0)
+    : activitySession?.last_active || 0
+
+  const botMood = workerActive || (isGatewayHome && gatewayState === 'busy') ? 'work' : 'idle'
+  // Status keys off the canonical Bot Chat — the very session this row opens,
+  // so the dot and the click can never describe different conversations.
+  const canonicalSessionId = botCanonicalSessionId(bot)
+  // Needs-attention badge (#93091 item 3): background failures record under
+  // the selection key (group turns) or the route key (relay deliveries) —
+  // check both. Local/unannotated rows carry no connectionId, so their relay
+  // failures live under `<activeConnectionId>::<name>` — resolve that shape
+  // too or active-gateway bots never badge. Hidden bots keep their entry;
+  // hiding is display-only.
+  const attentionByKey = useValue($botAttention)
+
+  const attention =
+    attentionByKey[botSelectionKey(bot)] ||
+    attentionByKey[botRosterKey(bot)] ||
+    attentionByKey[`${bot?.connectionId || activeConnectionId}::${bot?.name || 'default'}`] ||
+    null
+
+  // WHO sent the last message (bot-to-bot DM vs human) — the full stored
+  // history lives in the canonical chat, not inline.
+  // Preview identity must match click identity (#88200): when the backend
+  // resolved the pinned canonical chat, preview THAT session — not the
+  // profile's most recent (but unrelated) activity. Liveness checks above
+  // keep last_session semantics: any recent activity means the bot is alive.
+  const { fromBot } = previewKind(previewSession?.preview)
+
+  // DM previews read like DMs: strip the delivery prefix, keep the message.
+  const displayPreview = stripPreviewMarkdown(
+    fromBot ? (previewSession?.preview || '').replace(A2A_PREFIX_RE, '').trim() || '…' : previewSession?.preview || ''
+  )
+
+  const handle = botHandle(bot.name, bot)
+  const gatewayLabel = bot.connectionLabel || (bot.connectionId === 'local' ? 'This device' : '')
+  const showDetailsRow = Boolean(showHandle || displayPreview || fromBot)
+
+  const rowTooltip = [displayName(bot, meta), `@${handle}`, gatewayLabel, sourceStatus.label]
+    .filter(Boolean)
+    .join(' · ')
+
+  const warm = () => {
+    // Multi-source row: pre-dial the agent's OWN source (feature-detected).
+    if (bot.sourceScoped && typeof host.warmAgent === 'function') {
+      try {
+        host.warmAgent(bot.connectionId, bot.name)
+      } catch {
+        /* warm is best-effort */
+      }
+
+      return
+    }
+
+    if (typeof host.warmProfile !== 'function') {
+      return
+    }
+
+    try {
+      host.warmProfile(bot.name)
+    } catch {
+      /* warm is best-effort */
+    }
+  }
+
+  // Rows and Active Now share the exact-owner open path; only that path may
+  // activate a source and resolve the canonical Bot Chat.
+  const open = () => void openRosterBot(bot)
+
+  const row = (
+    <RowButton
+      aria-label={rowTooltip}
+      className={cn(
+        'flex w-full min-w-0 max-w-full items-center gap-2.5 overflow-hidden rounded-md px-2 py-2 text-left transition-colors',
+        'hover:bg-(--chrome-action-hover)',
+        isActive && 'bg-(--ui-row-active-background)'
+      )}
+      onClick={open}
+      onPointerEnter={warm}
+    >
+      <div className={cn('shrink-0', !sourceStatus.available && 'grayscale opacity-60')}>
+        <BotFace
+          color={avatarColor(color, bot.name)}
+          image={photo ? image : null}
+          mood={botMood}
+          name={bot.name}
+          shape={shape}
+          size={34}
+        />
+      </div>
+      <div className="min-w-0 flex-1">
+        <div className="flex items-baseline justify-between gap-2">
+          <div className="flex min-w-0 items-center gap-1.5">
+            {/* The session row's own lead cell, so a bot's name sits on the
+                same left edge as every session name above it in the rail. */}
+            <SidebarRowLead>
+              <SessionStatusDot storedSessionId={canonicalSessionId} />
+            </SidebarRowLead>
+            {pinned ? (
+              <Tip label={b.roster.pinned}>
+                <Codicon className="shrink-0 text-[0.6875rem] text-(--ui-text-quaternary)" name="pinned" />
+              </Tip>
+            ) : null}
+            {hidden ? (
+              <Tip label={b.roster.hiddenFromRoster}>
+                <Codicon className="shrink-0 text-[0.6875rem] text-(--ui-text-quaternary)" name="eye-closed" />
+              </Tip>
+            ) : null}
+            <Tip label={rowTooltip}>
+              <span className="min-w-0 truncate text-[0.8125rem] font-medium">{displayName(bot, meta)}</span>
+            </Tip>
+          </div>
+          {attention ? (
+            <Tip label={BOT_ATTENTION_HINTS[attention.reason] || 'Needs attention'}>
+              <Codicon
+                aria-label={b.roster.needsAttention}
+                className="shrink-0 text-[0.6875rem] text-amber-600 dark:text-amber-300"
+                name="warning"
+              />
+            </Tip>
+          ) : null}
+          {rowAgeTs ? (
+            <span className="shrink-0 text-[0.6875rem] text-(--ui-text-quaternary)">
+              {rowAge(rowAgeTs * 1000, t.sidebar.row)}
+            </span>
+          ) : null}
+        </div>
+        {showDetailsRow ? (
+          <div className="flex min-w-0 items-center gap-1.5 text-xs text-(--ui-text-tertiary)">
+            {showHandle ? (
+              <span className="shrink-0 font-mono text-[0.6875rem] text-(--ui-text-quaternary)">{`@${handle}`}</span>
+            ) : null}
+            {showHandle && displayPreview ? <span className="shrink-0 text-(--ui-text-quaternary)">·</span> : null}
+            {displayPreview ? (
+              <span className={cn('min-w-0 truncate', fromBot && 'italic')}>{displayPreview}</span>
+            ) : null}
+          </div>
+        ) : null}
+      </div>
+    </RowButton>
+  )
+
+  return (
+    <ContextMenu>
+      <ContextMenuTrigger asChild>{row}</ContextMenuTrigger>
+      <ContextMenuContent>
+        <ContextMenuItem onSelect={() => void openRosterBot(bot, { canonical: true })}>
+          {b.bot.openBotChat}
+        </ContextMenuItem>
+        <ContextMenuSeparator />
+        <ContextMenuItem
+          onSelect={() => {
+            void ensureBotMetadata(bot)
+              .then(current => {
+                const pinned = Boolean(current.pinned)
+                void saveBotMeta(bot, {
+                  pinned: !pinned
+                })
+                host.notify({
+                  kind: 'info',
+                  message: `${displayName(bot, current)} ${pinned ? 'unpinned' : 'pinned to top'}`
+                })
+              })
+              .catch(error => host.notifyError?.(error, 'Could not load bot metadata'))
+          }}
+        >
+          {pinned ? 'Unpin' : 'Pin to top'}
+        </ContextMenuItem>
+        <ContextMenuItem
+          onSelect={() => {
+            void ensureBotMetadata(bot)
+              .then(current => {
+                const hidden = Boolean(current.hidden)
+                void saveBotMeta(bot, {
+                  hidden: !hidden
+                })
+
+                if (!hidden) {
+                  fallbackSelectionAfterHide(botSelectionKey(bot))
+                }
+
+                host.notify({
+                  kind: 'info',
+                  message: hidden
+                    ? `${displayName(bot, current)} is back in the roster`
+                    : `${displayName(bot, current)} hidden — use the eye button in the Bots header to see hidden bots`
+                })
+              })
+              .catch(error => host.notifyError?.(error, 'Could not load bot metadata'))
+          }}
+        >
+          {hidden ? 'Unhide' : 'Hide'}
+        </ContextMenuItem>
+        <ContextMenuSeparator />
+        <ContextMenuItem
+          onSelect={() =>
+            void ensureBotMetadata(bot)
+              .then(() => onEdit(bot))
+              .catch(error => host.notifyError?.(error, 'Could not load bot'))
+          }
+        >
+          {b.bot.editTitle}
+        </ContextMenuItem>
+        <ContextMenuItem
+          onSelect={() =>
+            void ensureBotMetadata(bot)
+              .then(() => onGroup(bot))
+              .catch(error => host.notifyError?.(error, 'Could not load bot groups'))
+          }
+        >
+          {groups.length ? `Groups: ${groups.join(', ')}…` : 'Manage groups…'}
+        </ContextMenuItem>
+        <ContextMenuItem
+          onSelect={() => {
+            host.notify({
+              kind: 'info',
+              message: `Duplicating ${displayName(bot, meta)}…`
+            })
+            duplicateBot(bot, $lastRoster.get())
+              .then(name => {
+                queryClient.invalidateQueries({
+                  queryKey: ROSTER_KEY
+                })
+                host.notify({
+                  kind: 'success',
+                  message: `Created ${name} — full copy of ${bot.name}`
+                })
+              })
+              .catch(err => host.notifyError(err, b.bot.duplicateFailed))
+          }}
+        >
+          {b.bot.duplicate}
+        </ContextMenuItem>
+        <ContextMenuSeparator />
+        <ContextMenuItem
+          onSelect={() => {
+            saveSelectedRosterBot(bot)
+            setBotsWorkspaceOwner(botWorkspaceOwnerKey(bot), bot)
+            newBotChat(bot)
+          }}
+        >
+          {b.bot.newChatWith}
+        </ContextMenuItem>
+        {isDefaultBot(bot) ? null : <ContextMenuSeparator />}
+        {isDefaultBot(bot) ? null : (
+          <ContextMenuItem onSelect={() => onDelete(bot)} variant="destructive">
+            {t.common.delete}
+          </ContextMenuItem>
+        )}
+      </ContextMenuContent>
+    </ContextMenu>
+  )
+}
+
+/** One group chat as one quiet roster row. The room owns one visual identity;
+ *  member details stay in its tooltip and workspace instead of competing
+ *  with bot avatars in the narrow sidebar. */
+interface GroupRowProps {
+  active: boolean
+  group: string
+  members: GroupMember[]
+  needsYou: boolean
+  onDisband: (room: { members: GroupMember[]; name: string }) => void
+  onOpen: (group: string) => void
+}
+
+export function GroupRow({ active, group, members, needsYou, onOpen, onDisband }: GroupRowProps) {
+  const { t } = useI18n()
+  const b = useBots()
+  const rooms = useValue($groupChats)
+
+  const room = rooms[group] || {
+    log: []
+  }
+
+  const log = Array.isArray(room.log) ? room.log : []
+  const last = log.length ? log[log.length - 1] : null
+  const lastAt = groupLastActivity(room)
+  // Room previews speak the same handle vocabulary as the roster, mentions
+  // and the group prompt: the primary profile is @hermes, not @default.
+  const lastFrom = last?.from?.name || ''
+
+  const lastHandle = botHandle(
+    lastFrom || 'bot',
+    members.find(member => member?.name === lastFrom)
+  )
+
+  const preview = last
+    ? `${last.from?.kind === 'user' ? 'You' : `@${lastHandle}`}: ${stripPreviewMarkdown(last.text) || '…'}`
+    : `${members.length} bots`
+
+  const availableMembers = members.filter(member => botSourceStatus(member).available).length
+  const availabilityLabel = `${availableMembers} of ${members.length} available`
+
+  const row = (
+    <RowButton
+      aria-label={`${group}, ${members.length} bots, ${availabilityLabel}`}
+      className={cn(
+        'flex w-full min-w-0 max-w-full items-center gap-2.5 overflow-hidden rounded-md px-2 py-2 text-left transition-colors',
+        'hover:bg-(--chrome-action-hover)',
+        active && 'bg-(--ui-row-active-background)'
+      )}
+      onClick={() => {
+        haptic('tap')
+        onOpen(group)
+      }}
+    >
+      <div className="relative flex w-[34px] shrink-0 items-center justify-center">
+        {room.image ? (
+          <img
+            alt=""
+            className={cn(
+              'size-8 rounded-md object-cover ring-1 ring-(--ui-stroke-tertiary)',
+              availableMembers === 0 && 'grayscale opacity-60'
+            )}
+            src={room.image}
+          />
+        ) : (
+          <span
+            className={cn(
+              'flex size-8 items-center justify-center rounded-md bg-(--chrome-action-hover) text-(--ui-text-tertiary)',
+              availableMembers === 0 && 'opacity-60'
+            )}
+          >
+            <Codicon name="organization" />
+          </span>
+        )}
+        {members.length > 0 && availableMembers < members.length ? (
+          <Tip label={availabilityLabel}>
+            <span
+              aria-label={availabilityLabel}
+              className="absolute -bottom-0.5 -right-0.5 flex size-4 items-center justify-center rounded-full bg-(--ui-bg-primary) text-[0.625rem] text-amber-600 ring-1 ring-(--ui-stroke-tertiary) dark:text-amber-300"
+            >
+              <Codicon name="debug-disconnect" />
+            </span>
+          </Tip>
+        ) : null}
+      </div>
+      <div className="min-w-0 flex-1">
+        <div className="flex items-baseline justify-between gap-2">
+          <span className="min-w-0 flex-1 truncate text-[0.8125rem] font-medium">{group}</span>
+          {needsYou ? (
+            <Tip label={b.group.needsYourInput}>
+              <Codicon aria-label={b.roster.needsInput} className="shrink-0 text-(--ui-accent)" name="question" />
+            </Tip>
+          ) : null}
+          {lastAt ? (
+            <span className="shrink-0 text-[0.6875rem] text-(--ui-text-quaternary)">
+              {rowAge(lastAt, t.sidebar.row)}
+            </span>
+          ) : null}
+        </div>
+        <div className="min-w-0 truncate text-xs text-(--ui-text-tertiary)">{preview}</div>
+      </div>
+    </RowButton>
+  )
+
+  return (
+    <ContextMenu>
+      <ContextMenuTrigger asChild>{row}</ContextMenuTrigger>
+      <ContextMenuContent>
+        <ContextMenuItem onSelect={() => onOpen(group)}>Open Group Chat</ContextMenuItem>
+        <ContextMenuSeparator />
+        <ContextMenuItem
+          className="text-destructive focus:text-destructive"
+          onSelect={() =>
+            onDisband({
+              name: group,
+              members
+            })
+          }
+        >
+          {b.group.deleteAction}
+        </ContextMenuItem>
+      </ContextMenuContent>
+    </ContextMenu>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/bot-state.focused-owner.test.ts b/apps/desktop/src/plugins/hermes-bots/bot-state.focused-owner.test.ts
new file mode 100644
index 000000000000..e4400b414645
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/bot-state.focused-owner.test.ts
@@ -0,0 +1,149 @@
+/**
+ * The roster highlight and the Routines tile follow the chat the user is
+ * LOOKING AT — the focused session's OWNER (profile + connection) — not the
+ * gateway socket's home. Tab focus moves without swapping the socket, so
+ * keying off `host.state.profile` highlighted the wrong bot whenever a focused
+ * tab showed another profile's chat (community report: Newsanalyst chat open,
+ * Hermes highlighted).
+ *
+ * Newer desktops publish the complete pair as `host.state.focusedSessionOwner`.
+ * Older ones expose only `focusedSessionProfile`, a legacy HALF-SHAPE with no
+ * source identity: pairing that profile with the ambient connection id
+ * manufactures a cross-source owner out of two unrelated atoms, which is how a
+ * remote bot got highlighted as "active" on the wrong machine. The fallback
+ * therefore fails closed unless the focused profile IS the active profile.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+interface Store<T> {
+  get: () => T
+  listen: (listener: (value: T) => void) => () => void
+}
+
+const { state } = vi.hoisted(() => ({
+  state: {
+    activeConnectionId: '' as string,
+    connectionId: 'source-a',
+    focusedProfile: null as null | string,
+    focusedOwner: null as null | { authoritative?: boolean; connectionId: string; profile: string },
+    profile: 'default'
+  }
+}))
+
+const store = <T>(read: () => T): Store<T> => ({ get: read, listen: () => () => undefined })
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    atom,
+    host: {
+      activeConnectionId: () => state.activeConnectionId,
+      state: {
+        connectionId: store(() => state.connectionId),
+        // Both focus atoms are FEATURE-DETECTED: their absence is the whole
+        // signal on an older desktop, so they must be genuinely absent.
+        get focusedSessionOwner() {
+          return state.focusedOwner ? store(() => state.focusedOwner) : undefined
+        },
+        get focusedSessionProfile() {
+          return state.focusedProfile === null ? undefined : store(() => state.focusedProfile)
+        },
+        profile: store(() => state.profile)
+      }
+    },
+    queryClient: { invalidateQueries: vi.fn() },
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+/** $focusedBotOwner binds to host.state at module load, so each topology needs
+ *  a fresh graph. */
+async function load() {
+  vi.resetModules()
+
+  const [botState, data] = await Promise.all([import('./bot-state'), import('./data')])
+
+  return { ...botState, isActiveRosterBot: data.isActiveRosterBot }
+}
+
+beforeEach(() => {
+  state.activeConnectionId = ''
+  state.connectionId = 'source-a'
+  state.focusedOwner = null
+  state.focusedProfile = null
+  state.profile = 'default'
+})
+
+describe('a desktop that publishes the complete focused owner', () => {
+  it('uses it verbatim and treats it as authoritative', async () => {
+    state.focusedOwner = { connectionId: 'source-b', profile: 'worker' }
+
+    const { $focusedBotOwner, focusedRosterOwner, isActiveRosterBot } = await load()
+    const owner = focusedRosterOwner($focusedBotOwner.get())
+
+    expect(owner).toEqual({ authoritative: true, connectionId: 'source-b', name: 'worker' })
+    expect(isActiveRosterBot({ connectionId: 'source-b', name: 'worker', remoteSource: true }, owner)).toBe(true)
+    // Same name on ANOTHER machine is a different agent.
+    expect(isActiveRosterBot({ connectionId: 'source-a', name: 'worker', remoteSource: true }, owner)).toBe(false)
+  })
+})
+
+describe('a legacy desktop with focusedSessionProfile only', () => {
+  it('fails closed rather than pairing foreign focus with the ambient connection', async () => {
+    state.focusedProfile = 'worker'
+    state.profile = 'default'
+
+    const { $focusedBotOwner, focusedRosterOwner, isActiveRosterBot } = await load()
+    const owner = focusedRosterOwner($focusedBotOwner.get())
+
+    expect(owner).toBeNull()
+    expect(isActiveRosterBot({ connectionId: 'source-a', name: 'worker', remoteSource: true }, owner)).toBe(false)
+    // And nothing else gets highlighted in its place.
+    expect(isActiveRosterBot({ name: 'default' }, owner)).toBe(false)
+  })
+
+  it('reuses the ambient connection only when focus IS the active profile', async () => {
+    state.focusedProfile = 'default'
+    state.profile = 'default'
+
+    const { $focusedBotOwner, focusedRosterOwner } = await load()
+
+    // Non-authoritative: it is inferred, not published by the desktop.
+    expect(focusedRosterOwner($focusedBotOwner.get())).toEqual({
+      authoritative: false,
+      connectionId: 'source-a',
+      name: 'default'
+    })
+  })
+})
+
+describe('a desktop with neither focus atom', () => {
+  it('falls back to the socket home profile', async () => {
+    state.profile = 'researcher'
+    state.activeConnectionId = 'source-a'
+    state.connectionId = ''
+
+    const { $focusedBotOwner, focusedMentionProfile, focusedRosterOwner } = await load()
+
+    expect(focusedMentionProfile()).toBe('researcher')
+    expect(focusedRosterOwner($focusedBotOwner.get())).toEqual({
+      authoritative: false,
+      connectionId: 'source-a',
+      name: 'researcher'
+    })
+  })
+})
+
+describe('focusedRosterOwner', () => {
+  it('reports nothing for an owner with no profile', async () => {
+    const { focusedRosterOwner } = await load()
+
+    expect(focusedRosterOwner(null)).toBeNull()
+    expect(focusedRosterOwner({ connectionId: 'source-a', profile: '  ' })).toBeNull()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/bot-state.ts b/apps/desktop/src/plugins/hermes-bots/bot-state.ts
new file mode 100644
index 000000000000..a478189ff8f7
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/bot-state.ts
@@ -0,0 +1,177 @@
+/**
+ * The window-local state Bot Mode's surfaces share: which roster row is
+ * selected, which owner's chat is on screen, and the per-bot activity
+ * watermarks the unread poll compares against.
+ *
+ * A leaf by design. The roster, the routines tile, the create dialog and the
+ * delete path all read and write this, and it reads none of them — so no
+ * surface has to import a sibling surface to know what is selected.
+ */
+
+import { atom, host } from '@hermes/plugin-sdk'
+
+import { botRosterKey, botSelectionKey } from './data'
+import { getPluginCtx } from './shared'
+import type { RosterRow } from './types'
+
+// last_active watermark per source-qualified bot, seeded on first poll so a
+// fresh mount doesn't mark ancient history unread.
+export const rosterWatermarks = new Map<string, number>()
+
+// Bot Mode sessions are ALWAYS hidden from the global Sessions sidebar:
+// canonical Bot Chats are plugin-owned forever-chats and group-chat member
+// sessions are room plumbing — neither is a scratch conversation, and a
+// 6-member room would otherwise dump six identical "Group: ..." rows into
+// recents. Backed by the core generic `hidden` session flag (session.create
+// hidden:true / session.set_hidden). Older gateways ignore the flag and the
+// sessions simply stay visible there.
+
+/** Bot the Routines tile is scoped to. Follows the live gateway profile
+ *  (the bot you're actually chatting with) and roster clicks. */
+export const $selectedBot = atom('default')
+
+/** Owner of the chat the user is LOOKING AT. Newer desktops expose a
+ *  connection-qualified owner. Older builds synthesize the previous
+ *  profile/gateway fallback and listen to both atoms when available. */
+/** Source-qualified Bot Mode selection. Restoring it is presentation-only:
+ *  it never activates a gateway or creates a session. */
+export const $selectedRosterKey = atom('')
+export const $selectedRosterHydrated = atom(false)
+export const $rosterHydrated = atom(false)
+/** Mirrors host.paneVisibility('hermes-bots:pane') — wired in register(). */
+export const $botsPaneVisible = atom(false)
+/** An explicit open landed: {key, openedRegistryId, openedSessionId}. The
+ *  registry id is empty for the legacy newChat draft fallback and for a click
+ *  that came back to the bot's already-open tabs (only openedSessionId set — no
+ *  canonical chat was resolved). This transient view observation is never an
+ *  identity preference. */
+export const $openBotChat = atom<{ key: string; openedRegistryId: string; openedSessionId?: string } | null>(null)
+/** A session owns the main workspace. The roster highlight and the Cronjobs
+ *  lifecycle both key off this rather than reading host.state conditionally
+ *  from render. */
+export const $botChatFocused = atom(false)
+
+export function saveSelectedRosterBot(bot: RosterRow) {
+  const key = botRosterKey(bot)
+  $selectedBot.set(botSelectionKey(bot))
+  $selectedRosterKey.set(key)
+
+  try {
+    Promise.resolve(getPluginCtx()?.storage?.set?.('selected-roster-bot-v1', key)).catch(() => undefined)
+  } catch {
+    /* storage unavailable — selection lasts for this window */
+  }
+}
+
+export function clearSelectedRosterBot(bot: RosterRow) {
+  clearSelectedRosterKey(botRosterKey(bot))
+}
+
+/** Drop the persisted selection when it is exactly this key — the caller has
+ *  proven the owner is gone, not merely unreachable. An unreachable source
+ *  KEEPS its key so the selection reconciles when the gateway returns. */
+export function clearSelectedRosterKey(key: string) {
+  if ($selectedRosterKey.get() !== key) {
+    return
+  }
+
+  $selectedRosterKey.set('')
+
+  try {
+    Promise.resolve(getPluginCtx()?.storage?.set?.('selected-roster-bot-v1', '')).catch(() => undefined)
+  } catch {
+    /* storage unavailable — selection is cleared for this window */
+  }
+}
+
+/** Split a roster key back into its owner parts. Profile names cannot contain
+ *  ':' (NAME_RE), so the first '::' is unambiguous. */
+export function parseRosterKey(key: null | string | undefined) {
+  const raw = String(key || '')
+  const at = raw.indexOf('::')
+
+  if (at < 0) {
+    return {
+      connectionId: '',
+      name: ''
+    }
+  }
+
+  return {
+    connectionId: raw.slice(0, at),
+    name: raw.slice(at + 2)
+  }
+}
+
+const $focusedBotProfile = host.state.focusedSessionProfile || host.state.profile
+
+/** Profile that owns the chat currently on screen. Bot Mode opens another
+ *  profile's session without moving the gateway socket, so mention filtering
+ *  and sender identity must follow focus rather than host.state.profile. */
+export function focusedMentionProfile() {
+  return String($focusedBotProfile.get?.() || '').trim() || 'default'
+}
+
+function fallbackFocusedBotOwner(profile: string = $focusedBotProfile.get?.()) {
+  const focusedProfile = String(profile || 'default').trim() || 'default'
+  const activeProfile = String(host.state.profile?.get?.() || 'default').trim() || 'default'
+
+  // focusedSessionProfile without focusedSessionOwner is a legacy half-shape:
+  // it carries no source identity. Only reuse the active connection when the
+  // focused profile is also the active profile; otherwise fail closed rather
+  // than manufacturing a cross-source owner from unrelated atoms.
+  if (host.state.focusedSessionProfile && focusedProfile !== activeProfile) {
+    return null
+  }
+
+  const connectionId = String(
+    host.state.connectionId?.get?.() ||
+      (typeof host.activeConnectionId === 'function' ? host.activeConnectionId() : '') ||
+      ''
+  ).trim()
+
+  return {
+    authoritative: false,
+    connectionId,
+    profile: focusedProfile
+  }
+}
+
+export const $focusedBotOwner = host.state.focusedSessionOwner || {
+  get: () => fallbackFocusedBotOwner(),
+  listen: (listener: (value: ReturnType<typeof fallbackFocusedBotOwner>) => void) => {
+    const emit = (profile: string) => listener(fallbackFocusedBotOwner(profile))
+    const unbindProfile = $focusedBotProfile.listen(emit)
+    const unbindConnection = host.state.connectionId?.listen?.(() => emit($focusedBotProfile.get?.()))
+
+    return () => {
+      unbindProfile?.()
+      unbindConnection?.()
+    }
+  }
+}
+
+export function focusedRosterOwner(
+  owner: {
+    authoritative?: boolean
+    connectionId?: string
+    name?: string
+    profile?: string
+  } | null
+) {
+  // TODO(bot-mode-types): `owner.name` cannot exist. Every caller passes
+  // $focusedBotOwner, whose two shapes (host.state.focusedSessionOwner and
+  // fallbackFocusedBotOwner) both key the profile as `profile`, so the
+  // `owner?.name` arm is unreachable and a name-only owner would be dropped.
+  const name = String(owner?.profile || owner?.name || '').trim()
+
+  if (!owner || !name) {
+    return null
+  }
+
+  return {
+    authoritative: owner.authoritative !== false,
+    connectionId: String(owner.connectionId || '').trim(),
+    name
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/canonical-chat-adopt-on-conflict.test.ts b/apps/desktop/src/plugins/hermes-bots/canonical-chat-adopt-on-conflict.test.ts
new file mode 100644
index 000000000000..fb60121058d1
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/canonical-chat-adopt-on-conflict.test.ts
@@ -0,0 +1,169 @@
+/**
+ * ADOPT-BEFORE-MINT (#92473 part 2).
+ *
+ * Between the registry miss and our eager `session.title` write, another
+ * writer can take the canonical title (peer dm minting server-side, a second
+ * machine, cross-connection sync). UNIQUE(title) rejects our write with
+ * "already in use". Before this fix that rejection was read as "old gateway"
+ * and the compat path prompted into OUR stray lazy session — forking the
+ * forever chat. Now the mint re-consults the registry and adopts the winner;
+ * the stray zero-message session is abandoned to the gateway's pruner.
+ *
+ * Ported from tests/canonical-chat-adopt-on-conflict.test.mjs.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+const { hostMock, persistMock, requestForBotMock, saveBotMetaMock } = vi.hoisted(() => ({
+  hostMock: { openSession: vi.fn(), request: vi.fn() },
+  persistMock: vi.fn(),
+  requestForBotMock: vi.fn(),
+  saveBotMetaMock: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', () => ({
+  BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS: 15_000,
+  host: hostMock
+}))
+
+vi.mock('./routing', () => ({
+  backendTargetProfile: (route: { targetProfile?: string } | null, name: string) => route?.targetProfile ?? name,
+  botConnectionRoute: () => null,
+  botRosterMeta: () => ({}),
+  botWorkspaceOwnerKey: (bot: { name?: string } | null) => String(bot?.name || ''),
+  requestForBot: requestForBotMock
+}))
+
+vi.mock('./data', () => ({
+  $botMeta: { get: () => ({}), set: vi.fn() },
+  botMetaKey: (bot: { name?: string }) => bot?.name ?? '',
+  botOwner: (owner: RosterRow | string) =>
+    typeof owner === 'string'
+      ? { bot: { name: owner }, key: owner, name: owner, route: null }
+      : { bot: owner, key: owner?.name, name: owner?.name, route: null },
+  persistBotMetaSnapshot: persistMock,
+  saveBotMeta: saveBotMetaMock
+}))
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null }))
+
+let events: string[]
+
+function respondWith(handler: (method: string) => unknown) {
+  requestForBotMock.mockImplementation(async (_bot: unknown, method: string) => {
+    events.push(method)
+
+    return handler(method)
+  })
+}
+
+async function loadModule() {
+  vi.resetModules()
+
+  return import('./canonical-chat')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  events = []
+  hostMock.openSession.mockImplementation(async (id: string) => {
+    events.push(`open:${id}`)
+  })
+})
+
+describe('a title-uniqueness rejection means someone else won the registry', () => {
+  it('adopts the racing winner instead of forking into the stray row', async () => {
+    let lists = 0
+
+    respondWith(method => {
+      if (method === 'session.list') {
+        lists += 1
+
+        // First consult: registry miss (this is why we mint at all). Second
+        // consult (after the conflict): the racing winner exists.
+        return lists === 1
+          ? { sessions: [] }
+          : { sessions: [{ id: 'winner-1', message_count: 3, resolved_id: 'winner-1', title: 'Bot Chat' }] }
+      }
+
+      if (method === 'session.create') {
+        return { session_id: 'rt-stray', stored_session_id: 'stray-1' }
+      }
+
+      if (method === 'session.title') {
+        throw new Error("Title 'Bot Chat' is already in use by session winner-1")
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+
+    expect(await createCanonicalChat('ops')).toBe('winner-1')
+    // The winner is opened; the stray is never prompted into or opened.
+    expect(events).toContain('open:winner-1')
+    expect(events).not.toContain('prompt.submit')
+    expect(events).not.toContain('open:stray-1')
+  })
+
+  it('adopts the winner but does not navigate once the user has clicked away', async () => {
+    // The conflict path is a full extra round-trip past the point every
+    // sibling open is staleness-probed at, so it is the likeliest of them all
+    // to land late. Identity must still resolve — only the workspace steal is
+    // what the probe prevents.
+    let lists = 0
+
+    respondWith(method => {
+      if (method === 'session.list') {
+        lists += 1
+
+        return lists === 1
+          ? { sessions: [] }
+          : { sessions: [{ id: 'winner-1', message_count: 3, resolved_id: 'winner-1', title: 'Bot Chat' }] }
+      }
+
+      if (method === 'session.create') {
+        return { session_id: 'rt-stray', stored_session_id: 'stray-1' }
+      }
+
+      if (method === 'session.title') {
+        throw new Error("Title 'Bot Chat' is already in use by session winner-1")
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+
+    expect(await createCanonicalChat('ops', { openingStillCurrent: () => false })).toBe('winner-1')
+    expect(events).not.toContain('open:winner-1')
+  })
+
+  it('keeps the compat path for a NON-conflict title failure (old gateways)', async () => {
+    respondWith(method => {
+      if (method === 'session.list') {
+        return { sessions: [] }
+      }
+
+      if (method === 'session.create') {
+        return { session_id: 'rt-1', stored_session_id: 'stored-1' }
+      }
+
+      if (method === 'session.title') {
+        throw new Error('unknown method')
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+
+    expect(await createCanonicalChat('ops')).toBe('stored-1')
+    // Old gateway: eager title unsupported → the kickoff persists the lazy row.
+    expect(events).toContain('prompt.submit')
+    // Only the initial registry consult — a plain failure must not re-list.
+    expect(events.filter(event => event === 'session.list')).toHaveLength(1)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/canonical-chat-creation.test.ts b/apps/desktop/src/plugins/hermes-bots/canonical-chat-creation.test.ts
new file mode 100644
index 000000000000..7c3b8906588d
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/canonical-chat-creation.test.ts
@@ -0,0 +1,330 @@
+/**
+ * Minting a bot's forever-chat.
+ *
+ * `session.create` is lazy: the stored row does not exist until something
+ * writes to it. Creation therefore materializes and TITLES the row eagerly,
+ * before it opens or prompts — until the row carries "Bot Chat" the registry
+ * has no entry for this bot, and a second click during that window mints a
+ * duplicate forever-chat. Older gateways that reject the eager title keep a
+ * narrow compat kickoff, else the pruner reaps the empty lazy session and the
+ * chat never survives its own creation.
+ *
+ * The other half of the contract is navigation: a create still completes
+ * registry-side when the user has already moved on, but it must not steal the
+ * workspace (#89834 family).
+ *
+ * Ported from tests/canonical-chat-creation.test.mjs, which sliced the
+ * creation section out of the old plugin.js bundle and ran it under `vm`.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+const { hostMock, persistMock, pluginCtx, requestForBotMock, saveBotMetaMock } = vi.hoisted(() => ({
+  hostMock: { openSession: vi.fn(), request: vi.fn() },
+  persistMock: vi.fn(),
+  // Null unless a test installs one — the plugin ctx is genuinely absent until
+  // register() runs, which is why every read of it carries an English floor.
+  pluginCtx: { current: null as null | { i18n?: { t: (key: string) => string } } },
+  requestForBotMock: vi.fn(),
+  saveBotMetaMock: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', () => ({
+  BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS: 15_000,
+  host: hostMock
+}))
+
+vi.mock('./routing', () => ({
+  backendTargetProfile: (route: { targetProfile?: string } | null, name: string) => route?.targetProfile ?? name,
+  botConnectionRoute: () => null,
+  botRosterMeta: () => ({}),
+  botWorkspaceOwnerKey: (bot: { connectionId?: string; name?: string } | null) =>
+    `bot:${bot?.connectionId ? `${bot.connectionId}::` : ''}${bot?.name || 'default'}`,
+  requestForBot: requestForBotMock
+}))
+
+vi.mock('./data', () => ({
+  $botMeta: { get: () => ({}), set: vi.fn() },
+  botMetaKey: (bot: { name?: string }) => bot?.name ?? '',
+  botOwner: (owner: RosterRow | string) =>
+    typeof owner === 'string'
+      ? { bot: { name: owner }, key: owner, name: owner, route: null }
+      : { bot: owner, key: owner?.name, name: owner?.name, route: null },
+  persistBotMetaSnapshot: persistMock,
+  saveBotMeta: saveBotMetaMock
+}))
+
+vi.mock('./shared', () => ({ getPluginCtx: () => pluginCtx.current }))
+
+/** Ordered log of everything creation did — RPCs and navigations interleaved,
+ *  because the ORDER between them is most of what this suite pins. */
+let events: string[]
+
+function respondWith(handler: (method: string, params: Record<string, unknown>) => unknown) {
+  requestForBotMock.mockImplementation(async (_bot: unknown, method: string, params: Record<string, unknown>) =>
+    handler(method, params ?? {})
+  )
+}
+
+async function loadModule() {
+  // Creation is single-flighted through a module-level map keyed by bot.
+  vi.resetModules()
+
+  return import('./canonical-chat')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  events = []
+  pluginCtx.current = null
+  hostMock.openSession.mockImplementation(async (id: string) => {
+    events.push(`open:${id}`)
+  })
+})
+
+/** Runs a kickoff creation and hands back the text the intro turn submitted. */
+async function kickoffTextSent(): Promise<string> {
+  let sent = ''
+
+  respondWith((method, params) => {
+    if (method === 'session.create') {
+      return { session_id: 'runtime-1', stored_session_id: 'stored-1' }
+    }
+
+    if (method === 'prompt.submit') {
+      sent = String(params.text ?? '')
+    }
+
+    return {}
+  })
+
+  const { createCanonicalChat } = await loadModule()
+
+  await createCanonicalChat('ops', { kickoff: true })
+
+  return sent
+}
+
+describe('the lazy row is materialized before anything else touches it', () => {
+  it('titles the created row, then opens it, and sends no intro', async () => {
+    respondWith((method, params) => {
+      events.push(method)
+
+      if (method === 'session.create') {
+        return { session_id: 'runtime-1', stored_session_id: 'stored-1' }
+      }
+
+      if (method === 'session.title') {
+        // A throw here is NOT inert: createCanonicalChat reads it as "eager
+        // title unsupported" and falls back to the compat kickoff.
+        expect(params).toEqual({ session_id: 'runtime-1', title: 'Bot Chat' })
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+
+    // No kickoff option: the click-path mint. The eager title write persists
+    // the row, so NO intro turn fires — the user speaks first (ScottFive).
+    expect(await createCanonicalChat('ops')).toBe('stored-1')
+    expect(events).toEqual(['session.list', 'session.create', 'session.title', 'open:stored-1'])
+  })
+
+  it('always creates hidden — Bot Mode sessions have no visibility pref', async () => {
+    // Canonical Bot Chats are plugin-owned forever-chats, never scratch
+    // conversations, so `hidden` is unconditional. The `$hideBotChats` user
+    // pref that used to gate it is gone.
+    let created: Record<string, unknown> | null = null
+
+    respondWith((method, params) => {
+      if (method === 'session.create') {
+        created = params
+
+        return { session_id: 'rt-1', stored_session_id: 'sid-1' }
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+    await createCanonicalChat('alpha')
+
+    expect(created).toMatchObject({
+      hidden: true,
+      title: 'Bot Chat',
+      // The PR #97008 contract: the canonical Bot Chat's runtime always
+      // follows the profile's CURRENT config on resume — never the stored
+      // model/provider pin. Dropping this param silently regresses bots to
+      // the server's exact-title legacy fallback.
+      follow_profile_config: true
+    })
+  })
+
+  it('sends the one intro turn on New Bot creation (kickoff: true)', async () => {
+    respondWith((method, params) => {
+      events.push(method)
+
+      if (method === 'session.create') {
+        return { session_id: 'runtime-1', stored_session_id: 'stored-1' }
+      }
+
+      if (method === 'prompt.submit') {
+        expect(params.session_id).toBe('runtime-1')
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+
+    expect(await createCanonicalChat('ops', { kickoff: true })).toBe('stored-1')
+    expect(events).toEqual(['session.list', 'session.create', 'session.title', 'open:stored-1', 'prompt.submit'])
+  })
+
+  it('scopes the open to the bots workspace even with no staleness probe', async () => {
+    // The create path is the one caller that passes no probe. Gating the
+    // workspace fields on the probe left ITS chat unscoped, so the composer
+    // could not tell a bot chat from a working session and kept the branch
+    // rail up until the next (probed) click reopened the same row.
+    respondWith(method =>
+      method === 'session.create' ? { session_id: 'runtime-1', stored_session_id: 'stored-1' } : {}
+    )
+
+    const { createCanonicalChat } = await loadModule()
+
+    await createCanonicalChat('ops', { kickoff: true })
+
+    expect(hostMock.openSession).toHaveBeenCalledWith(
+      'stored-1',
+      expect.objectContaining({ tabTitle: 'Bot Chat', workspaceMode: 'bots', workspaceOwnerKey: 'bot:ops' })
+    )
+  })
+
+  it('speaks the intro in the active locale (#91827)', async () => {
+    // The first line of the forever-chat, and the bot's reply follows its
+    // language — so a hardcoded English intro biased the whole conversation.
+    pluginCtx.current = { i18n: { t: key => (key === 'bot.kickoff' ? 'こんにちは、自己紹介をしてください！' : key) } }
+
+    expect(await kickoffTextSent()).toBe('こんにちは、自己紹介をしてください！')
+  })
+
+  it('falls back to English when the bundle has not registered yet', async () => {
+    // Creation can race plugin registration; an unresolved key must never
+    // reach the model as the literal `bot.kickoff`.
+    expect(await kickoffTextSent()).toBe('Hey, tell me about yourself!')
+  })
+
+  it('retries navigation after the compat kickoff when the eager title is unsupported', async () => {
+    let attempts = 0
+
+    hostMock.openSession.mockImplementation(async (id: string) => {
+      events.push(`open:${id}`)
+      attempts += 1
+
+      if (attempts === 1) {
+        throw new Error('stored row not persisted yet')
+      }
+    })
+    respondWith(method => {
+      if (method === 'session.create') {
+        return { session_id: 'runtime-1', stored_session_id: 'stored-1' }
+      }
+
+      if (method === 'session.title') {
+        throw new Error('unknown method')
+      }
+
+      if (method === 'prompt.submit') {
+        events.push('kickoff:persisted')
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+
+    expect(await createCanonicalChat('ops')).toBe('stored-1')
+    expect(events).toEqual(['open:stored-1', 'kickoff:persisted', 'open:stored-1'])
+  })
+
+  it('still returns the created registry row when the intro fails', async () => {
+    respondWith(method => {
+      if (method === 'session.create') {
+        return { session_id: 'rt-1', stored_session_id: 'new-bot-chat' }
+      }
+
+      if (method === 'prompt.submit') {
+        throw new Error('gateway timeout')
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+
+    // The chat exists under the canonical title — the next click finds it by
+    // NAME (the registry), so a failed kickoff can never orphan or fork it.
+    expect(await createCanonicalChat('newbie', { kickoff: true })).toBe('new-bot-chat')
+  })
+})
+
+describe('a superseded click completes registry-side but never navigates', () => {
+  it('creates the canonical row without stealing the workspace', async () => {
+    let current = true
+
+    respondWith(method => {
+      if (method === 'session.create') {
+        current = false
+
+        return { session_id: 'new-runtime', stored_session_id: 'new-stored' }
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+
+    expect(await createCanonicalChat('ops', { openingStillCurrent: () => current })).toBe('new-stored')
+    expect(hostMock.openSession).not.toHaveBeenCalled()
+  })
+
+  it('lets a newer same-bot open take over the in-flight creation navigation', async () => {
+    let firstCurrent = true
+    let releaseCreate = () => undefined as void
+    let markCreateStarted = () => undefined as void
+
+    const createStarted = new Promise<void>(resolve => {
+      markCreateStarted = resolve
+    })
+
+    respondWith(method => {
+      if (method === 'session.create') {
+        markCreateStarted()
+
+        return new Promise(resolve => {
+          releaseCreate = () => resolve({ session_id: 'shared-runtime', stored_session_id: 'shared-stored' })
+        })
+      }
+
+      return {}
+    })
+
+    const { createCanonicalChat } = await loadModule()
+    const first = createCanonicalChat('ops', { openingStillCurrent: () => firstCurrent })
+
+    await createStarted
+    firstCurrent = false
+
+    const second = createCanonicalChat('ops', { openingStillCurrent: () => true })
+
+    releaseCreate()
+
+    expect(await first).toBe('shared-stored')
+    expect(await second).toBe('shared-stored')
+    // The newer current click owns the shared creation's one navigation.
+    expect(hostMock.openSession).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/canonical-chat-registry.test.ts b/apps/desktop/src/plugins/hermes-bots/canonical-chat-registry.test.ts
new file mode 100644
index 000000000000..03e34f8e6cde
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/canonical-chat-registry.test.ts
@@ -0,0 +1,283 @@
+/**
+ * The canonical-chat REGISTRY contract.
+ *
+ * A bot's forever-chat has exactly ONE identity: the session titled "Bot Chat"
+ * on that bot's profile. The core UNIQUE(title) index makes (profile, "Bot
+ * Chat") an exact registry — at most one row, resolved fresh on every open via
+ * `session.list { title: 'Bot Chat', include_hidden: true }`.
+ *
+ * There is NO session-id pin. The previous design stored a pointer in
+ * ui_meta['hermes-bots'].chat and spent five hardening waves (#88690, #90732,
+ * #90751, the #91791 revert, #92042) guarding its failure modes: rows[0]
+ * steals, last_session adoptions, transient clears, drifted-title welds. Every
+ * "lost canonical chat" incident traced to that pointer dangling and a later
+ * guard welding the wrong session in. Name-as-identity removes the failure
+ * class instead of guarding it: a name cannot dangle.
+ *
+ * This suite pins the whole contract:
+ *   1. open = registry lookup → open the row (lineage tip)
+ *   2. no row → create (adopt-before-mint lives inside creation)
+ *   3. no pointer is ever read or written on the open path
+ *
+ * It drives the real module. Its predecessor sliced `plugin.js` out of the
+ * bundle with string offsets and ran it under `vm`, which meant the tripwire
+ * below could only be a regex over source text; here it is an assertion about
+ * what the code DOES — no write reaches the metadata store, and no RPC carries
+ * an id to verify.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+const { hostMock, persistMock, requestForBotMock, saveBotMetaMock } = vi.hoisted(() => ({
+  hostMock: { openSession: vi.fn(), request: vi.fn() },
+  persistMock: vi.fn(),
+  requestForBotMock: vi.fn(),
+  saveBotMetaMock: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', () => ({
+  BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS: 15_000,
+  host: hostMock
+}))
+
+vi.mock('./routing', () => ({
+  backendTargetProfile: (route: { targetProfile?: string } | null, name: string) => route?.targetProfile ?? name,
+  botConnectionRoute: () => null,
+  botRosterMeta: () => ({}),
+  botWorkspaceOwnerKey: (bot: { connectionId?: string; name?: string } | null) =>
+    `bot:${bot?.connectionId ? `${bot.connectionId}::` : ''}${bot?.name || 'default'}`,
+  requestForBot: requestForBotMock
+}))
+
+vi.mock('./data', () => ({
+  $botMeta: { get: () => ({}), set: vi.fn() },
+  botMetaKey: (bot: { name?: string }) => bot?.name ?? '',
+  // Local bots carry no route, so everything resolves onto the ambient
+  // request — the single-connection shape these tests pin.
+  botOwner: (owner: RosterRow | string) =>
+    typeof owner === 'string'
+      ? { bot: { name: owner }, key: owner, name: owner, route: null }
+      : { bot: owner, key: owner?.name, name: owner?.name, route: null },
+  persistBotMetaSnapshot: persistMock,
+  saveBotMeta: saveBotMetaMock
+}))
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null }))
+
+/** Route every RPC through one table, recording what was asked. */
+function respondWith(handler: (method: string, params: Record<string, unknown>) => unknown) {
+  const calls: Array<{ method: string; params: Record<string, unknown> }> = []
+
+  requestForBotMock.mockImplementation(async (_bot: unknown, method: string, params: Record<string, unknown>) => {
+    calls.push({ method, params: structuredClone(params ?? {}) })
+
+    return handler(method, params)
+  })
+
+  return calls
+}
+
+async function loadModule() {
+  vi.resetModules()
+
+  return import('./canonical-chat')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  hostMock.openSession.mockResolvedValue(undefined)
+})
+
+describe('the registry row wins, always', () => {
+  it('resolves the profile\u2019s "Bot Chat" row by exact title and opens it', async () => {
+    const calls = respondWith(method => {
+      if (method === 'session.list') {
+        return { sessions: [{ id: 'forever-chat', message_count: 930, title: 'Bot Chat' }] }
+      }
+
+      if (method === 'session.create') {
+        throw new Error('must not create: the registry row exists')
+      }
+
+      return {}
+    })
+
+    const { openBotCanonicalChat } = await loadModule()
+    const opened = await openBotCanonicalChat('ops')
+
+    expect(opened).toEqual({ openedId: 'forever-chat', registryId: 'forever-chat' })
+    expect(hostMock.openSession).toHaveBeenCalledTimes(1)
+
+    const [id, options] = hostMock.openSession.mock.calls[0]
+
+    expect(id).toBe('forever-chat')
+    expect(options).toMatchObject({
+      profile: 'ops',
+      // Opening a bot leaves the Sessions workspace on its current gateway.
+      keepAllProfilesScope: true,
+      tabTitle: 'Bot Chat',
+      workspaceMode: 'bots',
+      workspaceOwnerKey: 'bot:ops'
+    })
+    // Same intent a session row click uses. `tab` stacked a fresh tile on every
+    // miss, so bot chats piled up beside each other and beside the untouched
+    // "New session" draft.
+    expect(options.intent).toBe('in-place')
+
+    const list = calls.find(call => call.method === 'session.list')
+
+    expect(list?.params).toMatchObject({
+      profile: 'ops',
+      // Canonical chats are always hidden — the lookup must see hidden rows.
+      include_hidden: true,
+      title: 'Bot Chat'
+    })
+  })
+
+  it('opens the lineage tip of a compression-rotated registry row', async () => {
+    respondWith(method =>
+      method === 'session.list'
+        ? {
+            sessions: [
+              { id: 'root-1', message_count: 400, resolved_id: 'tip-9', root_title: 'Bot Chat', title: 'Bot Chat' }
+            ]
+          }
+        : {}
+    )
+
+    const { openBotCanonicalChat } = await loadModule()
+    const opened = await openBotCanonicalChat('ops')
+
+    // The durable registry id names the chat; the tip is what takes focus.
+    expect(opened).toEqual({ openedId: 'tip-9', registryId: 'root-1' })
+    expect(hostMock.openSession.mock.calls[0][0]).toBe('tip-9')
+  })
+
+  it('never reads or writes a stored pointer while opening', async () => {
+    const calls = respondWith(method =>
+      method === 'session.list' ? { sessions: [{ id: 'forever-chat', title: 'Bot Chat' }] } : {}
+    )
+
+    const { openBotCanonicalChat } = await loadModule()
+    await openBotCanonicalChat('ops')
+
+    expect(saveBotMetaMock).not.toHaveBeenCalled()
+    expect(persistMock).not.toHaveBeenCalled()
+    // No id-verification RPC: the name IS the identity, so there is nothing to
+    // verify a stored id against.
+    expect(calls.every(call => !('preferred_session_ids' in call.params))).toBe(true)
+    expect(calls.map(call => call.method)).toEqual(['session.list'])
+  })
+})
+
+describe('no registry row → create', () => {
+  it('mints a hidden "Bot Chat" WITHOUT an intro kickoff', async () => {
+    // Click-path resolution mints silently. The intro turn fires only from New
+    // Bot creation (kickoff: true) — re-firing it on a resolution miss burned a
+    // model turn and stamped a user-attributed prompt into the chat.
+    const calls = respondWith(method => {
+      if (method === 'session.list') {
+        return { sessions: [] }
+      }
+
+      if (method === 'session.create') {
+        return { session_id: 'rt-1', stored_session_id: 'fresh-1' }
+      }
+
+      return {}
+    })
+
+    const { openBotCanonicalChat } = await loadModule()
+    const opened = await openBotCanonicalChat('newbie')
+
+    expect(opened).toEqual({ openedId: 'fresh-1', registryId: 'fresh-1' })
+    expect(calls.find(call => call.method === 'session.create')?.params).toMatchObject({
+      hidden: true,
+      title: 'Bot Chat'
+    })
+    // The eager title write persists the row; no user-attributed intro.
+    expect(calls.find(call => call.method === 'session.title')?.params).toMatchObject({ session_id: 'rt-1' })
+    expect(calls.find(call => call.method === 'prompt.submit')).toBeUndefined()
+  })
+
+  it('never claims an ordinary titled session', async () => {
+    respondWith(method => {
+      if (method === 'session.list') {
+        // An older gateway ignores the title param and returns a windowed
+        // listing — the local exact-title scan still applies.
+        return {
+          sessions: [
+            { id: 'scratch', message_count: 40, title: 'help me with x' },
+            { id: 'draft', message_count: 0, title: '' }
+          ]
+        }
+      }
+
+      return method === 'session.create' ? { session_id: 'rt-2', stored_session_id: 'fresh-2' } : {}
+    })
+
+    const { openBotCanonicalChat } = await loadModule()
+    const opened = await openBotCanonicalChat('ops')
+
+    expect(opened).toEqual({ openedId: 'fresh-2', registryId: 'fresh-2' })
+    expect(hostMock.openSession.mock.calls.every(([id]) => id !== 'scratch')).toBe(true)
+  })
+
+  it('surfaces a failed open of the registry row instead of forking a replacement', async () => {
+    respondWith(method => {
+      if (method === 'session.list') {
+        return { sessions: [{ id: 'forever-chat', message_count: 12, title: 'Bot Chat' }] }
+      }
+
+      if (method === 'session.create') {
+        throw new Error('must not create: a transient open failure is not ownership loss')
+      }
+
+      return {}
+    })
+    hostMock.openSession.mockRejectedValue(new Error('backend restarting'))
+
+    const { openBotCanonicalChat } = await loadModule()
+
+    await expect(openBotCanonicalChat('ops')).rejects.toThrow('backend restarting')
+  })
+})
+
+describe('a failed lookup fails CLOSED — never "no chat exists"', () => {
+  // The post-update window: the desktop restarts every profile backend, the
+  // first bot click races the warm-up, and the lookup RPC fails transiently.
+  // Swallowing that made the failure indistinguishable from "this bot has no
+  // Bot Chat yet", so create minted a fresh forever-chat while the real one
+  // (data intact, hidden) still held the canonical title — read by users as
+  // "my bot lost everything after the update".
+  const refuseToMint = (method: string) => {
+    if (method === 'session.list') {
+      throw new Error('gateway not ready')
+    }
+
+    if (method === 'session.create') {
+      throw new Error('must not create: a failed lookup is not "no chat exists"')
+    }
+
+    return {}
+  }
+
+  it('rejects instead of minting a replacement chat', async () => {
+    const calls = respondWith(refuseToMint)
+    const { openBotCanonicalChat } = await loadModule()
+
+    await expect(openBotCanonicalChat('ops')).rejects.toThrow(/Bot Chat registry/)
+    expect(calls.some(call => call.method === 'session.create')).toBe(false)
+    expect(hostMock.openSession).not.toHaveBeenCalled()
+  })
+
+  it('refuses to mint when the adoption lookup inside creation fails', async () => {
+    const calls = respondWith(refuseToMint)
+    const { createCanonicalChat } = await loadModule()
+
+    await expect(createCanonicalChat('ops')).rejects.toThrow(/Bot Chat registry/)
+    expect(calls.some(call => call.method === 'session.create')).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/canonical-chat.ts b/apps/desktop/src/plugins/hermes-bots/canonical-chat.ts
new file mode 100644
index 000000000000..265b1fa14d9e
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/canonical-chat.ts
@@ -0,0 +1,558 @@
+/**
+ * The canonical Bot Chat: one bot, one forever-chat, resolved by exact title.
+ *
+ * Read the Bot Mode section of the repo root AGENTS.md before touching any of
+ * this — the identity contract below is settled and has been regressed
+ * repeatedly. The click-path orchestration that drives these lives in
+ * plugin.tsx, which owns the workspace and group state a bot open competes
+ * with.
+ */
+
+import * as sdk from '@hermes/plugin-sdk'
+import { host } from '@hermes/plugin-sdk'
+
+import { $botMeta, botMetaKey, botOwner, persistBotMetaSnapshot } from './data'
+import { backendTargetProfile, botConnectionRoute, botRosterMeta, botWorkspaceOwnerKey, requestForBot } from './routing'
+import type { RpcErrorLike } from './routing'
+import { getPluginCtx } from './shared'
+import type { BotMeta, CanonicalSession, RosterRow } from './types'
+
+// ── canonical bot chat ───────────────────────────────────────────────────────
+// Each bot has ONE forever chat, identified by NAME, never by pointer: the
+// session titled exactly "Bot Chat" on that bot's profile. The core
+// UNIQUE(title) index makes (profile, "Bot Chat") an exact registry, so every
+// open consults that registry directly — there is nothing to verify, re-pin,
+// grandfather, or recover. Stored-id pins (ui_meta['hermes-bots'].chat) were
+// the previous identity and are REMOVED: every lost-chat incident traced to a
+// dangled or stolen pointer that later guards then welded in. Legacy
+// ui_meta.chat keys are simply ignored.
+
+interface CanonicalCreation {
+  /** Null only between the holder literal and the assignment two statements
+   *  later; a flight is published to the map already carrying its promise. */
+  run: null | Promise<null | string>
+}
+
+// In-flight creations, keyed by bot name — double-clicking a row must not
+// mint two canonical chats.
+const canonicalCreations = new Map<string, CanonicalCreation>()
+
+/** Upper bound for per-profile session.list scans (hide sweep, canonical-chat
+ *  adoption, stored-session lookups). */
+export const PROFILE_SESSION_LIST_LIMIT = 200
+
+/** The one canonical title. (profile, CANONICAL_CHAT_TITLE) IS the bot's
+ *  forever-chat identity — see the header above. */
+const CANONICAL_CHAT_TITLE = 'Bot Chat'
+
+/** A `session.list` row as the registry lookup reads it. CanonicalSession
+ *  models the roster's `canonical_session` field, which carries no
+ *  `message_count` — the listing row does. `readonly` because the count is
+ *  read through an aliased guard, which TS only narrows for immutable
+ *  properties. */
+interface CanonicalChatRow extends CanonicalSession {
+  readonly message_count?: number
+}
+
+/** Is the chat on screen the given bot's forever-chat?
+ *
+ *  Identity comes off the roster's `canonical_session`, resolved server-side
+ *  by title, and matches EITHER the durable registry row or the
+ *  compression-lineage tip — a compacted Bot Chat is on screen under its tip
+ *  id while the registry still names it by the root.
+ *
+ *  Takes the STORED id. The runtime id belongs to a different id space and
+ *  matches neither, which is how the `/new` guard that calls this went dead. */
+export function isCanonicalChatOnScreen(
+  bot: null | RosterRow | undefined,
+  storedSessionId: null | string | undefined
+): boolean {
+  const canonical = bot?.canonical_session
+
+  if (!storedSessionId || !canonical) {
+    return false
+  }
+
+  return [canonical.id, canonical.resolved_id].filter(Boolean).map(String).includes(String(storedSessionId))
+}
+
+async function openStoredBotChat(
+  owner: RosterRow | string,
+  storedId: string,
+  summary: CanonicalChatRow
+): Promise<string> {
+  if (!storedId || typeof host.openSession !== 'function') {
+    throw new Error('This Hermes Desktop version cannot open stored sessions')
+  }
+
+  const { bot, name, route } = botOwner(owner)
+  const ownerKey = botWorkspaceOwnerKey(bot)
+  const hasAuthoritativeCount = typeof summary?.message_count === 'number' && Number.isFinite(summary.message_count)
+  const expectHistory = hasAuthoritativeCount ? summary.message_count > 0 : true
+
+  // Current SDKs export the Bot-specific budget. The fallback preserves
+  // compatibility with older hosts and isolated plugin test harnesses.
+  const hydrationTimeoutMs =
+    typeof sdk !== 'undefined' && Number.isFinite(sdk.BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS)
+      ? sdk.BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS
+      : 60_000
+
+  // A profile backend that just woke up can lose the hydration-timeout race
+  // even though the session is fine (hermes-agent#89617) — clicking Retry
+  // succeeds because the backend is warm by then. retryHydrationTimeoutOnce
+  // asks the SDK layer to retry that same wait internally, BEFORE it arms the
+  // core stranded-session overlay: a plugin-side retry can't do this because
+  // only host.openSession sees the resume-exhausted latch that overlay reads.
+  //
+  // forceResume: an explicit bot switch must never trust a cached transcript.
+  // The SDK's surface-health check passes whenever ANY non-empty transcript is
+  // painted, including a stale snapshot the session-states cache kept from the
+  // previous time this bot was open — which left the pane showing old messages
+  // until an app restart (hermes-agent#93604). A resume is cheap and
+  // idempotent, so on this explicit user navigation we always request one.
+  await host.openSession(storedId, {
+    ...(route
+      ? {
+          route
+        }
+      : {}),
+    profile: name,
+    // Same intent a session row click uses. `tab` stacked a fresh tile every
+    // time focusOpenSession missed, so bot chats piled up beside each other and
+    // beside the untouched "New session" draft, which then kept focus —
+    // clicking a bot appeared to do nothing. `in-place` still fronts an
+    // already-open tile first, so Bot tabs survive owner lifecycles (#a81854a2,
+    // the reason this stopped being `main`); it just loads into main instead of
+    // minting a second tab when there is nothing to front.
+    intent: 'in-place',
+    awaitHydration: true,
+    expectHistory,
+    forceResume: true,
+    hydrationTimeoutMs,
+    keepAllProfilesScope: true,
+    workspaceMode: 'bots',
+    workspaceOwnerKey: ownerKey,
+    retryHydrationTimeoutOnce: true,
+    tabTitle: CANONICAL_CHAT_TITLE
+  })
+
+  return storedId
+}
+
+/** True when a session summary IS the canonical registry row. root_title is
+ *  the durable lineage-root title reported by exact-lookup gateways; plain
+ *  title covers windowed listings. */
+function isCanonicalBotChatHistory(history: CanonicalChatRow) {
+  const rootTitle = String(history?.root_title || '').trim()
+  const title = String(history?.title || '').trim()
+
+  return rootTitle === CANONICAL_CHAT_TITLE || (!rootTitle && title === CANONICAL_CHAT_TITLE)
+}
+
+function botModeGatewayNeedsUpdate(error: unknown) {
+  const message = String((error as RpcErrorLike)?.message || error || '')
+
+  return /(?:method not found|no handler for|unknown method|unsupported rpc)/i.test(message)
+}
+
+export function notifyBotOpenFailure(error: unknown, bot: RosterRow, fallbackMessage: string) {
+  if (botModeGatewayNeedsUpdate(error)) {
+    const gateway = bot.connectionLabel || bot.connectionId || 'this gateway'
+    host.notify?.({
+      kind: 'error',
+      title: 'Update this gateway to use Bot Mode',
+      message: `Update ${gateway}, then try again.`
+    })
+
+    return
+  }
+
+  host.notifyError?.(error, fallbackMessage)
+}
+
+/** THE identity lookup: the profile's session titled exactly "Bot Chat",
+ *  consulted on the bot's OWN source. The core UNIQUE title index guarantees
+ *  at most ONE such row per profile db — Profile → Named Session is an exact
+ *  registry, so consult it exactly: `title` asks the gateway for an indexed
+ *  WHERE title = ? lookup (window-free; a busy profile can push the
+ *  forever-chat past any recency window). include_hidden is required
+ *  (canonical chats are always hidden). Remote bots route via requestForBot
+ *  on the immutable captured owner — activation is a UI concern and never
+ *  authorizes this RPC. */
+async function findExistingCanonicalChat(owner: RosterRow | string): Promise<CanonicalChatRow | null> {
+  const { bot, name, route } = botOwner(owner)
+  // FAIL CLOSED. A failed registry lookup MUST NOT read as "no Bot Chat
+  // exists" — that is the one remaining way to fork a bot's forever chat.
+  // The failure lives exactly in the post-update window: the desktop
+  // restarts every profile backend, the first bot click races the warm-up,
+  // the lookup RPC fails transiently, and a swallowed error here sent
+  // createCanonicalChat() straight to session.create — minting a fresh
+  // "Bot Chat" while the real one (data intact, hidden) still held the
+  // canonical title. Users read that as "my bot lost all context after the
+  // update". Cross-connection lookups fail MORE often (network), so this
+  // matters doubly for remote bots. Both open paths catch and toast "try
+  // again", which is the correct outcome: retry, never mint.
+  let res: { sessions?: CanonicalChatRow[] }
+
+  try {
+    res = await requestForBot<{ sessions?: CanonicalChatRow[] }>(bot, 'session.list', {
+      profile: backendTargetProfile(route, name),
+      title: CANONICAL_CHAT_TITLE,
+      limit: PROFILE_SESSION_LIST_LIMIT,
+      include_hidden: true
+    })
+  } catch (error) {
+    // Plugin tests and host bridges can return Error-like values from another
+    // JS realm, where `instanceof Error` is false. Preserve the provider/RPC
+    // message so update-required classification and diagnostics still work.
+    const message = typeof (error as RpcErrorLike)?.message === 'string' ? (error as { message: string }).message : ''
+    const detail = message ? ` (${message})` : ''
+    throw new Error(`Could not check ${name}'s Bot Chat registry${detail} — not starting a new chat`)
+  }
+
+  const rows = res?.sessions ?? []
+
+  return rows.find(row => isCanonicalBotChatHistory(row)) || null
+}
+
+interface CreateCanonicalChatOptions {
+  kickoff?: boolean
+  openingStillCurrent?: (() => boolean) | null
+}
+
+/** The self-introduction a brand-new bot is born with (#91827).
+ *
+ *  Localized because it is the FIRST line of the forever-chat: shipped in
+ *  English it opened every non-English user's relationship with their bot in a
+ *  foreign language, and the bot's reply followed the prompt's language, so one
+ *  hardcoded string biased the whole conversation.
+ *
+ *  It is still submitted on the user's side, which is the half of #91827 this
+ *  cannot close from here: `prompt.submit` IS the user-turn API, so an
+ *  unattributed birth needs the lazy/silent path that issue proposes — a
+ *  gateway contract change, not a rename. The intro itself is deliberate and
+ *  documented in AGENTS.md ("kicked off with the bot's intro"); what this
+ *  narrows is who has to read it in English. */
+function kickoffText(): string {
+  return getPluginCtx()?.i18n?.t('bot.kickoff') ?? 'Hey, tell me about yourself!'
+}
+
+/** Create the bot's ONE forever chat: a real session titled "Bot Chat".
+ *  Adopts the existing "Bot Chat" row instead of creating when the profile
+ *  already has one — minting while a "Bot Chat" row exists is always wrong
+ *  twice over: it forks the forever-chat AND the new row can never take the
+ *  (already held) canonical title. Creates on the bot's own source via
+ *  requestForBot.
+ *
+ *  `kickoff` (New Agent creation ONLY): submit the self-introduction prompt
+ *  so a brand-new bot greets its owner once. Every other caller — the bot
+ *  row's click-path canonical resolution above all — must NOT pass it: a
+ *  resolution miss (retitled row, hidden-listing gap, post-update skew)
+ *  re-mints the session, and re-firing the intro there burned a model turn
+ *  and stamped a user-attributed "Hey, tell me about yourself!" into the
+ *  chat on every click (ScottFive report). The kickoff's original session-
+ *  persistence job is done by the eager session.title write below on modern
+ *  gateways; older gateways that reject the eager write keep a narrow
+ *  compat kickoff, else the pruner reaps the empty lazy session and the
+ *  chat never survives its own creation.
+ *
+ *  `openingStillCurrent` (click-path opens): a staleness probe consulted
+ *  before every navigation — when the user has already moved on (opened a
+ *  group, clicked another bot), the create still completes registry-side
+ *  but never steals the workspace (#89834 family).
+ *
+ *  It gates WHETHER to navigate, never WHAT the session is. The bots
+ *  workspace fields below ride every open unconditionally: they say this row
+ *  is a bot's chat, which is true of a freshly minted one no matter who asked
+ *  for it. Spreading them only when a probe was passed is how the create path
+ *  — the one caller with no probe — opened its chat unscoped, and the
+ *  composer, reading that scope to stand the branch rail down, showed the
+ *  rail in a bot chat until the next click re-opened it scoped. */
+export function createCanonicalChat(
+  owner: RosterRow | string,
+  { kickoff = false, openingStillCurrent = null }: CreateCanonicalChatOptions = {}
+): Promise<null | string> {
+  const { bot, name, key, route } = botOwner(owner)
+  const inflight = canonicalCreations.get(key)
+
+  // Every open of a just-minted row is the same call — adopting a concurrent
+  // flight's result, the retry after a failed eager title, the retry after the
+  // compat kickoff. Only WHEN differs, so WHAT lives in one place.
+  const openFreshCanonical = (sid: string) =>
+    host.openSession!(sid, {
+      ...(route
+        ? {
+            route
+          }
+        : {}),
+      profile: name,
+      intent: 'main',
+      keepAllProfilesScope: route ? true : false,
+      workspaceMode: 'bots',
+      workspaceOwnerKey: botWorkspaceOwnerKey(bot),
+      tabTitle: CANONICAL_CHAT_TITLE
+    })
+
+  if (inflight) {
+    if (!openingStillCurrent) {
+      return inflight.run!
+    }
+
+    return inflight.run!.then(async sid => {
+      if (sid && openingStillCurrent() && typeof host.openSession === 'function') {
+        await openFreshCanonical(sid)
+      }
+
+      return sid
+    })
+  }
+
+  const flight: CanonicalCreation = {
+    run: null
+  }
+
+  const canNavigate = () => !openingStillCurrent || openingStillCurrent()
+
+  const run = (async () => {
+    const existing = await findExistingCanonicalChat(owner)
+
+    if (existing?.id) {
+      if (typeof host.openSession === 'function' && canNavigate()) {
+        // The exact-lookup gateway reports the compression-lineage tip as
+        // resolved_id; open the tip, the registry row stays the identity.
+        await openStoredBotChat(owner, existing.resolved_id || existing.id, existing)
+      }
+
+      return existing.id
+    }
+
+    const res = await requestForBot<{ session_id?: string; stored_session_id?: string }>(bot, 'session.create', {
+      profile: backendTargetProfile(route, name),
+      title: CANONICAL_CHAT_TITLE,
+      // Always born hidden from the global sidebar — Bot Mode sessions are
+      // plugin-owned. Core applies this via the generic `hidden` flag
+      // (deferred as pending_hidden until the row exists); older gateways
+      // ignore the unknown param and it stays visible.
+      hidden: true,
+      // Explicit contract (PR #97008): this session's runtime always follows
+      // the member profile's CURRENT config. Resume must NOT restore the
+      // stored model/provider pin from an old row — that left bot DMs stuck
+      // on a stale/dead provider after a profile switch. Older gateways
+      // ignore the unknown param; the server's exact-title backfill then
+      // covers the legacy path.
+      follow_profile_config: true
+    })
+
+    const sid = res?.stored_session_id
+    const runtime = res?.session_id
+
+    // session.create is intentionally lazy: its stored row does not exist until
+    // the first prompt. Mounting `sid` immediately therefore emits a noisy REST
+    // 404 ("Session not found"), and the turn-start auto-titler can win the race
+    // against the deferred `title: 'Bot Chat'` — under name-identity that is an
+    // identity outage: until the row is titled, the registry has no "Bot Chat"
+    // entry, so a second click during the intro turn mints a duplicate.
+    // session.title materializes the row now and records a user-authority title
+    // before either the open or kickoff, closing both the 404 race and the
+    // untitled window. Older gateways may not support the eager write; retain
+    // the kickoff-and-retry fallback below.
+    let titled = false
+
+    if (runtime) {
+      try {
+        await requestForBot(bot, 'session.title', {
+          session_id: runtime,
+          title: CANONICAL_CHAT_TITLE
+        })
+        titled = true
+      } catch (error) {
+        // ADOPT-BEFORE-MINT: a title-uniqueness rejection is not an old
+        // gateway — it means another writer took the canonical title between
+        // our registry miss and this write (peer dm minting server-side, a
+        // second machine, cross-connection sync). Falling through to the
+        // compat path would prompt into OUR stray session and fork the
+        // forever chat. Re-consult the registry and adopt the winner; the
+        // stray lazy session holds zero messages and is simply abandoned
+        // (the gateway prunes it).
+        if (/already in use/i.test(String((error as RpcErrorLike)?.message || ''))) {
+          const winner = await findExistingCanonicalChat(owner)
+
+          if (winner?.id) {
+            // Adopting the winner settles IDENTITY, which is always correct to
+            // return. Navigating to it is not: this path can land a full
+            // round-trip after the user clicked another bot, and every sibling
+            // open here is staleness-probed for exactly that reason.
+            if (typeof host.openSession === 'function' && canNavigate()) {
+              await openStoredBotChat(owner, winner.resolved_id || winner.id, winner)
+            }
+
+            return winner.id
+          }
+        }
+        /* compatibility fallback: prompt.submit will persist the lazy row */
+      }
+    }
+
+    // Mount the session view FIRST, then send the kickoff — submitting into
+    // an unmounted session left the intro reply invisible until reopen.
+    let opened = false
+
+    if (sid && typeof host.openSession === 'function' && canNavigate()) {
+      try {
+        await openFreshCanonical(sid)
+        opened = true
+      } catch {
+        // The stored row may not exist until the kickoff persists it. Retry
+        // after prompt.submit below instead of leaving the chat off-screen.
+      }
+    }
+
+    if (runtime) {
+      // Intro turn: only on genuine New Agent creation (`kickoff`), or as the
+      // COMPAT persistence write when the eager title failed — an old gateway
+      // prunes the zero-message lazy session, so without some first prompt
+      // the chat never survives its own creation. A titled row needs neither:
+      // the user speaks first.
+      const submitIntro = kickoff || !titled
+
+      if (submitIntro) {
+        await new Promise(resolve => window.setTimeout(resolve, 400))
+
+        try {
+          await requestForBot(bot, 'prompt.submit', {
+            session_id: runtime,
+            text: kickoffText()
+          })
+
+          if (!opened && sid && typeof host.openSession === 'function' && canNavigate()) {
+            await openFreshCanonical(sid)
+          }
+        } catch {
+          // The chat already exists under the canonical title — the next click
+          // finds it by name instead of making a second Bot Chat.
+        }
+      } else if (!opened && sid && typeof host.openSession === 'function' && canNavigate()) {
+        // No intro turn: still finish mounting the chat when the first open
+        // raced the (now titled) row.
+        try {
+          await openFreshCanonical(sid)
+        } catch {
+          /* row is titled and persistent — the next click opens it by name */
+        }
+      }
+    }
+
+    return sid || null
+  })().finally(() => {
+    if (canonicalCreations.get(key) === flight) {
+      canonicalCreations.delete(key)
+    }
+  })
+
+  flight.run = run
+  canonicalCreations.set(key, flight)
+
+  return run
+}
+
+/** Open the bot's ONE forever chat and return the opened registry id.
+ *
+ *  The whole resolution is one registry consultation ON THE BOT'S OWN
+ *  SOURCE: the profile's session titled "Bot Chat" exists → open it
+ *  (lineage tip); it doesn't → create it. No id pointer is read or written
+ *  anywhere in this path — remote bots included. The owner route rides
+ *  every RPC (requestForBot) and the open (openStoredBotChat), so a remote
+ *  bot's chat opens without re-homing Desktop's chrome. */
+export async function openBotCanonicalChat(
+  owner: RosterRow | string,
+  openingStillCurrent: (() => boolean) | null = null
+): Promise<{ openedId: string; registryId: string } | null> {
+  const existing = await findExistingCanonicalChat(owner)
+
+  if (existing?.id && typeof host.openSession === 'function') {
+    if (openingStillCurrent && !openingStillCurrent()) {
+      return null
+    }
+
+    const openedId = existing.resolved_id || existing.id
+    await openStoredBotChat(owner, openedId, existing)
+
+    // Both identities matter downstream: the durable registry row names the
+    // chat; the resolved lineage tip is what actually takes session focus.
+    // Callers matching focus against only the registry id mistook every
+    // compressed Bot Chat for a stale open (first click bounced to the home).
+    return {
+      registryId: String(existing.id),
+      openedId: String(openedId)
+    }
+  }
+
+  const created = await createCanonicalChat(owner, {
+    openingStillCurrent
+  })
+
+  return created
+    ? {
+        registryId: String(created),
+        openedId: String(created)
+      }
+    : null
+}
+
+export async function prepareBotSource(bot: RosterRow) {
+  if (!bot.sourceScoped) {
+    return
+  }
+
+  // Cross-connection RPCs ride the immutable captured route (requestForBot →
+  // host.requestProfile) — Desktop's active connection does not move, and
+  // activation is a UI concern that never authorizes the calls. All this
+  // gate does is refuse when the desktop predates routed profile requests.
+  const route = botConnectionRoute(bot)
+
+  if (route && typeof host.requestProfile !== 'function') {
+    throw new Error(
+      getPluginCtx()?.i18n?.t('bot.remoteConnectionsUnsupported') ??
+        'Update Hermes Desktop to chat with bots on other connections.'
+    )
+  }
+
+  if (!route && typeof host.ensureAgent === 'function') {
+    // Source-annotated row on the ACTIVE connection (no captured route):
+    // legacy activation path, unchanged. An absent connectionId is fine —
+    // ensureGatewayAgent normalizes it with `(connectionId ?? '').trim() || null`.
+    await host.ensureAgent(bot.connectionId, bot.name)
+  }
+}
+
+export async function ensureBotMetadata(bot: RosterRow): Promise<BotMeta> {
+  if (!bot?.sourceScoped) {
+    return botRosterMeta(bot, $botMeta.get()) || {}
+  }
+
+  const route = botConnectionRoute(bot)
+  const backendProfile = backendTargetProfile(route, bot.name)
+
+  const result = await requestForBot<{ profiles?: Array<Pick<RosterRow, 'name' | 'ui_meta'>> }>(
+    bot,
+    'profiles.list',
+    {}
+  )
+
+  const row = (result?.profiles || []).find(profile => profile?.name === backendProfile)
+  const server = row?.ui_meta?.['hermes-bots']
+
+  if (server && typeof server === 'object') {
+    const key = botMetaKey(bot)
+    $botMeta.set({
+      ...$botMeta.get(),
+      [key]: {
+        ...($botMeta.get()[key] || {}),
+        ...server
+      }
+    })
+    persistBotMetaSnapshot($botMeta.get(), true)
+  }
+
+  return botRosterMeta(bot, $botMeta.get()) || {}
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/chat-empty.tsx b/apps/desktop/src/plugins/hermes-bots/chat-empty.tsx
new file mode 100644
index 000000000000..5113eeb5a25d
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/chat-empty.tsx
@@ -0,0 +1,111 @@
+/**
+ * What a bot's chat shows before it has said anything.
+ *
+ * Core's splash is Hermes' own wordmark and belongs to a fresh draft; a bot
+ * chat is neither. It gets the same lettering with the bot's name in it, over
+ * the same face the roster row and tab carry, so an empty conversation still
+ * says whose it is.
+ */
+
+import { host, useValue, Wordmark } from '@hermes/plugin-sdk'
+
+import { avatarColor, botAppearance, BotFace } from './avatar'
+import { isBackfilledFacePng } from './avatar-image'
+import { $botMeta, $lastRoster } from './data'
+import { useBots } from './i18n'
+import { displayName } from './labels'
+import { botRosterMeta } from './routing'
+import type { RosterRow } from './types'
+
+const FACE_SIZE = 96
+const FACE_GAP = 16
+/** What the face costs the stack in height — the offset that puts the name on
+ *  the center line is derived from it, so the two can never drift apart. */
+const FACE_BLOCK = FACE_SIZE + FACE_GAP
+
+/** The bot whose canonical chat this session is, if it is one. Matches the
+ *  durable registry id or the compression-lineage tip, the same pair the
+ *  roster's click and preview identity resolve through. */
+function botForStoredId(roster: readonly RosterRow[], storedId: string): null | RosterRow {
+  if (!storedId || !Array.isArray(roster)) {
+    return null
+  }
+
+  return (
+    roster.find(bot => {
+      const canonical = bot?.canonical_session
+
+      return String(canonical?.id ?? '') === storedId || String(canonical?.resolved_id ?? '') === storedId
+    }) ?? null
+  )
+}
+
+/** The stored id of the chat on screen. The transcript hands its slot the
+ *  RUNTIME id, and a canonical Bot Chat is keyed by its stored one — the same
+ *  two id spaces that misrouted Bot Mode's RPCs in #93080. The focus store is
+ *  the translation the rest of the plugin already trusts. */
+function focusedStoredId(): string {
+  return String(host.state.focusedStoredSessionId?.get?.() ?? '')
+}
+
+function botForChat(roster: readonly RosterRow[], sessionId: string): null | RosterRow {
+  // Stored ids pass straight through, so a shell that hands us one still
+  // resolves; otherwise the focused chat is the empty one being looked at.
+  return botForStoredId(roster, sessionId) ?? botForStoredId(roster, focusedStoredId())
+}
+
+export function BotChatEmpty({ sessionId }: { sessionId: string }) {
+  const b = useBots()
+  // Subscribed, not read once: roster, metadata and focus all land after the
+  // transcript mounts. This is also how the state appears at all — the slot
+  // mounts for every empty session and only resolves to a bot once the roster
+  // is in hand.
+  const roster = useValue($lastRoster)
+  const allMeta = useValue($botMeta)
+  useValue(host.state.focusedStoredSessionId)
+  const bot = botForChat(roster, sessionId)
+
+  if (!bot) {
+    return null
+  }
+
+  // Route-keyed, exactly as the roster row resolves it: metadata is scoped to
+  // the gateway it came from, so a plain by-name read misses the entry a
+  // source-scoped bot's avatar actually lives under.
+  const meta = botRosterMeta(bot, allMeta)
+  const name = displayName(bot, meta)
+  const { color, image, shape } = botAppearance(bot.name, meta)
+  // Same rule the rows use: keep a real photo or pet, drop the SVG backfill so
+  // the math face can animate.
+  const photo = Boolean(image && !isBackfilledFacePng(image))
+
+  return (
+    <div
+      className="pointer-events-none flex w-full min-w-0 flex-col items-center justify-center px-0.5 py-6 text-center text-muted-foreground sm:px-6 lg:px-8"
+      data-slot="bot_chat_empty"
+      // The name reads as the title of the chat, so it — not the stack as a
+      // whole — is what should sit on the optical center line. Lifting the
+      // stack by half the face's block does exactly that: the face hangs above
+      // the line and the text lands on it, the same balance the splash strikes
+      // with nothing above its lettering.
+      style={{ transform: `translateY(-${FACE_BLOCK / 2}px)` }}
+    >
+      <div className="w-full min-w-0">
+        <div className="flex justify-center" style={{ marginBottom: FACE_GAP }}>
+          <BotFace
+            color={avatarColor(color, bot.name)}
+            image={photo ? image : null}
+            mood="idle"
+            name={bot.name}
+            shape={shape}
+            size={FACE_SIZE}
+          />
+        </div>
+
+        <Wordmark className="mb-1" text={name} width="calc(80% - 1rem)" />
+
+        <p className="m-0 text-center leading-normal tracking-tight">{b.bot.chatEmpty}</p>
+      </div>
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/create-agent-lazy-profile.test.tsx b/apps/desktop/src/plugins/hermes-bots/create-agent-lazy-profile.test.tsx
new file mode 100644
index 000000000000..ee1dbfe5412b
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/create-agent-lazy-profile.test.tsx
@@ -0,0 +1,255 @@
+/**
+ * New Bot creates its profile LAZILY. Two contracts hang off that:
+ *
+ *  - MCP OAuth / API-key credentials must be configurable DURING creation
+ *    rather than forcing create-then-edit, so the setup button materializes
+ *    the profile through `ensureAgentCreated()` on its first action. The
+ *    creation is single-flighted and idempotent: whichever door fires first
+ *    (a setup click, the Capabilities tab, or Create Bot itself) is the only
+ *    `profiles.create` the dialog ever sends.
+ *  - `reset()` has to restore the SAME clone source the dialog mounted with.
+ *    It restored '__none__' instead: the first open cloned the main profile,
+ *    every later open after a create or cancel silently started fresh.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import type { ReactNode } from 'react'
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as DataModule from './data'
+import { translateBots } from './i18n-test-helper'
+import type { RosterRow } from './types'
+
+interface SkillsViewProps {
+  fixedConnection?: string
+  fixedProfile?: string
+}
+
+const mocks = vi.hoisted(() => ({
+  connections: vi.fn(async () => [] as { id: string; label: string }[]),
+  createCanonicalChat: vi.fn(async () => 'session-1'),
+  deleteBot: vi.fn(async () => undefined),
+  /** Flipped off to model a desktop build that predates the live surface. */
+  hasSkillsView: { value: true },
+  notify: vi.fn(),
+  notifyError: vi.fn(),
+  request: vi.fn(),
+  requestProfile: vi.fn(async () => ({})),
+  saveBotMeta: vi.fn(),
+  skillsView: [] as SkillsViewProps[]
+}))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const original = await importOriginal<typeof HermesSdk>()
+
+  const SkillsViewStub = (props: SkillsViewProps) => {
+    mocks.skillsView.push(props)
+
+    return null
+  }
+
+  // Builds that route `fixedConnection` get the live Capabilities tab for
+  // remote targets too, pinned to the target machine's backend.
+  SkillsViewStub.supportsFixedConnection = true
+
+  const mocked: Record<string, unknown> = {
+    ...original,
+    host: {
+      ...original.host,
+      connections: mocks.connections,
+      notify: mocks.notify,
+      notifyError: mocks.notifyError,
+      request: mocks.request,
+      requestProfile: mocks.requestProfile
+    },
+    // The plugin bundle normally lands via `ctx.i18n.register` at load.
+    usePluginI18n: () => translateBots
+  }
+
+  Object.defineProperty(mocked, 'SkillsView', {
+    configurable: true,
+    enumerable: true,
+    get: () => (mocks.hasSkillsView.value ? SkillsViewStub : undefined)
+  })
+
+  return mocked
+})
+
+vi.mock('./canonical-chat', () => ({ createCanonicalChat: mocks.createCanonicalChat }))
+vi.mock('./profile-ops', () => ({ deleteBot: mocks.deleteBot }))
+vi.mock('./data', async importOriginal => {
+  const original = await importOriginal<typeof DataModule>()
+
+  return { ...original, saveBotMeta: mocks.saveBotMeta }
+})
+
+// Each build re-imports the dialog's whole module graph.
+vi.setConfig({ testTimeout: 30_000 })
+
+const roster: RosterRow[] = [{ connectionId: 'local', name: 'default' }]
+
+/** A catalog entry that needs an API key — the only row that renders setup. */
+const catalog = { auth: null, installed: false, name: 'linear', requires: ['LINEAR_API_KEY'] }
+
+function withQueryClient(children: ReactNode) {
+  return (
+    <QueryClientProvider client={new QueryClient({ defaultOptions: { queries: { retry: false } } })}>
+      {children}
+    </QueryClientProvider>
+  )
+}
+
+async function renderDialog(hasSkillsView: boolean) {
+  mocks.hasSkillsView.value = hasSkillsView
+  vi.resetModules()
+
+  const { CreateAgentDialog } = await import('./create-dialog')
+
+  const view = render(withQueryClient(<CreateAgentDialog onClose={() => undefined} open roster={roster} />))
+
+  fireEvent.change(screen.getByPlaceholderText('inbox-triage'), { target: { value: 'inbox-triage' } })
+  fireEvent.click(screen.getByRole('button', { name: /Advanced/ }))
+
+  return view
+}
+
+function createCalls() {
+  return mocks.request.mock.calls.filter(([method]) => method === 'profiles.create')
+}
+
+/** The control under a `labeled(...)` caption — the label is presentational,
+ *  so it carries no `for`/`id` pair to query by. */
+function controlUnder(caption: string) {
+  return screen.getByText(caption).parentElement!.querySelector('[role="combobox"]') as HTMLElement
+}
+
+beforeAll(async () => {
+  // Radix Select/Dialog reach for APIs jsdom does not implement.
+  Element.prototype.scrollIntoView = () => undefined
+  Element.prototype.hasPointerCapture = () => false
+  Element.prototype.releasePointerCapture = () => undefined
+  Element.prototype.setPointerCapture = () => undefined
+  // Warm the transform cache so the first test isn't charged for it.
+  await import('./create-dialog')
+}, 120_000)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mocks.skillsView.length = 0
+  mocks.connections.mockResolvedValue([])
+  mocks.requestProfile.mockResolvedValue({})
+  mocks.request.mockImplementation(async (method: string) => {
+    switch (method) {
+      case 'mcp.catalog':
+        return { servers: [catalog] }
+
+      case 'mcp.servers.test':
+        return { ok: true }
+
+      case 'profiles.describe':
+        return { mcp_servers: [], skills: [], toolsets: [] }
+
+      default:
+        return {}
+    }
+  })
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('materializing the draft profile', () => {
+  it('creates it once when the Capabilities tab opens, pinned to the new slug', async () => {
+    await renderDialog(true)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Capabilities' }))
+
+    await waitFor(() => expect(createCalls()).toHaveLength(1))
+    expect(createCalls()[0][1]).toMatchObject({ clone_from: 'default', name: 'inbox-triage' })
+    // The live surface needs a REAL backend row to write to.
+    await waitFor(() => expect(mocks.skillsView.at(-1)).toMatchObject({ fixedProfile: 'inbox-triage' }))
+
+    // Create Bot goes through the same helper — no duplicate profiles.create.
+    fireEvent.click(screen.getByRole('button', { name: 'Create Bot' }))
+
+    await waitFor(() => expect(mocks.createCanonicalChat).toHaveBeenCalledWith('inbox-triage', { kickoff: true }))
+    expect(createCalls()).toHaveLength(1)
+  })
+
+  it('pins a remote-target draft to the TARGET machine, not the active gateway', async () => {
+    mocks.connections.mockResolvedValue([
+      { id: 'local', label: 'This Mac' },
+      { id: 'studio', label: 'Studio' }
+    ])
+
+    await renderDialog(true)
+
+    // "Create on" only exists on a multi-connection desktop.
+    await screen.findByText('Create on')
+    fireEvent.click(controlUnder('Create on'))
+    fireEvent.click(await screen.findByRole('option', { name: 'Studio' }))
+    fireEvent.click(screen.getByRole('button', { name: 'Capabilities' }))
+
+    // The create lands on THAT machine's backend — no gateway switch, and the
+    // clone source is the remote's own default (a local profile name the
+    // remote box does not have would fail there).
+    await waitFor(() =>
+      expect(mocks.requestProfile).toHaveBeenCalledWith(
+        expect.objectContaining({ connectionId: 'studio' }),
+        'profiles.create',
+        expect.objectContaining({ clone_from: 'default', name: 'inbox-triage' })
+      )
+    )
+    expect(createCalls()).toHaveLength(0)
+    await waitFor(() =>
+      expect(mocks.skillsView.at(-1)).toMatchObject({ fixedConnection: 'studio', fixedProfile: 'inbox-triage' })
+    )
+  })
+
+  it('creates it on the first MCP setup click, then adds the server to it', async () => {
+    // Older builds keep the staged MCP tab, which is where the setup button
+    // lives. There is no "save the agent first" gate: the button is live.
+    await renderDialog(false)
+
+    fireEvent.click(screen.getByRole('button', { name: 'MCP' }))
+    fireEvent.click(await screen.findByRole('button', { name: /Set up/ }))
+
+    await waitFor(() => expect(createCalls()).toHaveLength(1))
+    expect(createCalls()[0][1]).toMatchObject({ name: 'inbox-triage' })
+    // The add lands on the profile the click just minted, not on `null`.
+    await waitFor(() =>
+      expect(mocks.request).toHaveBeenCalledWith('mcp.servers.add', {
+        name: 'linear',
+        preset: 'linear',
+        profile: 'inbox-triage'
+      })
+    )
+  })
+})
+
+describe('the clone-from default', () => {
+  it('regression: reset restores the mounted default, not "fresh profile"', async () => {
+    await renderDialog(true)
+
+    // `labeled()` renders a bare <label>, so the trigger is found by position.
+    const cloneFrom = () =>
+      screen.getByText('Clone from profile').parentElement!.querySelector('[role="combobox"]') as HTMLElement
+
+    expect(cloneFrom().textContent).toBe('default')
+
+    fireEvent.click(cloneFrom())
+    fireEvent.click(await screen.findByRole('option', { name: /Fresh profile/ }))
+    expect(cloneFrom().textContent).toMatch(/Fresh profile/)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Create Bot' }))
+    await waitFor(() => expect(mocks.createCanonicalChat).toHaveBeenCalled())
+
+    // Second open: the picker must read `default` again, or every agent after
+    // the first silently starts from a bare profile.
+    fireEvent.click(screen.getByRole('button', { name: /Advanced/ }))
+    expect(cloneFrom().textContent).toBe('default')
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/create-dialog.single-flight.test.ts b/apps/desktop/src/plugins/hermes-bots/create-dialog.single-flight.test.ts
new file mode 100644
index 000000000000..0be79fa6bd6a
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/create-dialog.single-flight.test.ts
@@ -0,0 +1,97 @@
+/**
+ * The create dialog pre-creates the draft profile so the Capabilities tab has
+ * a real backend to point at. Every tab that needs one races for it, so the
+ * creation is shared through one in-flight slot — otherwise a user tabbing
+ * quickly mints two profiles and the second one leaks.
+ *
+ * The other half is failure: a rejected creation must CLEAR the slot, or one
+ * gateway blip permanently wedges the dialog on a promise that will never
+ * resolve and the user can never finish creating the bot.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import { singleFlight } from './create-dialog'
+
+// The dialog is a 1200-line surface pulling in most of the SDK; the helper
+// under test touches none of it, so a self-returning stub keeps the module
+// graph linkable without pinning any of that surface.
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  const stub: unknown = new Proxy(function stubbed() {}, {
+    apply: () => stub,
+    get: (_target, key) => (key === 'then' ? undefined : stub)
+  })
+
+  return new Proxy({ atom } as Record<string, unknown>, {
+    // A callable `then` would make the namespace look thenable and hang the
+    // module loader.
+    get: (target, key) =>
+      typeof key === 'symbol' || key in target ? target[key as string] : key === 'then' ? undefined : stub,
+    has: () => true
+  })
+})
+
+describe('singleFlight', () => {
+  it('shares one in-flight creation across concurrent callers', async () => {
+    const ref: { current: null | Promise<string> } = { current: null }
+    let calls = 0
+    let release!: () => void
+
+    const pending = new Promise<void>(resolve => {
+      release = resolve
+    })
+
+    const create = async () => {
+      calls += 1
+      await pending
+
+      return 'researcher'
+    }
+
+    const first = singleFlight(ref, create)
+    const second = singleFlight(ref, create)
+
+    expect(calls).toBe(1)
+    expect(first).toBe(second)
+
+    release()
+    await expect(first).resolves.toBe('researcher')
+    expect(ref.current).toBe(first)
+  })
+
+  it('clears the slot on failure so a retry can succeed', async () => {
+    const ref: { current: null | Promise<string> } = { current: null }
+    let calls = 0
+
+    await expect(
+      singleFlight(ref, async () => {
+        calls += 1
+        throw new Error('gateway unavailable')
+      })
+    ).rejects.toThrow(/gateway unavailable/)
+
+    expect(ref.current).toBeNull()
+
+    await expect(
+      singleFlight(ref, async () => {
+        calls += 1
+
+        return 'researcher'
+      })
+    ).resolves.toBe('researcher')
+    expect(calls).toBe(2)
+  })
+
+  it('treats a synchronous throw as a rejected flight, not a crash', async () => {
+    const ref: { current: null | Promise<string> } = { current: null }
+
+    await expect(
+      singleFlight<string>(ref, () => {
+        throw new Error('bad args')
+      })
+    ).rejects.toThrow(/bad args/)
+    expect(ref.current).toBeNull()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/create-dialog.tsx b/apps/desktop/src/plugins/hermes-bots/create-dialog.tsx
new file mode 100644
index 000000000000..79c339d749be
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/create-dialog.tsx
@@ -0,0 +1,1352 @@
+/**
+ * The two creation dialogs: New Bot, and the group-chat creation flow the
+ * roster's group button opens (plus the per-bot group membership dialog it
+ * sits beside).
+ *
+ * New Bot creates its profile LAZILY, so it owns the single-flight guard and
+ * the name pattern that gates the draft.
+ */
+
+import {
+  Badge,
+  Button,
+  Checkbox,
+  cn,
+  Codicon,
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DisclosureCaret,
+  GlyphSpinner,
+  host,
+  Input,
+  queryClient,
+  RowButton,
+  SearchField,
+  SegmentedControl,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Textarea,
+  useI18n,
+  useValue
+} from '@hermes/plugin-sdk'
+import { useEffect, useRef, useState } from 'react'
+
+import { avatarColor, blobatarSvg, botAppearance, BotFace } from './avatar'
+import { isBackfilledFacePng } from './avatar-image'
+import { AvatarPicker } from './avatar-picker'
+import { $selectedBot } from './bot-state'
+import { createCanonicalChat } from './canonical-chat'
+import { $botMeta, botHandle, botRosterKey, filterBots, ROSTER_KEY, saveBotMeta } from './data'
+import { labeled, ResizableFrame } from './dialog-parts'
+import { GROUP_CHAT_MAX_MEMBERS, mintGroupRoomId, uniqueGroupChatName, updateGroupChat } from './group-chat'
+import type { GroupChatRoom } from './group-chat'
+import { GroupImageControls } from './group-chat-parts'
+import {
+  botGroups,
+  durableGroupChatMembers,
+  groupMembershipPatch,
+  knownGroups,
+  liveGroupChatNames
+} from './group-membership'
+import { useBots } from './i18n'
+import { displayName, slugify } from './labels'
+import { McpSetupButton } from './mcp-setup'
+import { ModelPicker } from './model-picker'
+import type {
+  CapabilityEntry,
+  McpCatalogResponse,
+  ProfileConfigurePayload,
+  ProfileDescribeResponse
+} from './profile-config'
+import { CheckList, SkillsView, skillsViewRoutesConnections } from './profile-config'
+import { deleteBot } from './profile-ops'
+import { botRosterMeta } from './routing'
+import { HubSkillsSection } from './skills-hub'
+import { composeSoul } from './soul'
+import type { BotMeta, ConnectionRow, RosterRow } from './types'
+
+const NAME_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/
+
+/** Share one in-flight async operation across concurrent callers. Failures
+ * clear the slot so a later attempt can retry. */
+export function singleFlight<T>(ref: { current: null | Promise<T> }, start: () => Promise<T> | T): Promise<T> {
+  if (ref.current) {
+    return ref.current
+  }
+
+  let flight: Promise<T>
+
+  try {
+    flight = Promise.resolve(start())
+  } catch (err) {
+    flight = Promise.reject(err)
+  }
+
+  ref.current = flight
+  flight.catch(() => {
+    if (ref.current === flight) {
+      ref.current = null
+    }
+  })
+
+  return flight
+}
+
+// ── create dialog ────────────────────────────────────────────────────────────
+
+/** The clone source's capability catalog, staged before the profile exists. */
+interface CapabilityCatalog {
+  mcp: CapabilityEntry[]
+  skills: CapabilityEntry[]
+  source: string
+  toolsets: CapabilityEntry[]
+}
+interface CreateAgentDialogProps {
+  onClose: () => void
+  open: boolean
+  roster: RosterRow[]
+}
+
+export function CreateAgentDialog({ open, onClose, roster }: CreateAgentDialogProps) {
+  const { t } = useI18n()
+  const b = useBots()
+  const [name, setName] = useState('')
+  // Create mode: the profile is created LAZILY. Capability toggles are staged in
+  // component state; the profile is materialized either on Create (submit) or on
+  // the first MCP credential setup (ensureAgentCreated), whichever comes first —
+  // so OAuth / API-key setup works DURING creation, not only after in Edit.
+  const createdRef = useRef<null | string>(null)
+  // In-flight profiles.create shared across concurrent triggers (Create
+  // button + MCP setup buttons). Distinct from createdRef on purpose:
+  // createdRef must stay a slug string for its sibling consumers.
+  const flightRef = useRef<Promise<null | string> | null>(null)
+  const [title, setTitle] = useState('')
+  const [description, setDescription] = useState('')
+  // Default shapes mode: deterministic blob face drawn from the agent's name
+  // (falls back to the legacy shape vocabulary on older SDKs).
+  const [shape, setShape] = useState(blobatarSvg ? 'blobatar' : 'circle')
+  const [color, setColor] = useState<null | string>(null)
+  const [image, setImage] = useState<null | string>(null)
+  const [advanced, setAdvanced] = useState(false)
+  const [cloneFrom, setCloneFrom] = useState('default')
+  const [model, setModel] = useState('')
+  const [provider, setProvider] = useState('')
+  const [soul, setSoul] = useState('')
+  const [noSkills, setNoSkills] = useState(false)
+  const [shareAuth, setShareAuth] = useState(true)
+  const [advTab, setAdvTab] = useState('general')
+  // Where the profile is created: '' = the active gateway (unchanged default),
+  // else a registry connection id — the profiles.create lands on THAT
+  // machine's backend via host.requestProfile, no gateway switch. Only
+  // rendered when the desktop has a multi-connection registry.
+  const [targetConnection, setTargetConnection] = useState('')
+  const [connections, setConnections] = useState<ConnectionRow[] | null>(null)
+  useEffect(() => {
+    if (
+      !open ||
+      connections !== null ||
+      typeof host.connections !== 'function' ||
+      typeof host.requestProfile !== 'function'
+    ) {
+      return
+    }
+
+    host
+      .connections()
+      // host.connections() returns the registry ROWS on current SDKs, but the
+      // envelope object ({version, primary, connections: [...]}) on desktops
+      // that predate the SDK-side unwrap — accept both shapes.
+      .then((value: ConnectionRow[] | { connections?: ConnectionRow[] }) =>
+        setConnections(Array.isArray(value) ? value : Array.isArray(value?.connections) ? value.connections : [])
+      )
+      .catch(() => setConnections([]))
+  }, [open, connections])
+  const activeConnectionId = String(host.state?.connectionId?.get?.() || '').trim()
+  // Remote target = an explicitly picked registry connection that is not the
+  // one this window is already on.
+  const remoteTarget = Boolean(targetConnection) && targetConnection !== (activeConnectionId || 'local')
+
+  const targetLabel = remoteTarget
+    ? (connections || []).find(c => c.id === targetConnection)?.label || targetConnection
+    : ''
+
+  /** Gateway RPC on the create target: the picked connection's default
+   *  backend for remote targets, the active gateway otherwise. */
+  const requestForTarget = <T,>(method: string, params: Record<string, unknown> = {}): Promise<T> =>
+    remoteTarget
+      ? host.requestProfile(
+          {
+            connectionId: targetConnection,
+            mode: 'remote',
+            profile: 'default',
+            targetProfile: 'default'
+          },
+          method,
+          params
+        )
+      : host.request(method, params)
+
+  // Set once ensureAgentCreated() materializes the profile for the live
+  // Capabilities tab (SkillsView needs a real backend to point at). State —
+  // not just createdRef — because the render must flip when it lands.
+  const [createdForCaps, setCreatedForCaps] = useState<null | string>(null)
+  const [caps, setCaps] = useState<CapabilityCatalog | null>(null)
+  const [capsFailed, setCapsFailed] = useState(false)
+
+  const [dirtyCaps, setDirtyCaps] = useState({
+    skills: false,
+    toolsets: false,
+    mcp: false
+  })
+
+  const [capFilter, setCapFilter] = useState('')
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState<null | string>(null)
+  const slug = slugify(name)
+  const valid = slug.length > 0 && NAME_RE.test(slug)
+
+  // Once the draft profile is materialized (Capabilities tab / MCP setup) it
+  // shows up in the roster — its OWN slug must not read as "taken".
+  // A remote-target create is gated by the TARGET machine's roster: a local
+  // name clash is fine there, and the remote's own duplicate check rejects
+  // real collisions at profiles.create time.
+  const taken = remoteTarget
+    ? roster.some(
+        b => b.remoteSource && b.connectionId === targetConnection && b.name === slug && b.name !== createdRef.current
+      )
+    : roster.some(b => !b.remoteSource && b.name === slug && b.name !== createdRef.current)
+
+  // Draft semantics for the lazily-created profile: opening the Capabilities
+  // tab (or running MCP setup) materializes the profile so the LIVE config
+  // surfaces have a real backend to write to — but until the user hits
+  // Create Agent it is a DRAFT. Cancelling the dialog deletes it, so
+  // preconfigure-then-back-out leaves zero residue. Best-effort and
+  // fire-and-forget: a failed cleanup surfaces a toast, never blocks close.
+  const discardDraft = () => {
+    const draft = createdRef.current
+
+    if (!draft) {
+      return
+    }
+
+    createdRef.current = null
+    flightRef.current = null
+
+    const discard = remoteTarget
+      ? requestForTarget('cli.exec', {
+          argv: ['profile', 'delete', draft, '--yes']
+        })
+      : deleteBot({
+          name: draft
+        })
+
+    void Promise.resolve(discard)
+      .then(() =>
+        host.notify({
+          kind: 'success',
+          message: `Draft agent "${draft}" discarded`
+        })
+      )
+      .catch(err => host.notifyError(err, `Could not clean up draft profile "${draft}"`))
+  }
+
+  const reset = () => {
+    setName('')
+    setTitle('')
+    setDescription('')
+    setShape(blobatarSvg ? 'blobatar' : 'circle')
+    setColor(null)
+    setImage(null)
+    setAdvanced(false)
+    // Same default as the initial useState — resetting to '__none__' made
+    // the second agent you create silently start from a fresh profile
+    // instead of cloning the main one like the first dialog open did.
+    setCloneFrom('default')
+    setModel('')
+    setProvider('')
+    setSoul('')
+    setNoSkills(false)
+    setShareAuth(true)
+    setAdvTab('general')
+    setCreatedForCaps(null)
+    setCaps(null)
+    setCapsFailed(false)
+    setDirtyCaps({
+      skills: false,
+      toolsets: false,
+      mcp: false
+    })
+    setCapFilter('')
+    setTargetConnection('')
+    setBusy(false)
+    setError(null)
+    createdRef.current = null
+    flightRef.current = null
+  }
+
+  // Capability catalog for the tabs: the profile doesn't exist yet, so show
+  // what it WILL have — the clone source's catalog, else the main profile's.
+  const capSource = cloneFrom === '__none__' ? 'default' : cloneFrom
+
+  const ensureCaps = () => {
+    if ((caps && caps.source === capSource) || capsFailed) {
+      return
+    }
+
+    Promise.all([
+      requestForTarget<ProfileDescribeResponse>('profiles.describe', {
+        name: remoteTarget ? 'default' : capSource
+      }),
+      requestForTarget<McpCatalogResponse>('mcp.catalog', {}).catch(() => null)
+    ])
+      .then(([res, cat]) => {
+        // Full MCP menu = the profile's configured servers + the bundled
+        // catalog (installable). Configured entries win on name clash.
+        const configured = res.mcp_servers || []
+        const have = new Set(configured.map(m => m.name))
+        const catalog = ((cat && cat.servers) || []).filter(s => !have.has(s.name))
+        setCaps({
+          source: capSource,
+          skills: res.skills || [],
+          toolsets: res.toolsets || [],
+          mcp: [
+            ...configured,
+            ...catalog.map(s => ({
+              name: s.name,
+              enabled: false,
+              fromCatalog: true,
+              installed: s.installed,
+              auth: s.auth,
+              requires: s.requires || [],
+              description: s.description || ''
+            }))
+          ]
+        })
+      })
+      .catch(() => setCapsFailed(true))
+  }
+
+  const toggleCap = (kind: 'mcp' | 'skills' | 'toolsets', name: string, enabled: boolean) => {
+    setDirtyCaps(prev => ({
+      ...prev,
+      [kind === 'mcp' ? 'mcp' : kind]: true
+    }))
+    setCaps(prev =>
+      prev
+        ? {
+            ...prev,
+            [kind]: prev[kind].map(x =>
+              x.name === name
+                ? {
+                    ...x,
+                    enabled
+                  }
+                : x
+            )
+          }
+        : prev
+    )
+  }
+
+  // Materialize the profile exactly once. createdRef stores the finished slug
+  // (its consumers — the taken check, draft discard on cancel, the MCP setup
+  // button's profile param — all read a string); flightRef shares the
+  // in-flight creation promise so simultaneous MCP setup / Create clicks fire
+  // ONE profiles.create. A settled flight clears its slot: failures retry,
+  // and a null result (form invalid at flight time) isn't sticky.
+  const ensureAgentCreated = (): Promise<null | string> => {
+    // Renamed since the draft materialized? The old draft is orphaned —
+    // discard it and create fresh under the new slug.
+    if (createdRef.current && createdRef.current !== slug) {
+      discardDraft()
+      setCreatedForCaps(null)
+    }
+
+    if (createdRef.current) {
+      return Promise.resolve(createdRef.current)
+    }
+
+    const flight = singleFlight(flightRef, async () => {
+      if (!valid || taken) {
+        return null
+      }
+
+      const descriptionText = [title, description].filter(Boolean).join(' — ')
+      await requestForTarget('profiles.create', {
+        name: slug,
+        description: descriptionText,
+        // Clone sources are profiles of the TARGET backend. The picker's
+        // roster is the local one, so a remote create always starts from the
+        // remote machine's default (or fresh) — never a local profile name
+        // the remote box doesn't have.
+        clone_from: cloneFrom === '__none__' ? null : remoteTarget ? 'default' : cloneFrom,
+        no_skills: noSkills,
+        // Shared (not copied) auth keeps ONE OAuth/token pool with the main
+        // profile, so refreshes can't invalidate each other. Older gateways
+        // ignore the param and copy — still functional, just forked.
+        share_auth: shareAuth,
+        soul: composeSoul({
+          name: slug,
+          title,
+          description,
+          roster,
+          customSoul: soul
+        }),
+        ...(model.trim() && provider.trim()
+          ? {
+              model: model.trim(),
+              provider: provider.trim()
+            }
+          : {})
+      })
+      createdRef.current = slug
+
+      // Apply capability picks from the Advanced tabs (best-effort; the
+      // profile exists either way and Edit Profile can finish the job).
+      try {
+        const capPayload: Pick<
+          ProfileConfigurePayload,
+          'disabled_skills' | 'enabled_mcp_servers' | 'enabled_toolsets'
+        > = {}
+
+        if (dirtyCaps.skills && caps) {
+          capPayload.disabled_skills = caps.skills.filter(s => !s.enabled).map(s => s.name)
+        }
+
+        if (dirtyCaps.toolsets && caps) {
+          const en = caps.toolsets.filter(t => t.enabled)
+          capPayload.enabled_toolsets = en.length === caps.toolsets.length || en.length === 0 ? [] : en.map(t => t.name)
+        }
+
+        if (dirtyCaps.mcp && caps) {
+          capPayload.enabled_mcp_servers = caps.mcp.filter(m => m.enabled).map(m => m.name)
+        }
+
+        if (Object.keys(capPayload).length) {
+          await requestForTarget('profiles.configure', {
+            name: slug,
+            ...capPayload
+          })
+        }
+      } catch {
+        /* capability application is best-effort */
+      }
+
+      if (remoteTarget) {
+        // The bot lives on ANOTHER machine — local bot-meta is scoped to the
+        // active gateway, so write appearance/title into the remote
+        // profile's ui_meta (and asset store) directly. Best-effort: the
+        // profile exists either way.
+        const { image: avatarImage, ...look } = {
+          shape,
+          color,
+          image,
+          imageKind: image ? 'photo' : 'shape',
+          title: title.trim(),
+          created: Date.now()
+        }
+
+        try {
+          void requestForTarget('profiles.configure', {
+            name: slug,
+            ui_meta: {
+              'hermes-bots': look
+            }
+          }).catch(() => undefined)
+
+          if (avatarImage) {
+            void requestForTarget('profiles.set_asset', {
+              name: slug,
+              asset: 'avatar',
+              data: avatarImage
+            }).catch(() => undefined)
+          }
+        } catch {
+          /* older remote gateway */
+        }
+      } else {
+        saveBotMeta(slug, {
+          shape,
+          color: color ?? undefined,
+          image,
+          imageKind: image ? 'photo' : 'shape',
+          title: title.trim(),
+          created: Date.now()
+        })
+      }
+
+      queryClient.invalidateQueries({
+        queryKey: ROSTER_KEY
+      })
+
+      return slug
+    })
+
+    return flight
+  }
+
+  const submit = async () => {
+    if (!valid || taken || busy) {
+      return
+    }
+
+    setBusy(true)
+    setError(null)
+
+    try {
+      const slugCreated = await ensureAgentCreated()
+
+      if (!slugCreated) {
+        setBusy(false)
+        setError('Could not create the bot.')
+
+        return
+      }
+
+      host.notify({
+        kind: 'success',
+        message: remoteTarget
+          ? `Bot "${displayName({
+              name: slug,
+              title
+            })}" created on ${targetLabel}`
+          : `Bot "${displayName({
+              name: slug,
+              title
+            })}" created`
+      })
+      const wasRemote = remoteTarget
+      reset()
+      onClose()
+
+      if (wasRemote) {
+        // The bot lives on another machine: it appears in the roster via the
+        // union enumeration; chat routes through its own source. No local
+        // canonical chat to birth here.
+        queryClient.invalidateQueries({
+          queryKey: ROSTER_KEY
+        })
+
+        return
+      }
+
+      $selectedBot.set(slug)
+
+      // Birth the bot's forever chat right away: it introduces itself as
+      // the first thing the user sees, and the pin exists from minute one.
+      try {
+        // Creates, pins, opens, and kicks off the intro in one flow. This is
+        // the ONE caller allowed to request the intro turn — genuine New
+        // Agent creation. Click-path resolution (openBotCanonicalChat) mints
+        // silently so a resolution miss never burns a turn (ScottFive).
+        const sid = await createCanonicalChat(slug, {
+          kickoff: true
+        })
+
+        if (!sid && typeof host.newChat === 'function') {
+          host.newChat(slug)
+        }
+      } catch {
+        if (typeof host.newChat === 'function') {
+          host.newChat(slug)
+        }
+      }
+    } catch (err) {
+      setBusy(false)
+      setError(err instanceof Error ? err.message : String(err))
+    }
+  }
+
+  return (
+    <Dialog
+      onOpenChange={value => {
+        if (!value && !busy) {
+          // Cancel path (esc / overlay click): a materialized draft profile is
+          // discarded — preconfigure-then-back-out leaves nothing behind.
+          discardDraft()
+          reset()
+          onClose()
+        }
+      }}
+      open={open}
+    >
+      <DialogContent
+        className={advanced ? 'max-w-3xl' : 'max-w-md'} // Native resize handle (bottom-right corner): the dialog becomes a
+        // window the user can grow/shrink. overflow:auto is required for CSS
+        // resize to engage; caps keep it on screen.
+        style={
+          advanced
+            ? {
+                resize: 'both',
+                overflow: 'auto',
+                minWidth: 420,
+                minHeight: 360,
+                maxWidth: '95vw',
+                maxHeight: '90vh'
+              }
+            : undefined
+        }
+      >
+        <DialogHeader>
+          <DialogTitle>{b.bot.newTitle}</DialogTitle>
+          <DialogDescription>
+            A named teammate with its own memory, skills, and chat. It can message your other agents.
+          </DialogDescription>
+        </DialogHeader>
+        <div className="grid gap-3.5">
+          <div className="flex justify-center py-1">
+            <BotFace
+              color={avatarColor(color, slug || 'agent')}
+              image={image}
+              name={slug || 'agent'}
+              shape={shape}
+              size={56}
+            />
+          </div>
+          <AvatarPicker
+            color={color}
+            generateSeed={{
+              name: slug || 'agent',
+              title,
+              description
+            }}
+            image={image}
+            onColor={setColor}
+            onImage={setImage}
+            onShape={setShape}
+            shape={shape}
+          />
+          {labeled(
+            'Name',
+            <Input autoFocus onChange={event => setName(event.target.value)} placeholder="inbox-triage" value={name} />
+          )}
+          {taken ? (
+            <div className="text-xs text-(--ui-accent)">
+              {remoteTarget
+                ? `An agent named "${slug}" already exists on ${targetLabel}.`
+                : `An agent named "${slug}" already exists.`}
+            </div>
+          ) : null}
+          {/* Multi-connection desktops choose WHERE the agent lives. Hidden */
+          /* on single-connection setups — the active gateway is the only */
+          /* possible home, exactly the old behavior. */}
+          {Array.isArray(connections) && connections.length > 1
+            ? labeled(
+                'Create on',
+                <Select
+                  onValueChange={value => {
+                    setTargetConnection(value === (activeConnectionId || 'local') ? '' : value)
+                    // The capability catalog and clone list belong to the
+                    // target backend — refetch for the new home. The live
+                    // Capabilities tab re-pins to it via fixedConnection on
+                    // builds that route it (staged checklists otherwise).
+                    setCaps(null)
+                    setCapsFailed(false)
+                    setAdvTab('general')
+                  }}
+                  value={targetConnection || activeConnectionId || 'local'}
+                >
+                  <SelectTrigger className="h-8 rounded-md">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {connections.map(connection => (
+                      <SelectItem key={connection.id} value={connection.id}>
+                        {connection.id === (activeConnectionId || 'local')
+                          ? `${connection.label || connection.id} (current)`
+                          : connection.label || connection.id}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              )
+            : null}
+          {remoteTarget ? (
+            <div className="text-[0.7rem] leading-5 text-(--ui-text-tertiary)">{`The agent is created on ${targetLabel} and appears in the roster as a Connections bot. Chat routes to that machine.`}</div>
+          ) : null}
+          {labeled(
+            'Title',
+            <Input onChange={event => setTitle(event.target.value)} placeholder="Inbox Triage" value={title} />
+          )}
+          {labeled(
+            'Description',
+            <Textarea
+              className="min-h-16"
+              onChange={event => setDescription(event.target.value)}
+              placeholder={b.bot.helpPromptPlaceholder}
+              value={description}
+            />
+          )}
+          <Button
+            className="flex items-center gap-1 text-xs font-medium text-(--ui-text-tertiary) hover:text-(--ui-text-secondary)"
+            onClick={() => {
+              setAdvanced(v => {
+                if (!v) {
+                  ensureCaps()
+                }
+
+                return !v
+              })
+            }}
+            size="inline"
+            variant="text"
+          >
+            <DisclosureCaret open={advanced} />
+            {b.bot.advanced}
+          </Button>
+          {advanced ? (
+            <div className="grid gap-3 rounded-md border border-(--ui-stroke-secondary) p-3">
+              <SegmentedControl
+                onChange={id => {
+                  setAdvTab(id)
+                  setCapFilter('')
+
+                  if (id === 'capabilities') {
+                    // The live surface needs a real profile —
+                    // materialize it now (same lazy-create door
+                    // the MCP setup buttons use).
+                    void ensureAgentCreated()
+                      .then(created => created && setCreatedForCaps(created))
+                      .catch(err => host.notifyError(err, b.bot.createFailed))
+                  } else if (id !== 'general') {
+                    ensureCaps()
+                  }
+                }}
+                options={
+                  SkillsView && (!remoteTarget || skillsViewRoutesConnections)
+                    ? [
+                        { id: 'general', label: 'General' },
+                        { id: 'capabilities', label: 'Capabilities' }
+                      ]
+                    : [
+                        { id: 'general', label: 'General' },
+                        { id: 'skills', label: 'Skills' },
+                        { id: 'toolsets', label: 'Tools' },
+                        { id: 'mcp', label: 'MCP' }
+                      ]
+                }
+                value={advTab}
+              />
+              {advTab === 'general' ? (
+                <div className="grid gap-3.5">
+                  {labeled(
+                    remoteTarget ? `Clone from profile (on ${targetLabel})` : 'Clone from profile',
+                    <Select
+                      disabled={remoteTarget}
+                      onValueChange={value => {
+                        setCloneFrom(value)
+                        setCaps(null)
+                        setCapsFailed(false)
+                      }}
+                      value={remoteTarget ? 'default' : cloneFrom}
+                    >
+                      <SelectTrigger className="h-8 rounded-md">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="__none__">Fresh profile (bundled skills)</SelectItem>
+                        {roster.map(b => (
+                          <SelectItem key={b.name} value={b.name}>
+                            {b.name}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                  )}
+                  <ModelPicker
+                    onChange={patch => {
+                      if ('provider' in patch) {
+                        setProvider(patch.provider)
+                      }
+
+                      if ('model' in patch) {
+                        setModel(patch.model)
+                      }
+                    }}
+                    placeholderModel="inherited from launch profile"
+                    value={{
+                      provider,
+                      model
+                    }}
+                  />
+                  {labeled(
+                    'SOUL.md (optional — replaces the generated persona)',
+                    <Textarea
+                      className="min-h-24 font-mono text-xs leading-5"
+                      onChange={event => setSoul(event.target.value)}
+                      placeholder={b.avatar.describeHint}
+                      value={soul}
+                    />
+                  )}
+                  <label className="flex items-center gap-2 text-xs text-(--ui-text-secondary)">
+                    <Checkbox checked={shareAuth} onCheckedChange={value => setShareAuth(Boolean(value))} />
+                    Share keys & accounts with the main profile
+                  </label>
+                  <div className="pl-6 pt-0.5 text-[0.7rem] leading-5 text-(--ui-text-tertiary)">
+                    Subscriptions, OAuth logins, and API keys stay shared (not copied), so token refreshes never
+                    invalidate each other. Uncheck for an isolated snapshot copy.
+                  </div>
+                  <label className="flex items-center gap-2 text-xs text-(--ui-text-secondary)">
+                    <Checkbox checked={noSkills} onCheckedChange={value => setNoSkills(Boolean(value))} />
+                    Create empty (skip bundled skills)
+                  </label>
+                </div>
+              ) : advTab === 'capabilities' ? (
+                !valid || taken ? (
+                  <div className="px-2 py-3 text-center text-xs text-(--ui-text-tertiary)">
+                    {taken
+                      ? 'That name is taken — pick another before configuring capabilities.'
+                      : 'Name the bot first — a draft profile is created when you open this tab (discarded if you cancel).'}
+                  </div>
+                ) : !createdForCaps ? (
+                  <div className="flex justify-center py-4">
+                    <GlyphSpinner className="text-(--ui-text-tertiary)" spinner="breathe" />
+                  </div>
+                ) : SkillsView ? (
+                  <ResizableFrame height={440} minHeight={280}>
+                    <SkillsView
+                      embedded
+                      fixedProfile={createdForCaps}
+                      {...(remoteTarget
+                        ? {
+                            fixedConnection: targetConnection
+                          }
+                        : {})}
+                    />
+                  </ResizableFrame>
+                ) : (
+                  // The tab list is gated on the same export, so this is only
+                  // reachable via persisted tab state on a build that lacks it
+                  // — a message rather than rendering `undefined` as a
+                  // component, which throws.
+                  <div className="px-2 py-3 text-center text-xs text-(--ui-text-tertiary)">
+                    Skills need a newer Hermes Desktop.
+                  </div>
+                )
+              ) : capsFailed ? (
+                <div className="px-2 py-3 text-center text-xs text-(--ui-text-tertiary)">
+                  Capability catalog needs a newer gateway (restart it after updating Hermes).
+                </div>
+              ) : !caps ? (
+                <div className="flex justify-center py-4">
+                  <GlyphSpinner className="text-(--ui-text-tertiary)" spinner="breathe" />
+                </div>
+              ) : advTab === 'skills' ? (
+                noSkills ? (
+                  <div className="px-2 py-3 text-center text-xs text-(--ui-text-tertiary)">
+                    “Create empty” is checked — no bundled skills will be installed.
+                  </div>
+                ) : (
+                  <div className="grid gap-1.5">
+                    <Input
+                      className="h-7 text-xs"
+                      onChange={event => setCapFilter(event.target.value)}
+                      placeholder={b.tools.filterSkills}
+                      value={capFilter}
+                    />
+                    <div
+                      className="overflow-y-auto overscroll-contain"
+                      style={{
+                        maxHeight: 200
+                      }}
+                    >
+                      <CheckList
+                        columns={2}
+                        items={
+                          capFilter.trim()
+                            ? caps.skills.filter(s => s.name.toLowerCase().includes(capFilter.trim().toLowerCase()))
+                            : caps.skills
+                        }
+                        onToggle={(name, enabled) => toggleCap('skills', name, enabled)}
+                      />
+                    </div>
+                    <div className="text-[0.65rem] leading-4 text-(--ui-text-quaternary)">{`Catalog from ${caps.source} — unchecked skills are disabled after creation.`}</div>
+                    <HubSkillsSection
+                      forProfile={null}
+                      onInstalled={name =>
+                        setCaps(prev =>
+                          !prev || prev.skills.some(s => s.name === name)
+                            ? prev
+                            : {
+                                ...prev,
+                                skills: [
+                                  ...prev.skills,
+                                  {
+                                    name,
+                                    enabled: true
+                                  }
+                                ]
+                              }
+                        )
+                      }
+                    />
+                  </div>
+                )
+              ) : advTab === 'toolsets' ? (
+                <div className="grid gap-1.5">
+                  <div
+                    className="overflow-y-auto overscroll-contain"
+                    style={{
+                      maxHeight: 200
+                    }}
+                  >
+                    <CheckList
+                      columns={2}
+                      items={caps.toolsets}
+                      onToggle={(name, enabled) => toggleCap('toolsets', name, enabled)}
+                    />
+                  </div>
+                  <div className="text-[0.65rem] leading-4 text-(--ui-text-quaternary)">
+                    Leaving all (or none) checked keeps the default toolset behavior.
+                  </div>
+                </div>
+              ) : caps.mcp.length === 0 ? (
+                <div className="px-2 py-3 text-center text-xs text-(--ui-text-tertiary)">{b.tools.noMcpServers}</div>
+              ) : (
+                <div className="grid gap-1.5">
+                  <div
+                    className="overflow-y-auto overscroll-contain"
+                    style={{
+                      maxHeight: 200
+                    }}
+                  >
+                    <div className="grid gap-1">
+                      {caps.mcp.map(m => {
+                        const needsSetup =
+                          m.fromCatalog &&
+                          !m.installed &&
+                          ((m.requires || []).length > 0 || (m.auth || '').toLowerCase() === 'oauth')
+
+                        return (
+                          <label className="flex items-start gap-2 text-xs text-(--ui-text-secondary)" key={m.name}>
+                            <Checkbox
+                              checked={!!m.enabled}
+                              disabled={needsSetup}
+                              onCheckedChange={value => toggleCap('mcp', m.name, Boolean(value))}
+                            />
+                            <span className="min-w-0">
+                              <span>{m.name}</span>
+                              {m.fromCatalog && !needsSetup ? (
+                                <span className="ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)">
+                                  {m.installed ? 'catalog · installed' : 'catalog'}
+                                </span>
+                              ) : null}
+                              {needsSetup ? (
+                                <McpSetupButton
+                                  ensureProfile={ensureAgentCreated}
+                                  entry={m}
+                                  onDone={() => {
+                                    // Setup done: mark installed so the row's
+                                    // checkbox un-disables, and enable it.
+                                    setCaps(prev =>
+                                      prev
+                                        ? {
+                                            ...prev,
+                                            mcp: prev.mcp.map(x =>
+                                              x.name === m.name
+                                                ? {
+                                                    ...x,
+                                                    installed: true,
+                                                    enabled: true
+                                                  }
+                                                : x
+                                            )
+                                          }
+                                        : prev
+                                    )
+                                    setDirtyCaps(prev => ({
+                                      ...prev,
+                                      mcp: true
+                                    }))
+                                  }}
+                                  profile={createdRef.current}
+                                />
+                              ) : null}
+                              {m.description ? (
+                                <div className="truncate text-[0.65rem] leading-4 text-(--ui-text-quaternary)">
+                                  {m.description}
+                                </div>
+                              ) : null}
+                            </span>
+                          </label>
+                        )
+                      })}
+                    </div>
+                  </div>
+                  <div className="text-[0.65rem] leading-4 text-(--ui-text-quaternary)">
+                    Configured servers copy from the main profile; catalog entries are the bundled MCP menu. Entries
+                    needing API keys route through setup first (credentials follow the shared keys setting).
+                  </div>
+                </div>
+              )}
+            </div>
+          ) : null}
+          {error ? (
+            <div className="rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs text-(--ui-accent)">
+              {error}
+            </div>
+          ) : null}
+        </div>
+        <DialogFooter>
+          <Button
+            disabled={busy}
+            onClick={() => {
+              discardDraft()
+              reset()
+              onClose()
+            }}
+            variant="ghost"
+          >
+            {t.common.cancel}
+          </Button>
+          <Button disabled={busy || !valid || taken} onClick={submit}>
+            {busy ? 'Creating…' : 'Create Bot'}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+interface GroupDialogProps {
+  bot: RosterRow
+  onClose: () => void
+}
+
+/** Assign a bot to a group-chat membership without replacing its others.
+ *  Existing groups are independent toggles; the input creates and joins a new
+ *  one. Canonical groups + the legacy scalar projection ride ui_meta. */
+export function GroupDialog({ bot, onClose }: GroupDialogProps) {
+  const b = useBots()
+  const meta = useValue($botMeta)
+  const [name, setName] = useState('')
+  const current = botGroups(botRosterMeta(bot, meta))
+  const groups = knownGroups(meta)
+
+  const setMembership = (group: string, enabled: boolean) => {
+    void saveBotMeta(bot, groupMembershipPatch(botRosterMeta(bot, meta), group, enabled))
+    host.notify({
+      kind: 'info',
+      message: enabled
+        ? `${displayName(bot, botRosterMeta(bot, meta))} added to “${group}”`
+        : `${displayName(bot, botRosterMeta(bot, meta))} removed from “${group}”`
+    })
+  }
+
+  return (
+    <Dialog
+      onOpenChange={value => {
+        if (!value) {
+          onClose()
+        }
+      }}
+      open={Boolean(bot)}
+    >
+      <DialogContent className="max-w-sm">
+        <DialogHeader>
+          <DialogTitle>{b.group.manageTitle}</DialogTitle>
+          <DialogDescription>{b.group.manageDesc}</DialogDescription>
+        </DialogHeader>
+        {groups.length ? (
+          <div className="grid gap-1.5">
+            {groups.map(group => {
+              const enabled = current.includes(group)
+
+              return (
+                <label
+                  className="flex cursor-pointer items-center gap-2 rounded-md px-2 py-1.5 text-sm hover:bg-(--chrome-action-hover)"
+                  key={group}
+                >
+                  <Checkbox checked={enabled} onCheckedChange={checked => setMembership(group, checked === true)} />
+                  <span>{group}</span>
+                </label>
+              )
+            })}
+          </div>
+        ) : null}
+        <form
+          className="flex items-center gap-1.5"
+          onSubmit={event => {
+            event.preventDefault()
+            const trimmed = name.trim()
+
+            if (trimmed) {
+              setMembership(trimmed, true)
+              setName('')
+            }
+          }}
+        >
+          <Input
+            autoFocus
+            onChange={event => setName(event.target.value)}
+            placeholder={groups.length ? 'New group…' : 'Group name (e.g. Research)'}
+            value={name}
+          />
+          <Button disabled={!name.trim()} size="sm" type="submit">
+            Create & join
+          </Button>
+        </form>
+        {current.length ? (
+          <Button
+            className="justify-self-start"
+            onClick={() =>
+              void saveBotMeta(bot, {
+                groups: [],
+                group: null
+              })
+            }
+            size="sm"
+            variant="ghost"
+          >
+            {b.bot.removeFromAllGroups}
+          </Button>
+        ) : null}
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+interface CreateGroupChatDialogProps {
+  onClose: () => void
+  onCreated?: (group: string) => void
+  open: boolean
+  roster: RosterRow[]
+}
+
+/** Discord-style group chat creation: pick 2+ bots via checkboxes (with
+ *  search), name the group, create. Assignment appends to each local bot's
+ *  group membership list, so the room appears in the roster and syncs
+ *  cross-machine via ui_meta without replacing its other groups. */
+export function CreateGroupChatDialog({ open, roster, onClose, onCreated }: CreateGroupChatDialogProps) {
+  const { t } = useI18n()
+  const b = useBots()
+  const allMeta: Record<string, BotMeta> = useValue($botMeta)
+  const [query, setQuery] = useState('')
+  const [checked, setChecked] = useState<Record<string, boolean>>({})
+  const [name, setName] = useState('')
+  const [image, setImage] = useState<null | string>(null)
+
+  // Reset per open so a cancelled draft doesn't leak into the next one.
+  useEffect(() => {
+    if (open) {
+      setQuery('')
+      setChecked({})
+      setName('')
+      setImage(null)
+    }
+  }, [open])
+
+  // An outage placeholder preserves one selected owner's identity in the
+  // sidebar, but it is not a routable room member. Never offer it here.
+  const selectableRoster = roster.filter(bot => !bot?.ghost)
+  const selected = selectableRoster.filter(bot => checked[botRosterKey(bot)])
+  const visible: RosterRow[] = filterBots(selectableRoster, allMeta, query)
+  const atCap = selected.length >= GROUP_CHAT_MAX_MEMBERS
+
+  const placeholder = selected.length
+    ? selected.map(bot => displayName(bot, botRosterMeta(bot, allMeta))).join(', ')
+    : b.group.nameLabel
+
+  const canCreate = selected.length >= 2 && Boolean(name.trim() || selected.length)
+
+  const create = () => {
+    const base = (name.trim() || placeholder).slice(0, 64)
+
+    if (selected.length < 2 || !base) {
+      return
+    }
+
+    // Creating a group is always a FRESH room. Without this, re-creating a
+    // group under an existing name (easy — the default name is just the
+    // member names) silently reopens the old room with its full log, which
+    // reads as "not a fresh group" (db's Aug 2026 report). Uniquify against
+    // both live rooms and any bot's current grouping, then mint a fresh
+    // roomId: member sessions are titled by that roomId, so a
+    // disbanded-and-recreated group with the SAME display name still gets
+    // new sessions instead of resuming the old room's by title.
+    const taken = new Set(liveGroupChatNames())
+
+    for (const meta of Object.values($botMeta.get() || {})) {
+      for (const existing of botGroups(meta)) {
+        taken.add(existing)
+      }
+    }
+
+    const groupName = uniqueGroupChatName(base, taken)
+    const roomId = mintGroupRoomId()
+
+    for (const bot of selected) {
+      void saveBotMeta(bot, groupMembershipPatch(botRosterMeta(bot, allMeta), groupName, true))
+    }
+
+    // Persist every machine identity, including today's active source. That
+    // member becomes remote after a source switch and cannot rely on the new
+    // gateway's name-keyed bot metadata to remain seated in this room.
+    const roomMembers = durableGroupChatMembers(selected)
+    updateGroupChat(groupName, (room: GroupChatRoom) => {
+      room.members = roomMembers
+      room.roomId = roomId
+
+      if (image) {
+        room.image = image
+      }
+
+      return room
+    })
+    host.notify({
+      kind: 'info',
+      message: `“${groupName}” created with ${selected.length} bots`
+    })
+    onClose()
+    onCreated?.(groupName)
+  }
+
+  return (
+    <Dialog
+      onOpenChange={value => {
+        if (!value) {
+          onClose()
+        }
+      }}
+      open={open}
+    >
+      <DialogContent className="max-w-md">
+        <DialogHeader>
+          <DialogTitle>{b.group.newTitle}</DialogTitle>
+          <DialogDescription>{`Pick 2–${GROUP_CHAT_MAX_MEMBERS} bots. Local memberships sync through each Bot profile; cross-machine members stay scoped to this room.`}</DialogDescription>
+        </DialogHeader>
+        {/* TODO(bot-mode-types): this search box never takes focus when the dialog
+            opens — SearchField accepts no `autoFocus` prop and forwards no extra
+            props, so the `autoFocus` that used to sit here was inert. */}
+        <SearchField
+          aria-label={b.group.searchToAdd}
+          containerClassName="w-full"
+          inputClassName="w-full"
+          onChange={setQuery}
+          placeholder={b.group.searchToAddPlaceholder}
+          value={query}
+        />
+        {selected.length ? (
+          <div className="flex flex-wrap gap-1">
+            {selected.map(bot => (
+              <Badge
+                asChild
+                className="rounded-full bg-(--chrome-action-hover) pl-2 pr-1.5 text-[0.6875rem] text-(--ui-text-secondary) transition-colors hover:text-foreground"
+                key={botRosterKey(bot)}
+                variant="muted"
+              >
+                <RowButton
+                  onClick={() =>
+                    setChecked(prev => ({
+                      ...prev,
+                      [botRosterKey(bot)]: false
+                    }))
+                  }
+                  title={b.group.removeFromSelection}
+                >
+                  {displayName(bot, botRosterMeta(bot, allMeta))}
+                  <Codicon className="text-[0.6rem]" name="close" />
+                </RowButton>
+              </Badge>
+            ))}
+          </div>
+        ) : null}
+        <div className="max-h-64 min-h-0 overflow-y-auto overscroll-contain">
+          <div className="grid gap-0.5 pr-2">
+            {visible.length ? (
+              visible.map(bot => {
+                const meta = botRosterMeta(bot, allMeta)
+                const { shape, color, image } = botAppearance(bot.name, meta)
+                const isChecked = Boolean(checked[botRosterKey(bot)])
+                const disabled = !isChecked && atCap
+                const currentGroups = botGroups(meta)
+
+                return (
+                  <label
+                    className={cn(
+                      'flex cursor-pointer items-center gap-2 rounded-md px-1.5 py-1 transition-colors hover:bg-(--chrome-action-hover)',
+                      disabled && 'cursor-not-allowed opacity-50'
+                    )}
+                    key={botRosterKey(bot)}
+                  >
+                    <BotFace
+                      color={avatarColor(color, bot.name)}
+                      image={image && !isBackfilledFacePng(image) ? image : null}
+                      name={bot.name}
+                      shape={shape}
+                      size={24}
+                    />
+                    <div className="min-w-0 flex-1">
+                      <div className="truncate text-xs text-foreground">{displayName(bot, meta)}</div>
+                      <div className="truncate text-[0.625rem] text-(--ui-text-quaternary)">
+                        {[
+                          currentGroups.length
+                            ? `@${botHandle(bot.name, bot)} · in ${currentGroups.map(group => `“${group}”`).join(', ')}`
+                            : `@${botHandle(bot.name, bot)}`,
+                          bot.remoteSource && bot.connectionLabel ? ` · ${bot.connectionLabel}` : ''
+                        ].join('')}
+                      </div>
+                    </div>
+                    <Checkbox
+                      checked={isChecked}
+                      disabled={disabled}
+                      onCheckedChange={value =>
+                        setChecked(prev => ({
+                          ...prev,
+                          [botRosterKey(bot)]: Boolean(value)
+                        }))
+                      }
+                    />
+                  </label>
+                )
+              })
+            ) : (
+              <div className="px-1.5 py-3 text-center text-xs text-(--ui-text-tertiary)">
+                {query.trim() ? `No bots match “${query.trim()}”` : 'No bots yet — create one first.'}
+              </div>
+            )}
+          </div>
+        </div>
+        <div className="grid gap-2">
+          <GroupImageControls
+            image={image}
+            onImage={setImage}
+            seedMembers={selected.map(bot => displayName(bot, botRosterMeta(bot, allMeta)))}
+            seedName={name.trim() || (selected.length ? placeholder : '')}
+          />
+          <form
+            onSubmit={event => {
+              event.preventDefault()
+              create()
+            }}
+          >
+            <Input
+              aria-label={b.group.nameLabel}
+              maxLength={64}
+              onChange={event => setName(event.target.value)}
+              placeholder={placeholder}
+              value={name}
+            />
+          </form>
+        </div>
+        <DialogFooter>
+          <Button onClick={onClose} variant="secondary">
+            {t.common.cancel}
+          </Button>
+          <Button
+            disabled={!canCreate}
+            onClick={create}
+            title={selected.length < 2 ? 'Pick at least 2 bots' : undefined}
+          >{`Create Group${selected.length ? ` (${selected.length})` : ''}`}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-create-dialog.test.tsx b/apps/desktop/src/plugins/hermes-bots/cron-create-dialog.test.tsx
new file mode 100644
index 000000000000..2d05299e417e
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-create-dialog.test.tsx
@@ -0,0 +1,150 @@
+/**
+ * The Create-job dialog: who it says the job belongs to, and where the run's
+ * output is delivered.
+ *
+ * #93572: the dialog's `bot` prop is the pane's create target — an owner
+ * OBJECT for roster-scoped bots, a bare profile name otherwise. Building the
+ * label with `displayName({ name: bot }, $botMeta.get()[bot])` rendered
+ * "[object Object]" and keyed the meta map with an object. The prop is now
+ * normalized to a roster row at the component boundary and the meta lookup
+ * goes through the object-aware `botRosterMeta`.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { translateBots } from './i18n-test-helper'
+
+// Radix calls these on open; jsdom doesn't implement them.
+beforeAll(() => {
+  Element.prototype.scrollIntoView = vi.fn()
+  Element.prototype.hasPointerCapture = vi.fn(() => false)
+  Element.prototype.releasePointerCapture = vi.fn()
+})
+
+const { notify, request } = vi.hoisted(() => ({
+  notify: vi.fn(),
+  request: vi.fn(async (_method: string, _params: Record<string, unknown>) => ({}))
+}))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  return {
+    ...sdk,
+    host: { ...sdk.host, notify, request },
+    // The plugin bundle normally lands via `ctx.i18n.register` at load, so
+    // without this every localized label renders empty.
+    usePluginI18n: () => translateBots
+  }
+})
+
+const { $botMeta } = await import('./data')
+const { CreateRoutineDialog } = await import('./cron')
+
+/** The control under a `labeled(...)` caption — the label is presentational,
+ *  so it carries no `for`/`id` pair to query by. */
+function controlUnder(caption: string) {
+  const field = screen.getByText(caption).parentElement!
+
+  return within(field).getByRole('combobox')
+}
+
+/** Name + instruction; the schedule picker already defaults to a valid daily. */
+function fillRequiredFields() {
+  fireEvent.change(screen.getByPlaceholderText('Morning briefing'), { target: { value: 'Morning digest' } })
+  fireEvent.change(screen.getByPlaceholderText(/Summarize my unread Slack threads/), {
+    target: { value: 'Summarize yesterday.' }
+  })
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  $botMeta.set({})
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('the dialog names the bot, never its object', () => {
+  it('resolves an owner OBJECT through the roster-aware meta lookup', () => {
+    $botMeta.set({ ops: { title: 'Ops Bot' } })
+
+    render(<CreateRoutineDialog bot={{ name: 'ops' }} onClose={() => undefined} open />)
+
+    const dialog = screen.getByRole('dialog')
+
+    expect(dialog.textContent).toContain('Ops Bot')
+    expect(dialog.textContent).not.toContain('[object Object]')
+  })
+
+  it('normalizes the bare-name arm to the same label', () => {
+    $botMeta.set({ ops: { title: 'Ops Bot' } })
+
+    render(<CreateRoutineDialog bot="ops" onClose={() => undefined} open />)
+
+    expect(screen.getByRole('dialog').textContent).toContain('Ops Bot')
+  })
+})
+
+describe('where the run\u2019s output lands', () => {
+  it('offers run history and the bot\u2019s own chat', () => {
+    render(<CreateRoutineDialog bot={{ name: 'ops' }} onClose={() => undefined} open />)
+
+    fireEvent.click(controlUnder('Send results to'))
+
+    const options = screen.getAllByRole('option').map(option => option.textContent)
+
+    expect(options).toContain('Run history only')
+    expect(options.some(option => option?.includes('chat (bot responds)'))).toBe(true)
+  })
+
+  it('sends no deliver param by default \u2014 history only', async () => {
+    render(<CreateRoutineDialog bot={{ name: 'ops' }} onClose={() => undefined} open />)
+    fillRequiredFields()
+
+    fireEvent.click(screen.getByRole('button', { name: 'Create cron' }))
+
+    await waitFor(() => expect(request).toHaveBeenCalled())
+
+    const [, params] = request.mock.calls[0]
+
+    expect(params).not.toHaveProperty('deliver')
+    expect(params).toMatchObject({ action: 'add', name: '[bot:ops] Morning digest', profile: 'ops' })
+  })
+
+  it('sends the BARE bot-chat token on the profile-scoped create', async () => {
+    render(<CreateRoutineDialog bot={{ name: 'ops' }} onClose={() => undefined} open />)
+    fillRequiredFields()
+
+    fireEvent.click(controlUnder('Send results to'))
+    fireEvent.click(screen.getByRole('option', { name: /chat \(bot responds\)/ }))
+    fireEvent.click(screen.getByRole('button', { name: 'Create cron' }))
+
+    await waitFor(() => expect(request).toHaveBeenCalled())
+
+    const [, params] = request.mock.calls[0]
+
+    // The job is created in the bot's OWN cron store (profile scoping above),
+    // so the bare token resolves to that profile machine-locally. A named
+    // token built from a Desktop-side alias could name a profile the backend
+    // does not have — the #82530 alias trap.
+    expect(params.deliver).toBe('bot-chat')
+    expect(params.profile).toBe('ops')
+  })
+
+  it('returns the picker to history when the dialog is reopened', async () => {
+    const { rerender } = render(<CreateRoutineDialog bot={{ name: 'ops' }} onClose={() => undefined} open />)
+
+    fireEvent.click(controlUnder('Send results to'))
+    fireEvent.click(screen.getByRole('option', { name: /chat \(bot responds\)/ }))
+    // Cancel resets; a reopened dialog must never inherit the last target.
+    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }))
+
+    rerender(<CreateRoutineDialog bot={{ name: 'ops' }} onClose={() => undefined} open />)
+
+    await waitFor(() => expect(controlUnder('Send results to').textContent).toBe('Run history only'))
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-detail.test.tsx b/apps/desktop/src/plugins/hermes-bots/cron-detail.test.tsx
new file mode 100644
index 000000000000..f42b9808d1cb
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-detail.test.tsx
@@ -0,0 +1,174 @@
+/**
+ * Bot Mode's cronjob rows were inert: the only interactive controls were the
+ * enable switch and the hover-only delete button, so clicking a job to see
+ * what it runs, when it runs next, or why it stopped did nothing at all. The
+ * gateway already ships every one of those facts with `cron.manage list`, so
+ * the inspector reads the record the pane is already holding — no extra RPC,
+ * and no second mutation path beside the row's own switch and delete.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { cleanup, render, screen, within } from '@testing-library/react'
+import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
+
+import type { RoutineJob } from './types'
+
+// Radix calls these on open; jsdom doesn't implement them.
+beforeAll(() => {
+  Element.prototype.scrollIntoView = vi.fn()
+  Element.prototype.hasPointerCapture = vi.fn(() => false)
+  Element.prototype.releasePointerCapture = vi.fn()
+})
+
+const request = vi.fn(async () => ({}))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  return { ...sdk, host: { ...sdk.host, request } }
+})
+
+const { RoutineDetailDialog, RoutineRow, routineDetailIssue, routineDetailRows } = await import('./cron')
+
+const activeJob: RoutineJob = {
+  deliver: 'bot-chat',
+  enabled: true,
+  job_id: 'job-1',
+  last_run_at: '2026-08-23T09:00:00Z',
+  last_status: 'success',
+  name: '[bot:notetaker] Morning digest',
+  next_run_at: '2026-08-23T10:00:00Z',
+  prompt_preview: 'Summarize yesterday and post it.',
+  repeat: 'forever',
+  schedule: 'every 1440m'
+}
+
+const valueOf = (rows: Array<{ label: string; value: string }>, label: string) =>
+  rows.find(row => row.label === label)?.value
+
+afterEach(() => {
+  cleanup()
+  vi.clearAllMocks()
+})
+
+describe('the facts the row never showed', () => {
+  it('carries only the fields the gateway actually sent', () => {
+    const rows = routineDetailRows({ enabled: true, job_id: 'bare', name: 'Bare', schedule: 'every 1h' })
+    const labels = rows.map(row => row.label)
+
+    // A job that has never run carries no last_run_at/last_status/model; those
+    // rows must be absent rather than rendering an empty or "undefined" value.
+    expect(labels).not.toContain('Last run')
+    expect(labels).not.toContain('Last result')
+    expect(labels).not.toContain('Model')
+    expect(rows.every(row => row.value.trim().length > 0)).toBe(true)
+  })
+
+  it('promises a next run only while the job is active', () => {
+    const active = routineDetailRows(activeJob)
+
+    expect(valueOf(active, 'Status')).toBe('Active')
+    expect(valueOf(active, 'Next run')).toBeTruthy()
+
+    const paused = routineDetailRows({ ...activeJob, enabled: false, state: 'paused' })
+
+    expect(valueOf(paused, 'Status')).toBe('Paused')
+    expect(valueOf(paused, 'Next run')).toBeUndefined()
+    expect(valueOf(paused, 'Last run')).toBeTruthy()
+  })
+
+  it('shows the raw schedule only when the humanized label dropped something', () => {
+    // "every 1440m" humanizes to "Daily" — the raw form still carries the cadence.
+    expect(valueOf(routineDetailRows(activeJob), 'Schedule (raw)')).toBe('every 1440m')
+
+    // A schedule the label passes through unchanged would only be duplicated.
+    const passthrough = routineDetailRows({ ...activeJob, schedule: '0 9 * * 1-5' })
+
+    expect(valueOf(passthrough, 'Schedule (raw)')).toBeUndefined()
+    expect(valueOf(passthrough, 'Schedule')).toBe('0 9 * * 1-5')
+  })
+
+  it('explains a failing or scheduler-paused job in failure order', () => {
+    expect(routineDetailIssue(activeJob)).toBeNull()
+    expect(routineDetailIssue({ ...activeJob, paused_reason: 'too many failures' })).toBe('too many failures')
+    expect(
+      routineDetailIssue({ ...activeJob, last_delivery_error: 'telegram 401', paused_reason: 'too many failures' })
+    ).toBe('telegram 401')
+    expect(
+      routineDetailIssue({
+        ...activeJob,
+        last_delivery_error: 'telegram 401',
+        last_fire_error: 'model timeout',
+        paused_reason: 'too many failures'
+      })
+      // The run that never happened outranks the delivery of a run that did.
+    ).toBe('model timeout')
+  })
+})
+
+describe('the row is reachable', () => {
+  it('opens THIS job from its own title control', async () => {
+    const opened: RoutineJob[] = []
+
+    render(<RoutineRow job={activeJob} onOpen={job => opened.push(job)} owner={{ name: 'notetaker' }} />)
+
+    screen.getByRole('button', { name: /Morning digest/ }).click()
+
+    expect(opened).toEqual([activeJob])
+  })
+
+  it('cannot swallow the switch or the delete control', () => {
+    render(<RoutineRow job={activeJob} onOpen={() => undefined} owner={{ name: 'notetaker' }} />)
+
+    const opener = screen.getByRole('button', { name: /Morning digest/ })
+
+    // The switch and delete button must be SIBLINGS of the opener: nested
+    // inside it, a click on either would also open the inspector (and nested
+    // interactive elements are invalid markup).
+    expect(within(opener).queryByRole('switch')).toBeNull()
+    expect(within(opener).queryByRole('button')).toBeNull()
+    expect(screen.getAllByRole('switch')).toHaveLength(1)
+    expect(screen.getByRole('button', { name: /delete/i })).toBeTruthy()
+  })
+
+  it('refuses to run a legacy delegated routine, and says why', () => {
+    const legacy: RoutineJob = {
+      ...activeJob,
+      prompt_preview: 'You are running the scheduled routine "Morning digest" for agent \'notetaker\'.'
+    }
+
+    render(<RoutineRow job={legacy} onOpen={() => undefined} owner={{ name: 'notetaker' }} />)
+
+    // Its prompt was built by interpolation, so the switch stays locked until
+    // the user recreates the job through the hardened create path.
+    expect(screen.getByRole('switch')).toHaveProperty('disabled', true)
+    expect(screen.getByText(/Paused for security/)).toBeTruthy()
+  })
+})
+
+describe('the inspector', () => {
+  it('renders the job\u2019s instruction and its failure', () => {
+    render(
+      <RoutineDetailDialog job={{ ...activeJob, last_fire_error: 'model timeout' }} onClose={() => undefined} open />
+    )
+
+    const dialog = screen.getByRole('dialog')
+
+    expect(within(dialog).getByText('Morning digest')).toBeTruthy()
+    expect(within(dialog).getByText('Summarize yesterday and post it.')).toBeTruthy()
+    expect(within(dialog).getByText('model timeout')).toBeTruthy()
+    // The routing tag is plumbing, not a title.
+    expect(dialog.textContent).not.toMatch(/\[bot:notetaker\]/)
+  })
+
+  it('stays shut without a job to inspect', () => {
+    render(<RoutineDetailDialog job={null} onClose={() => undefined} open />)
+
+    expect(screen.queryByRole('dialog')).toBeNull()
+
+    cleanup()
+    render(<RoutineDetailDialog job={activeJob} onClose={() => undefined} open={false} />)
+
+    expect(screen.queryByRole('dialog')).toBeNull()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-jobs-view.test.ts b/apps/desktop/src/plugins/hermes-bots/cron-jobs-view.test.ts
new file mode 100644
index 000000000000..1b1b1293b1ec
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-jobs-view.test.ts
@@ -0,0 +1,118 @@
+/**
+ * Which cron jobs the pane shows, and why it can look empty.
+ *
+ * Jobs are namespaced `[bot:<name>]`. Newer gateways honour the `profile`
+ * param and answer with the bot's OWN cron store (echoed back as `scoped`),
+ * in which case every job in the reply belongs to the bot. Older gateways
+ * ignore the param and return the launch-profile store, so the tag filter
+ * stays the fallback — and a stale `scoped` marker must never be trusted to
+ * leak another profile's jobs.
+ */
+
+import { describe, expect, it } from 'vitest'
+
+import { routineFilterHint, selectRoutineJobs } from './cron'
+import type { RoutineJob } from './types'
+
+const jobs: RoutineJob[] = [
+  { job_id: '1', name: '[bot:ops] Morning' },
+  { job_id: '2', name: '[bot:research] Digest' }
+]
+
+describe('selecting the jobs for the active bot', () => {
+  it('filters a live list down to the current bot', () => {
+    const view = selectRoutineJobs({ jobs }, null, [], 'ops')
+
+    expect(view.live).toHaveLength(2)
+    expect(view.jobs.map(job => job.job_id)).toEqual(['1'])
+  })
+
+  it('shows every job in a profile-scoped list, tagged or not', () => {
+    const profileJobs: RoutineJob[] = [
+      { job_id: 'legacy', name: 'ordinary profile cronjob' },
+      { job_id: 'routine', name: '[bot:ops] Bot Mode routine' }
+    ]
+
+    const view = selectRoutineJobs({ jobs: profileJobs, scoped: 'ops' }, null, [], 'ops')
+
+    expect(view.jobs.map(job => job.job_id)).toEqual(['legacy', 'routine'])
+  })
+
+  it('keeps tag filtering for an unmarked list (older gateways)', () => {
+    const profileJobs: RoutineJob[] = [
+      { job_id: 'legacy', name: 'ordinary launch-profile cronjob' },
+      { job_id: 'routine', name: '[bot:ops] Bot Mode routine' }
+    ]
+
+    const view = selectRoutineJobs({ jobs: profileJobs }, null, [], 'ops')
+
+    expect(view.jobs.map(job => job.job_id)).toEqual(['routine'])
+  })
+
+  it('cannot leak another profile\u2019s jobs through a stale scope marker', () => {
+    const profileJobs: RoutineJob[] = [
+      { job_id: 'research', name: 'ordinary research cronjob' },
+      { job_id: 'routine', name: '[bot:ops] Bot Mode routine' }
+    ]
+
+    const view = selectRoutineJobs({ jobs: profileJobs, scoped: 'research' }, null, [], 'ops')
+
+    expect(view.jobs.map(job => job.job_id)).toEqual(['routine'])
+  })
+
+  it('shows untagged legacy cronjobs only on the default bot', () => {
+    const legacy: RoutineJob = { job_id: 'legacy', name: 'Existing reminder' }
+
+    expect(selectRoutineJobs({ jobs: [legacy] }, null, [], 'default').jobs).toEqual([legacy])
+    expect(selectRoutineJobs({ jobs: [legacy] }, null, [], 'ops').jobs).toEqual([])
+  })
+})
+
+describe('a failed refresh keeps the last good list', () => {
+  it('falls back to the previous jobs, still filtered', () => {
+    const view = selectRoutineJobs(undefined, new Error('down'), jobs, 'ops')
+
+    expect(view.live).toBeNull()
+    expect(view.all).toHaveLength(2)
+    expect(view.jobs).toHaveLength(1)
+  })
+
+  it('does not resurrect a list a successful refresh emptied', () => {
+    const view = selectRoutineJobs({ jobs: [] }, null, jobs, 'ops')
+
+    expect(view.live).toBeTruthy()
+    expect(view.jobs).toHaveLength(0)
+  })
+
+  it('has nothing to show when the FIRST load fails', () => {
+    const view = selectRoutineJobs(undefined, new Error('down'), [], 'ops')
+
+    expect(view.all).toHaveLength(0)
+    expect(view.jobs).toHaveLength(0)
+  })
+})
+
+// A bot's cron store can hold jobs while none are namespaced for the active
+// bot. Without a hint the user stares at the generic empty state with no clue
+// that cronjobs are present but hidden by the tag filter.
+describe('explaining an empty pane over a non-empty store', () => {
+  it('stays quiet when the active bot already has tagged jobs', () => {
+    const all: RoutineJob[] = [{ job_id: '1', name: '[bot:ops] Morning' }]
+
+    expect(routineFilterHint(all, all)).toBeNull()
+  })
+
+  it('stays quiet when the store is genuinely empty', () => {
+    expect(routineFilterHint([], [])).toBeNull()
+    expect(routineFilterHint(undefined as unknown as RoutineJob[], [])).toBeNull()
+  })
+
+  it('explains the hidden jobs when the store has jobs but none match', () => {
+    const all: RoutineJob[] = [
+      { job_id: '2', name: '[bot:research] Digest' },
+      { job_id: '3', name: 'untagged job' }
+    ]
+
+    expect(routineFilterHint(all, [])).toMatch(/tagged for this bot/)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-load.test.ts b/apps/desktop/src/plugins/hermes-bots/cron-load.test.ts
new file mode 100644
index 000000000000..3839827ccd4f
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-load.test.ts
@@ -0,0 +1,177 @@
+/**
+ * `loadRoutines` — the pane's one read, and the two things it must survive.
+ *
+ * 1. Profile scope (#37). cron.manage is scoped to the bot's OWN cron store
+ *    through the core RPC's optional `profile` param: a bot's profile can run
+ *    a separate gateway, or keep cron in ~/.hermes/profiles/<name>/cron/.
+ *    Older gateways ignore the unknown param, so the `[bot:]` tag filter in
+ *    selectRoutineJobs stays the fallback.
+ * 2. Legacy delegated routines are paused inline before the list returns —
+ *    they carry a pre-hardening prompt whose shell command was built by
+ *    interpolation. A single pause RPC failing used to reject the WHOLE query:
+ *    the pane showed "Could not load cronjobs" over a list that had loaded
+ *    fine, and the 20s poll retried the failing pause inside a failing query
+ *    forever. Each pause now swallows its own error, and the paused-state
+ *    overlay only claims the jobs the gateway actually paused.
+ *
+ * The RPC boundary is `host.request` rather than `requestForBot`, so the real
+ * routing layer (route resolution, error coercion) runs.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RoutineJob } from './types'
+
+const request = vi.fn()
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  return { ...sdk, host: { ...sdk.host, request } }
+})
+
+const { loadRoutines } = await import('./cron')
+
+const LEGACY_PREFIX = 'You are running the scheduled routine "'
+
+/** The shape a pre-hardening routine was persisted with. */
+function legacyJob(id: string, title: string, bot: string): RoutineJob {
+  return {
+    enabled: true,
+    job_id: id,
+    name: `[bot:${bot}] ${title}`,
+    prompt_preview: `${LEGACY_PREFIX}${title}" for agent '${bot}'`,
+    state: 'scheduled'
+  }
+}
+
+/** Every cron.manage call, as `[action, name]`. */
+function callLog() {
+  return request.mock.calls.map(([, params]) => [params.action, params.name])
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('the bot\u2019s own cron store', () => {
+  it('scopes the list and every inline pause to the bot profile', async () => {
+    request.mockImplementation(async (_method: string, params: Record<string, unknown>) =>
+      params.action === 'list' ? { jobs: [legacyJob('legacy', 'Audit', 'research')] } : { success: true }
+    )
+
+    await loadRoutines('research')
+
+    expect(request.mock.calls.map(([method, params]) => [method, params])).toEqual([
+      ['cron.manage', { action: 'list', include_disabled: true, profile: 'research' }],
+      ['cron.manage', { action: 'pause', name: 'legacy', profile: 'research' }]
+    ])
+  })
+
+  it('omits the scope entirely when no owner is resolved', async () => {
+    request.mockResolvedValue({ jobs: [] })
+
+    await loadRoutines(undefined)
+
+    expect(request).toHaveBeenCalledWith('cron.manage', { action: 'list', include_disabled: true })
+  })
+})
+
+describe('pausing a legacy delegated routine cannot fail the list', () => {
+  it('returns the whole list and overlays only the pauses that landed', async () => {
+    const jobs: RoutineJob[] = [
+      legacyJob('legacy-fails', 'Audit', 'research'),
+      legacyJob('legacy-pauses', 'Build', 'research'),
+      {
+        enabled: true,
+        job_id: 'normal',
+        name: '[bot:research] Report',
+        prompt: 'Summarize the day',
+        state: 'scheduled'
+      }
+    ]
+
+    request.mockImplementation(async (_method: string, params: Record<string, unknown>) => {
+      if (params.action === 'list') {
+        return { jobs }
+      }
+
+      if (params.name === 'legacy-fails') {
+        throw new Error('gateway rejected the pause')
+      }
+
+      return { success: true }
+    })
+
+    // Pre-fix this rejected with the pause error.
+    const result = await loadRoutines('research')
+
+    expect(result.jobs).toHaveLength(3)
+
+    const byId = Object.fromEntries(result.jobs!.map(job => [job.job_id, job]))
+
+    // The failed pause keeps its server state and is retried on the next poll;
+    // claiming it as paused would tell the user a job is safe when it is not.
+    expect(byId['legacy-fails']).toMatchObject({ enabled: true, state: 'scheduled' })
+    expect(byId['legacy-pauses']).toMatchObject({ enabled: false, state: 'paused' })
+    expect(byId.normal.enabled).toBe(true)
+
+    expect(callLog()).toEqual([
+      ['list', undefined],
+      ['pause', 'legacy-fails'],
+      ['pause', 'legacy-pauses']
+    ])
+  })
+
+  it('still resolves with the list when every pause fails', async () => {
+    request.mockImplementation(async (_method: string, params: Record<string, unknown>) => {
+      if (params.action === 'list') {
+        return { jobs: [legacyJob('only', 'Watch', 'ops')] }
+      }
+
+      throw new Error('gateway down')
+    })
+
+    const result = await loadRoutines('ops')
+
+    expect(result.jobs![0]).toMatchObject({ enabled: true, job_id: 'only' })
+  })
+})
+
+describe('the security pause is one-shot, not a poll loop', () => {
+  it('pauses the persisted routine once and leaves the rest of the record intact', async () => {
+    const persisted: RoutineJob = {
+      ...legacyJob('legacy-job', 'Audit', 'research'),
+      repeat: { completed: 1, times: 3 } as unknown as string,
+      schedule: 'every 2h'
+    }
+
+    request.mockImplementation(async (_method: string, params: Record<string, unknown>) => {
+      if (params.action === 'list') {
+        return { jobs: [persisted] }
+      }
+
+      persisted.enabled = false
+      persisted.state = 'paused'
+
+      return { success: true }
+    })
+
+    const first = await loadRoutines('research')
+
+    expect(first.jobs![0]).toMatchObject({
+      enabled: false,
+      job_id: 'legacy-job',
+      repeat: { completed: 1, times: 3 },
+      schedule: 'every 2h',
+      state: 'paused'
+    })
+
+    request.mockClear()
+    await loadRoutines('research')
+
+    // Already paused: the next poll must not re-attempt the pause forever.
+    expect(callLog()).toEqual([['list', undefined]])
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-owner.test.tsx b/apps/desktop/src/plugins/hermes-bots/cron-owner.test.tsx
new file mode 100644
index 000000000000..2860d4bce35f
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-owner.test.tsx
@@ -0,0 +1,70 @@
+/**
+ * A cron mutation names the owner that rendered it, never the ambient profile.
+ *
+ * The Routines pane follows the focused chat, so the live gateway profile can
+ * already be on another bot by the time a row's switch is flipped or a create
+ * dialog is submitted. Both the RPC scope and the cache eviction therefore
+ * ride the captured owner — and the eviction is `exact`, so flipping one bot's
+ * job cannot invalidate every other bot's list.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { queryClient } from '@hermes/plugin-sdk'
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { request } = vi.hoisted(() => ({ request: vi.fn(async () => ({})) }))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  return { ...sdk, host: { ...sdk.host, request } }
+})
+
+const { invalidateRoutineOwner, RoutineRow, routineCreateTarget } = await import('./cron')
+
+const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries').mockResolvedValue(undefined)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('the create target is captured, not re-read', () => {
+  it('keeps the owner the dialog was opened for while another bot becomes active', () => {
+    expect(routineCreateTarget('ops', 'ops')).toBe('ops')
+    expect(routineCreateTarget('ops', 'default')).toBe('ops')
+    // Nothing captured yet: the pane's resolved bot is the target.
+    expect(routineCreateTarget(null, 'default')).toBe('default')
+  })
+})
+
+describe('cache eviction is scoped to one owner', () => {
+  it('invalidates that owner\u2019s list and nothing else', async () => {
+    await invalidateRoutineOwner('ops')
+
+    expect(invalidateQueries).toHaveBeenCalledWith({ exact: true, queryKey: ['hermes-bots', 'routines', 'ops'] })
+  })
+})
+
+describe('a row mutation addresses the owner that rendered it', () => {
+  it('scopes the pause RPC and the eviction to that owner', async () => {
+    render(
+      <RoutineRow
+        job={{ enabled: true, job_id: 'digest', name: '[bot:ops] Digest', schedule: 'every 1h' }}
+        onOpen={() => undefined}
+        owner={{ name: 'ops' }}
+      />
+    )
+
+    fireEvent.click(screen.getByRole('switch'))
+
+    await waitFor(() => expect(invalidateQueries).toHaveBeenCalled())
+
+    expect(request).toHaveBeenCalledWith('cron.manage', { action: 'pause', name: 'digest', profile: 'ops' })
+    expect(invalidateQueries).toHaveBeenCalledWith({ exact: true, queryKey: ['hermes-bots', 'routines', 'ops'] })
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-pane.test.tsx b/apps/desktop/src/plugins/hermes-bots/cron-pane.test.tsx
new file mode 100644
index 000000000000..f9586e425cdb
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-pane.test.tsx
@@ -0,0 +1,135 @@
+/**
+ * #94483: the Scheduled jobs pane read the shared roster with a bare
+ * `$lastRoster.get()` while rendering. BotsPane owns the roster fetch, so
+ * whenever this pane mounted before the roster hydrated (fresh boot ordering,
+ * a renderer reload resetting the atoms) it captured an empty snapshot
+ * forever: the pane stayed pinned on its "has to appear in the roster"
+ * placeholder even for a focused bot chat whose exact roster row existed, and
+ * creating a job silently no-oped.
+ *
+ * The contract:
+ *   1. the pane SUBSCRIBES to the roster, so hydration re-renders it;
+ *   2. once the owner resolves it paints real content and a working create
+ *      affordance instead of the placeholder;
+ *   3. a complete (authoritative) focused owner with no exact roster row STILL
+ *      fails closed — the subscription fix must not loosen identity matching.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react'
+import type { atom } from 'nanostores'
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { translateBots } from './i18n-test-helper'
+import type { RoutineJob } from './types'
+
+// Radix calls these on open; jsdom doesn't implement them.
+beforeAll(() => {
+  Element.prototype.scrollIntoView = vi.fn()
+  Element.prototype.hasPointerCapture = vi.fn(() => false)
+  Element.prototype.releasePointerCapture = vi.fn()
+})
+
+const { request } = vi.hoisted(() => ({ request: vi.fn() }))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+  const { atom: nanoAtom } = await import('nanostores')
+
+  return {
+    ...sdk,
+    host: {
+      ...sdk.host,
+      request,
+      // The pane's owner ladder starts here, so it has to be a real store:
+      // `$focusedBotOwner` is resolved once at bot-state module load.
+      state: { ...sdk.host.state, focusedSessionOwner: nanoAtom(null) }
+    },
+    // The plugin bundle normally lands via `ctx.i18n.register` at load, so
+    // without this every localized label renders empty.
+    usePluginI18n: () => translateBots
+  }
+})
+
+const { host } = await import('@hermes/plugin-sdk')
+const { $lastRoster } = await import('./data')
+const { $selectedBot } = await import('./bot-state')
+const { RoutinesPane } = await import('./cron')
+
+/** The SDK store the pane's owner ladder reads. */
+const $focused = host.state.focusedSessionOwner as unknown as ReturnType<typeof atom>
+
+const job: RoutineJob = { enabled: true, job_id: 'j-1', name: 'Report', schedule: 'every 1h', state: 'scheduled' }
+
+function renderPane() {
+  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+
+  return render(
+    <QueryClientProvider client={client}>
+      <RoutinesPane />
+    </QueryClientProvider>
+  )
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  request.mockResolvedValue({ jobs: [job], scoped: 'research' })
+  // Mount order under test: the pane paints BEFORE the roster fetch lands.
+  $lastRoster.set([])
+  $selectedBot.set('default')
+  $focused.set({ connectionId: 'local', profile: 'research' })
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('the pane follows the roster hydrating after mount', () => {
+  it('starts fail-closed, then paints once the row arrives', async () => {
+    renderPane()
+
+    expect(screen.getByText('This bot has to appear in the roster first.')).toBeTruthy()
+
+    // The same focused bot chat now resolves to its exact roster row. Nothing
+    // else changes — only a store write the pane must be subscribed to see.
+    act(() => $lastRoster.set([{ connectionId: 'local', name: 'research' }]))
+
+    await waitFor(() => expect(screen.queryByText('This bot has to appear in the roster first.')).toBeNull())
+    expect(await screen.findByText('Report')).toBeTruthy()
+    expect(screen.getByText('Scheduled jobs')).toBeTruthy()
+  })
+
+  it('offers a create affordance once the owner resolves', async () => {
+    request.mockResolvedValue({ jobs: [], scoped: 'research' })
+    renderPane()
+
+    act(() => $lastRoster.set([{ connectionId: 'local', name: 'research' }]))
+
+    // The reported "create silently no-ops" symptom starts here: while the
+    // owner is stuck unresolved the pane never offers any create control.
+    expect(await screen.findByText('No scheduled jobs yet')).toBeTruthy()
+
+    // Both doors: the header action and the empty state's own call to action.
+    const create = screen.getAllByRole('button', { name: 'New cron' })
+
+    expect(create).toHaveLength(2)
+
+    act(() => create[0].click())
+
+    // The dialog opens naming the resolved owner, not a placeholder.
+    expect((await screen.findByRole('dialog')).textContent).toMatch(/research/i)
+  })
+})
+
+describe('identity matching stays exact', () => {
+  it('fails closed for a complete focused owner with no roster row', async () => {
+    $focused.set({ connectionId: 'local', profile: 'ghost-profile' })
+    renderPane()
+
+    act(() => $lastRoster.set([{ connectionId: 'local', name: 'research' }]))
+
+    await waitFor(() => expect(screen.getByText('This bot has to appear in the roster first.')).toBeTruthy())
+    expect(request).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-prompt.test.ts b/apps/desktop/src/plugins/hermes-bots/cron-prompt.test.ts
new file mode 100644
index 000000000000..fbaf1e28c02a
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-prompt.test.ts
@@ -0,0 +1,92 @@
+/**
+ * What a routine actually runs.
+ *
+ * A job scheduled for the ACTIVE bot profile runs its instruction directly. A
+ * job for a different profile keeps the `hermes -p <bot> chat` delegation
+ * wrapper so the run lands in that bot's own history — and that wrapper is a
+ * shell command line, which is why every operand is single-quoted rather than
+ * interpolated. The pre-hardening prompts were built by interpolation, so a
+ * routine title or instruction containing `$(…)` executed on the scheduler's
+ * machine; `isLegacyDelegatedRoutine` is how those persisted jobs are still
+ * recognized and paused.
+ */
+
+import { spawnSync } from 'node:child_process'
+
+import { describe, expect, it } from 'vitest'
+
+import { isLegacyDelegatedRoutine, normalizedProfileName, routineInputError, routinePrompt } from './cron'
+
+/** Run the delegation command under a `hermes` stub that prints its argv, so
+ *  the assertion is what the SHELL passed — not what the string looks like. */
+function argvOf(prompt: string): string[] {
+  const command = prompt.slice(prompt.indexOf('hermes '), prompt.lastIndexOf('\n\nIf the command'))
+  const result = spawnSync('sh', ['-c', `hermes() { printf '%s\\037' "$@"; }\n${command}`], { encoding: 'utf8' })
+
+  expect(result.status, result.stderr).toBe(0)
+
+  return result.stdout.split('\u001f').slice(0, -1)
+}
+
+describe('direct vs delegated execution', () => {
+  it('runs the bare instruction when the routine owns the active profile', () => {
+    expect(normalizedProfileName(' Default ')).toBe('default')
+    expect(routinePrompt('default', 'Health', 'Collect status', ' DEFAULT ')).toBe('Collect status')
+  })
+
+  it('keeps the delegation wrapper for a different active profile', () => {
+    const prompt = routinePrompt('research', 'Digest', 'Summarize findings', 'default')
+
+    expect(prompt).toMatch(/hermes -p 'research' chat/)
+    expect(prompt).toMatch(/\[Scheduled routine\] Summarize findings/)
+  })
+
+  it('never re-wraps a direct prompt', () => {
+    const instruction = 'Keep "quoted" output intact'
+
+    expect(routinePrompt('ops', 'Check', instruction, 'ops')).toBe(instruction)
+  })
+})
+
+describe('delegated arguments stay literal shell values', () => {
+  it('passes substitutions, backticks and quotes through as text', () => {
+    const title = "Audit $(printf TITLE_EXPANDED) `printf TITLE_TICK` 'quoted'"
+    const instruction = "Line one $(printf TASK_EXPANDED) `printf TASK_TICK`\nLine two 'quoted'"
+
+    expect(argvOf(routinePrompt('research', title, instruction, 'default'))).toEqual([
+      '-p',
+      'research',
+      'chat',
+      '-c',
+      `Routine: ${title}`,
+      '-q',
+      `[Scheduled routine] ${instruction}`
+    ])
+  })
+
+  it('a recreated routine is no longer recognized as the unsafe legacy shape', () => {
+    // The v2 marker is what tells the loader this prompt was composed with
+    // quoting, so it must NOT be swept into the security pause.
+    const recreated = routinePrompt('research', 'Audit', 'Inspect', 'default')
+
+    expect(
+      isLegacyDelegatedRoutine({ job_id: 'x', name: '[bot:research] Audit', prompt_preview: recreated.slice(0, 100) })
+    ).toBe(false)
+  })
+
+  it('recognizes a persisted pre-hardening prompt', () => {
+    const legacy = 'You are running the scheduled routine "Audit" for agent \'research\'.'
+
+    expect(isLegacyDelegatedRoutine({ job_id: 'x', name: '[bot:research] Audit', prompt_preview: legacy })).toBe(true)
+    // Untagged jobs are not Bot Mode's to pause, whatever their prompt says.
+    expect(isLegacyDelegatedRoutine({ job_id: 'x', name: 'Audit', prompt_preview: legacy })).toBe(false)
+  })
+})
+
+describe('input the gateway cannot store', () => {
+  it('rejects NUL before cron creation, naming the offending field', () => {
+    expect(routineInputError('Normal title', 'Normal instruction')).toBeNull()
+    expect(routineInputError('Bad\0title', 'Normal instruction')).toMatch(/NUL.*U\+0000/)
+    expect(routineInputError('Normal title', 'Bad\0instruction')).toMatch(/NUL.*U\+0000/)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-rpc-error.test.ts b/apps/desktop/src/plugins/hermes-bots/cron-rpc-error.test.ts
new file mode 100644
index 000000000000..4619bfe27406
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-rpc-error.test.ts
@@ -0,0 +1,111 @@
+/**
+ * #94471: React Query stores whatever the queryFn throws, and React 19 then
+ * formats it with `(error.name || '').trim()`. IPC / JSON-RPC rejections are
+ * frequently plain objects whose `name` is the numeric error code, so that
+ * `.trim()` threw "is not a function" and the Routines pane died instead of
+ * rendering "Could not load cronjobs".
+ *
+ * `requestForBot` is the choke point every cron read and mutation goes
+ * through, so the coercion is pinned there — through the real function, not
+ * the private helper behind it.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const request = vi.fn()
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  return { ...sdk, host: { ...sdk.host, request } }
+})
+
+const { loadRoutines } = await import('./cron')
+const { requestForBot } = await import('./routing')
+
+/** Exactly what React 19 does to a query error before painting it. */
+function react19Format(error: { message?: unknown; name?: unknown }) {
+  return `${((error.name as string) || '').trim()}: ${String(error.message)}`
+}
+
+/** The rejection `requestForBot` hands back, after coercion. */
+async function rejectionFrom(thrown: unknown) {
+  request.mockRejectedValue(thrown)
+
+  return requestForBot({ name: 'research' }, 'cron.manage', {}).then(
+    () => {
+      throw new Error('requestForBot resolved; it must propagate the rejection')
+    },
+    (error: Error) => error
+  )
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('a rejection always reaches React with a string name', () => {
+  it('coerces a plain JSON-RPC object whose name is an error code', async () => {
+    request.mockRejectedValue({ code: -32603, message: 'cron.manage failed', name: 32000 })
+
+    const error = await loadRoutines('research').then(
+      () => {
+        throw new Error('loadRoutines resolved; the list read must propagate the failure')
+      },
+      (thrown: Error) => thrown
+    )
+
+    expect(typeof error.name).toBe('string')
+    expect(() => react19Format(error)).not.toThrow()
+    expect(error.message).toMatch(/cron\.manage failed/)
+    // The original rejection is preserved for logs — only the surface is fixed.
+    expect((error.cause as { name: number }).name).toBe(32000)
+  })
+
+  it('coerces a real Error whose name was overwritten with a number', async () => {
+    const weird = new Error('down')
+
+    Object.defineProperty(weird, 'name', { configurable: true, value: 13 })
+
+    const error = await rejectionFrom(weird)
+
+    expect(typeof error.name).toBe('string')
+    expect(() => react19Format(error)).not.toThrow()
+    expect(error.message).toMatch(/down/)
+  })
+
+  it('copies rather than mutates a frozen non-string name', async () => {
+    const weird = new Error('down')
+
+    Object.defineProperty(weird, 'name', { configurable: false, value: 13, writable: false })
+
+    const error = await rejectionFrom(weird)
+
+    expect(error).not.toBe(weird)
+    expect(typeof error.name).toBe('string')
+    expect(() => react19Format(error)).not.toThrow()
+  })
+
+  it('copies a sealed Error even where assignment would have worked', async () => {
+    const weird = new Error('sealed')
+
+    Object.defineProperty(weird, 'name', { configurable: true, value: 32000, writable: true })
+    Object.seal(weird)
+
+    const error = await rejectionFrom(weird)
+
+    expect(error).not.toBe(weird)
+    expect(typeof error.name).toBe('string')
+    expect(error.message).toMatch(/sealed/)
+    // Assignment would have succeeded on a sealed writable property; we still
+    // copy so React 19 never sees a numeric name even if mutation is possible.
+    expect(weird.name).toBe(32000)
+  })
+
+  it('passes an ordinary Error through untouched', async () => {
+    const original = new Error('gateway rejected the pause')
+
+    expect(await rejectionFrom(original)).toBe(original)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron-selected-bot.test.ts b/apps/desktop/src/plugins/hermes-bots/cron-selected-bot.test.ts
new file mode 100644
index 000000000000..510902138922
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron-selected-bot.test.ts
@@ -0,0 +1,131 @@
+/**
+ * Which bot the Routines pane is scoped to.
+ *
+ * #89625 (PR #89637 residual): nanostores' `.listen()` never replays the
+ * current value the way `.subscribe()` does, so the focused-owner listener in
+ * register() only kept `$selectedBot` current from the moment it was attached.
+ * A disable → profile switch → re-enable cycle (Settings ▸ Plugins) left
+ * `$selectedBot` pointed at whichever bot was active before the plugin was
+ * disabled. `bindProfileSync` reseeds from the store's CURRENT value before
+ * attaching the listener, so every register() starts in sync.
+ *
+ * #94516: the same ladder must not dead-end the pane. The SDK's
+ * focusedSessionOwner store fails closed to null whenever the focused session
+ * has no unique bot owner (a normal chat, ambiguous owner hints) — the common
+ * case while the user browses the Bots pane. The pane falls back to the bot
+ * the user clicked in the roster instead of pinning every bot on the
+ * "has to appear in the roster first" placeholder.
+ */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { $selectedBot } from './bot-state'
+import { bindProfileSync, resolveRoutineOwner } from './cron'
+import type { RosterRow } from './types'
+
+/** Real nanostores semantics — `get()` plus a NON-replaying `listen()` — so a
+ *  regression back to a plain listen() fails honestly instead of being masked
+ *  by a mock that assumes the fix. */
+function fakeOwnerStore<T>(initial: T) {
+  const listeners = new Set<(value: T) => void>()
+  let value = initial
+
+  return {
+    get: () => value,
+    listen: (listener: (value: T) => void) => {
+      listeners.add(listener)
+
+      return () => listeners.delete(listener)
+    },
+    set: (next: T) => {
+      value = next
+      listeners.forEach(listener => listener(value))
+    }
+  }
+}
+
+beforeEach(() => {
+  $selectedBot.set('default')
+})
+
+describe('bindProfileSync reseeds, then follows', () => {
+  it('resyncs on re-bind after a profile switch made while unbound', () => {
+    const profile = fakeOwnerStore('blog-writer')
+    const unbind = bindProfileSync(profile)
+
+    expect($selectedBot.get()).toBe('blog-writer')
+
+    unbind() // plugin disabled: listener torn down
+    profile.set('researcher') // profile changes while nothing is listening
+
+    bindProfileSync(profile) // plugin re-enabled: register() runs again
+
+    expect($selectedBot.get()).toBe('researcher')
+  })
+
+  it('keeps forwarding live profile changes after (re)binding', () => {
+    const profile = fakeOwnerStore('default')
+
+    bindProfileSync(profile)
+    profile.set('researcher')
+
+    expect($selectedBot.get()).toBe('researcher')
+  })
+
+  it('follows a connection change for the same profile name', () => {
+    const owner = fakeOwnerStore({ connectionId: 'source-a', profile: 'default' })
+
+    bindProfileSync(owner)
+
+    expect($selectedBot.get()).toBe('source-a::default')
+
+    owner.set({ connectionId: 'source-b', profile: 'default' })
+
+    expect($selectedBot.get()).toBe('source-b::default')
+  })
+
+  it('leaves the selection alone when the current value is empty', () => {
+    bindProfileSync(fakeOwnerStore(''))
+
+    expect($selectedBot.get()).toBe('default')
+  })
+})
+
+describe('resolving the pane\u2019s owner', () => {
+  const scoped = (name: string): RosterRow => ({
+    connectionId: 'source-a',
+    name,
+    remoteSource: true,
+    sourceScoped: true
+  })
+
+  it('fails closed when an authoritative focused owner has no roster row', () => {
+    // Routing cron reads/mutations through a stale selection or an unscoped
+    // profile name would address the wrong machine's cron store.
+    expect(
+      resolveRoutineOwner(
+        [scoped('default')],
+        { authoritative: true, connectionId: 'source-b', name: 'worker' },
+        'source-a::default'
+      )
+    ).toBeNull()
+  })
+
+  it('#94516: falls back to the roster-clicked bot when nothing is focused', () => {
+    const roster = [scoped('default'), scoped('blog-writer')]
+
+    expect(resolveRoutineOwner(roster, null, 'source-a::blog-writer')).toBe(roster[1])
+  })
+
+  it('#94516: still fails closed when the selection has no roster row either', () => {
+    // Nothing to scope cron reads/mutations to, so the pane keeps its
+    // fail-closed state rather than guessing.
+    expect(resolveRoutineOwner([scoped('default')], null, 'source-a::missing')).toBeNull()
+  })
+
+  it('lets a legacy SDK without focused-owner support use the selection', () => {
+    const roster = [scoped('default')]
+
+    expect(resolveRoutineOwner(roster, null, 'source-a::default')).toBe(roster[0])
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/cron.tsx b/apps/desktop/src/plugins/hermes-bots/cron.tsx
new file mode 100644
index 000000000000..4e25a957aae7
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cron.tsx
@@ -0,0 +1,1297 @@
+/**
+ * Routines: the Hermes cron jobs scoped to the bot you're chatting with — the
+ * list query and its owner resolution, the schedule picker, the create and
+ * detail dialogs, and the pane the right tile renders.
+ */
+
+import {
+  atom,
+  Button,
+  Checkbox,
+  cn,
+  Codicon,
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  GlyphSpinner,
+  host,
+  Input,
+  PanelEmpty,
+  queryClient,
+  relativeTime,
+  RowButton,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Switch,
+  Textarea,
+  Tip,
+  translateNow,
+  useI18n,
+  useQuery,
+  useValue
+} from '@hermes/plugin-sdk'
+import { useState } from 'react'
+
+import { avatarColor, botAppearance, BotFace } from './avatar'
+import { $focusedBotOwner, $selectedBot, focusedRosterOwner } from './bot-state'
+import { $botMeta, $lastRoster, botHandle, botRosterKey, botSelectionKey, isActiveRosterBot } from './data'
+import { labeled } from './dialog-parts'
+import { botsText, useBots } from './i18n'
+import { displayName } from './labels'
+import { botConnectionRoute, botRosterMeta, requestForBot } from './routing'
+import { ID } from './shared'
+import type { BotMeta, RosterRow, RoutineJob } from './types'
+
+const ROUTINES_KEY = [ID, 'routines']
+
+/** Last good cron list, same idea as the roster snapshot. */
+const $lastJobs = atom<RoutineJob[]>([])
+
+function showsHandle(name: string, meta: BotMeta | null | undefined, bot?: RosterRow) {
+  const display = displayName(
+    {
+      name
+    },
+    meta
+  )
+
+  return Boolean(name && display.toLowerCase() !== botHandle(name, bot).toLowerCase())
+}
+
+// ── routines (cron) ──────────────────────────────────────────────────────────
+//
+// Jobs are namespaced "[bot:<name>] <routine>". A job running in the active
+// bot profile uses the plain instruction; a different profile keeps the
+// hermes -p <bot> chat delegation wrapper so the run reaches that bot's
+// history. The tile follows the bot you're chatting with (gateway profile).
+const BOT_TAG_RE = /^\[bot:([a-z0-9][a-z0-9_-]*)\]\s*/i
+const SAFE_ROUTINE_MARKER = '[bot-mode:routine:v2] '
+const LEGACY_DELEGATED_ROUTINE_PREFIX = 'You are running the scheduled routine "'
+
+/** A routine's owner: a roster row, a bare profile name, or nothing resolved yet. */
+type RoutineOwner = RosterRow | string | null | undefined
+
+/** `cron.manage {action: 'list'}` reply. `scoped` carries the profile the
+ *  gateway scoped the store to; gateways that ignore `profile` omit it. */
+interface RoutineListResult {
+  jobs?: RoutineJob[]
+  scoped?: string
+}
+
+function routineBot(job: RoutineJob | null | undefined): null | string {
+  const match = BOT_TAG_RE.exec(job?.name || '')
+
+  return match ? match[1].toLowerCase() : null
+}
+
+function routineTitle(job: RoutineJob | null | undefined): string {
+  return (job?.name || '').replace(BOT_TAG_RE, '') || 'Untitled job'
+}
+
+export function isLegacyDelegatedRoutine(job: RoutineJob | null | undefined): boolean {
+  const preview = typeof job?.prompt_preview === 'string' ? job.prompt_preview : job?.prompt
+
+  return Boolean(routineBot(job) && typeof preview === 'string' && preview.startsWith(LEGACY_DELEGATED_ROUTINE_PREFIX))
+}
+
+export async function loadRoutines(owner: RoutineOwner): Promise<RoutineListResult> {
+  const bot =
+    typeof owner === 'string'
+      ? {
+          name: owner
+        }
+      : owner
+
+  const profile = String(bot?.name || '').trim()
+
+  // profile scopes cron.manage to that bot's own cron store (core RPC gained an
+  // optional `profile` param). Older gateways ignore the unknown param and
+  // return the launch-profile store — the [bot:] tag filter in selectRoutineJobs
+  // remains the graceful fallback there.
+  const scope = profile
+    ? {
+        profile
+      }
+    : {}
+
+  const data = (await requestForBot(bot, 'cron.manage', {
+    action: 'list',
+    include_disabled: true,
+    ...scope
+  })) as RoutineListResult
+
+  const jobs = Array.isArray(data?.jobs) ? data.jobs : []
+
+  const activeLegacyJobs = jobs.filter(
+    job => isLegacyDelegatedRoutine(job) && job.enabled !== false && job.state !== 'paused'
+  )
+
+  // A pause failing must not fail the LIST — the pane would report "could
+  // not load cronjobs" over data that loaded fine, and the 20s poll would
+  // re-attempt the failing pause inside a failing query forever. Each pause
+  // swallows its own error; the overlay only claims jobs the gateway
+  // actually paused, and the next poll retries the rest.
+  const pauses = await Promise.all(
+    activeLegacyJobs.map(job =>
+      requestForBot(bot, 'cron.manage', {
+        action: 'pause',
+        name: job.job_id,
+        ...scope
+      })
+        .then(() => true)
+        .catch(() => false)
+    )
+  )
+
+  if (!activeLegacyJobs.length) {
+    return data
+  }
+
+  const pausedIds = new Set(activeLegacyJobs.filter((job, index) => pauses[index]).map(job => job.job_id))
+
+  return {
+    ...data,
+    jobs: jobs.map(job =>
+      pausedIds.has(job.job_id)
+        ? {
+            ...job,
+            enabled: false,
+            state: 'paused'
+          }
+        : job
+    )
+  }
+}
+
+function useRoutines(owner: RoutineOwner) {
+  const bot =
+    typeof owner === 'string'
+      ? {
+          name: owner
+        }
+      : owner
+
+  const route = botConnectionRoute(bot)
+  const key = route ? botRosterKey(bot) : bot?.name || ''
+
+  return useQuery({
+    queryKey: [...ROUTINES_KEY, key],
+    queryFn: () => loadRoutines(bot),
+    enabled: Boolean(bot?.name),
+    refetchInterval: 20000,
+    staleTime: 8000
+  })
+}
+
+/** `activeBot` is always a non-empty profile name, so the result is never
+ *  nullish even when no create-owner has been captured yet. */
+export function routineCreateTarget(owner: RoutineOwner, activeBot: string): RosterRow | string {
+  return owner || activeBot
+}
+
+export async function invalidateRoutineOwner(owner: RoutineOwner) {
+  const bot =
+    typeof owner === 'string'
+      ? {
+          name: owner
+        }
+      : owner
+
+  const route = botConnectionRoute(bot)
+  const key = route ? botRosterKey(bot) : bot?.name || ''
+  await queryClient.invalidateQueries({
+    queryKey: [...ROUTINES_KEY, key],
+    exact: true
+  })
+}
+
+/** Pick which cron jobs to show. A failed refresh keeps the last good list. */
+export function selectRoutineJobs(
+  data: RoutineListResult | undefined,
+  error: unknown,
+  lastJobs: RoutineJob[],
+  bot: string
+) {
+  const live = Array.isArray(data?.jobs) ? data.jobs : null
+  const all = live ?? (error ? lastJobs : [])
+  const scopedToBot = normalizedProfileName(data?.scoped) === normalizedProfileName(bot)
+
+  return {
+    live,
+    all,
+    jobs: scopedToBot ? all : all.filter(job => (routineBot(job) || 'default') === bot)
+  }
+}
+
+/**
+ * Why the Routines pane can be empty while the bot's cron store has jobs.
+ *
+ * On older gateways the pane only shows jobs namespaced `[bot:<name>]` for the
+ * active bot (plus untagged legacy jobs on the default bot). When jobs exist in
+ * the store but none surface for this bot, the user is left staring at the
+ * generic empty state with no hint that cronjobs are present but hidden.
+ * Return a short explanation string in that case, or null when the store is
+ * genuinely empty (or the active bot's jobs are already shown).
+ */
+export function routineFilterHint(all: RoutineJob[], jobs: RoutineJob[]): null | string {
+  if (jobs.length !== 0 || !Array.isArray(all) || all.length === 0) {
+    return null
+  }
+
+  return botsText().cron.filterHint
+}
+
+export function normalizedProfileName(profile: unknown): string {
+  return typeof profile === 'string' ? profile.trim().toLowerCase() : ''
+}
+
+function shellQuote(value: unknown): string {
+  return `'${String(value).replaceAll("'", "'\"'\"'")}'`
+}
+
+export function routineInputError(title: string, instruction: string): null | string {
+  if (String(title).includes('\0')) {
+    return 'Job name cannot contain NUL (U+0000).'
+  }
+
+  if (String(instruction).includes('\0')) {
+    return 'Job instruction cannot contain NUL (U+0000).'
+  }
+
+  return null
+}
+
+export function routinePrompt(
+  bot: string | undefined,
+  title: string,
+  instruction: string,
+  activeProfile: string
+): string {
+  if (normalizedProfileName(bot) && normalizedProfileName(bot) === normalizedProfileName(activeProfile)) {
+    return instruction
+  }
+
+  return (
+    `${SAFE_ROUTINE_MARKER}You are running the scheduled routine "${title}" for agent '${bot}'. ` +
+    `Execute it AS that agent so the run lands in its own history: run this in the terminal and relay the output:\n\n` +
+    `hermes -p ${shellQuote(bot)} chat -c ${shellQuote(`Routine: ${title}`)} -q ${shellQuote(`[Scheduled routine] ${instruction}`)}\n\n` +
+    `If the command fails, report the error instead.`
+  )
+}
+
+function scheduleLabel(schedule: string | undefined): string {
+  const c = botsText().cron
+  const once = /^once in (.+)$/.exec(schedule || '')
+
+  if (once) {
+    return c.onceIn(once[1])
+  }
+
+  const bare = /^(\d+)([mhd])$/.exec(schedule || '')
+
+  if (bare) {
+    return c.onceIn(`${bare[1]}${bare[2]}`)
+  }
+
+  const match = /^every (\d+)m$/.exec(schedule || '')
+
+  if (match) {
+    const minutes = Number(match[1])
+
+    if (minutes % 1440 === 0) {
+      const d = minutes / 1440
+
+      // Daily/Hourly are core's own schedule vocabulary — reuse, don't retranslate.
+      return d === 1 ? translateNow('cron.scheduleLabels.daily') : c.everyNDays(d)
+    }
+
+    if (minutes % 60 === 0) {
+      const h = minutes / 60
+
+      return h === 1 ? translateNow('cron.scheduleLabels.hourly') : c.everyNHours(h)
+    }
+
+    return c.everyNMinutes(minutes)
+  }
+
+  return schedule || ''
+}
+
+/** Absolute + relative rendering of a cron timestamp, or null when the job
+ *  has never carried one (a job that has not run yet has no `last_run_at`). */
+function routineTimestamp(value: string | undefined): null | string {
+  const ms = value ? new Date(value).getTime() : Number.NaN
+
+  return Number.isFinite(ms) ? `${relativeTime(ms)} · ${new Date(ms).toLocaleString()}` : null
+}
+
+/** The facts `cron.manage list` already sends with every job, as label/value
+ *  rows. Pure so the detail contract is testable without a renderer, and so
+ *  the dialog cannot invent a field the gateway never sent: an absent value
+ *  drops its row instead of rendering "undefined". */
+export function routineDetailRows(job: RoutineJob | null | undefined): Array<{ label: string; value: string }> {
+  const paused = job?.enabled === false || job?.state === 'paused'
+  const label = scheduleLabel(job?.schedule)
+  const raw = String(job?.schedule || '').trim()
+
+  // Cells are `number | string | null | undefined` until the filter below
+  // drops the non-strings; a destructured, non-predicate callback can't carry
+  // that narrowing into the map, so the rows are typed as filtered.
+  return (
+    [
+      ['Status', paused ? 'Paused' : 'Active'],
+      ['Schedule', label],
+      // `scheduleLabel` humanizes "every 1440m" and cron expressions; keep the
+      // raw string when it says something the label dropped.
+      ['Schedule (raw)', raw && raw !== label ? raw : null],
+      ['Repeat', job?.repeat],
+      ['Next run', paused ? null : routineTimestamp(job?.next_run_at)],
+      ['Last run', routineTimestamp(job?.last_run_at)],
+      ['Last result', job?.last_status],
+      ['Delivers to', job?.deliver],
+      ['Model', job?.model],
+      ['Working directory', job?.workdir]
+    ] as Array<[string, string]>
+  )
+    .filter(([, value]) => typeof value === 'string' && value.trim())
+    .map(([name, value]) => ({
+      label: name,
+      value: value.trim()
+    }))
+}
+
+/** Why a job is not doing what the user expects. The row only ever showed
+ *  "paused"; the scheduler's own reason and the last fire/delivery failures
+ *  had no surface in Bot Mode at all. */
+export function routineDetailIssue(job: RoutineJob | null | undefined): null | string {
+  const reasons = [job?.last_fire_error, job?.last_delivery_error, job?.paused_reason]
+  const first = reasons.find(value => typeof value === 'string' && value.trim())
+
+  return first ? first.trim() : null
+}
+
+interface RoutineDetailDialogProps {
+  job: RoutineJob | null
+  onClose: () => void
+  open: boolean
+}
+
+/** Read-only inspector for one cronjob, rendered from the list payload the
+ *  pane already holds — no extra RPC, and no second mutation path beside the
+ *  row's own switch and delete. */
+export function RoutineDetailDialog({ job, onClose, open }: RoutineDetailDialogProps) {
+  const b = useBots()
+  const { t } = useI18n()
+  const rows = job ? routineDetailRows(job) : []
+  const issue = job ? routineDetailIssue(job) : null
+  const instruction = String(job?.prompt_preview || '').trim()
+
+  return (
+    <Dialog
+      onOpenChange={value => {
+        if (!value) {
+          onClose()
+        }
+      }}
+      open={Boolean(open && job)}
+    >
+      <DialogContent className="max-w-md">
+        <DialogHeader>
+          <DialogTitle className="truncate">{routineTitle(job)}</DialogTitle>
+          <DialogDescription>What this job runs, and when it runs next.</DialogDescription>
+        </DialogHeader>
+        <div className="grid gap-3.5">
+          {issue ? (
+            <div className="rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs leading-5 text-(--ui-accent)">
+              {issue}
+            </div>
+          ) : null}
+          <div className="grid gap-1.5">
+            {rows.map(row => (
+              <div className="flex items-baseline justify-between gap-3 text-xs" key={row.label}>
+                <span className="shrink-0 text-(--ui-text-tertiary)">{row.label}</span>
+                <span className="min-w-0 truncate text-right">{row.value}</span>
+              </div>
+            ))}
+          </div>
+          {instruction
+            ? labeled(
+                b.cron.instruction,
+                <div className="max-h-48 overflow-y-auto whitespace-pre-wrap break-words rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs leading-5 text-(--ui-text-secondary)">
+                  {instruction}
+                </div>
+              )
+            : null}
+        </div>
+        <DialogFooter>
+          <Button onClick={onClose} variant="secondary">
+            {t.common.close}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+interface RoutineRowProps {
+  job: RoutineJob
+  onOpen?: (job: RoutineJob) => void
+  /** The pane only renders rows once it has resolved an exact roster row, so
+   *  this never sees the bare-name arm of RoutineOwner. */
+  owner: RosterRow
+}
+
+export function RoutineRow({ job, onOpen, owner }: RoutineRowProps) {
+  const { t } = useI18n()
+  const c = t.cron
+  const profile = typeof owner === 'string' ? owner : owner?.name
+  const [busy, setBusy] = useState(false)
+  // Optimistic overlay: null = trust server state. Set immediately on
+  // toggle so the switch responds even before the refetch lands.
+  const [pendingActive, setPendingActive] = useState<boolean | null>(null)
+  const legacyUnsafe = isLegacyDelegatedRoutine(job)
+  const serverActive = !legacyUnsafe && job.enabled !== false && job.state !== 'paused'
+  const active = pendingActive === null ? serverActive : pendingActive
+
+  if (pendingActive !== null && pendingActive === serverActive) {
+    setPendingActive(null) // server caught up
+  }
+
+  const act = async (action: 'pause' | 'remove' | 'resume') => {
+    if (busy) {
+      return
+    }
+
+    setBusy(true)
+
+    if (action === 'pause' || action === 'resume') {
+      setPendingActive(action === 'resume')
+    }
+
+    try {
+      await requestForBot(owner, 'cron.manage', {
+        action,
+        name: job.job_id,
+        ...(profile
+          ? {
+              profile
+            }
+          : {})
+      })
+      await invalidateRoutineOwner(owner)
+    } catch (err) {
+      setPendingActive(null)
+      host.notifyError(err, c.failedUpdate)
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  return (
+    <div
+      className={cn(
+        'group grid gap-1.5 rounded-lg border border-(--ui-stroke-secondary) p-2.5 transition-colors',
+        'hover:border-(--ui-stroke-primary, var(--ui-stroke-secondary))'
+      )}
+    >
+      <div className="flex items-center gap-2">
+        {/* The row's own button, not a click handler on the card: the switch */
+        /* and delete control are siblings, so opening the details can never */
+        /* swallow a toggle (and a nested button would be invalid markup). */}
+        <RowButton
+          className="flex min-w-0 flex-1 items-center gap-2 text-left transition-colors hover:text-foreground"
+          onClick={() => onOpen?.(job)}
+          title={c.manage}
+        >
+          {/* `--ui-success` rather than a literal emerald: the token is rotated
+              toward the accent, so a column of active dots can't fight the
+              theme — the same reason the session status dots use it. */}
+          <span
+            aria-hidden
+            className={cn('size-1.5 shrink-0 rounded-full', active ? 'bg-(--ui-success)' : 'bg-(--ui-text-quaternary)')}
+          />
+          <span className={cn('min-w-0 flex-1 truncate text-xs font-medium', !active && 'text-(--ui-text-tertiary)')}>
+            {routineTitle(job)}
+          </span>
+        </RowButton>
+        <Switch
+          checked={active}
+          disabled={busy || legacyUnsafe}
+          onCheckedChange={value => act(value ? 'resume' : 'pause')}
+        />
+        <Tip label={t.common.delete}>
+          <Button
+            aria-label={t.common.delete}
+            className="opacity-0 transition-opacity group-hover:opacity-100"
+            disabled={busy}
+            onClick={() => act('remove')}
+            size="icon-xs"
+            variant="ghost"
+          >
+            <Codicon name="trash" />
+          </Button>
+        </Tip>
+      </div>
+      <div className="flex items-center justify-between gap-2 pl-3.5">
+        <span className="inline-flex items-center gap-1 rounded-full border border-(--ui-stroke-secondary) px-1.5 py-0.5 text-[0.65rem] text-(--ui-text-tertiary)">
+          <Codicon className="text-[0.7rem]" name="calendar" />
+          {scheduleLabel(job.schedule)}
+        </span>
+        <span className="truncate text-[0.65rem] text-(--ui-text-quaternary)">
+          {active && job.next_run_at
+            ? `${c.next} ${relativeTime(new Date(job.next_run_at).getTime())}`
+            : c.states.paused}
+        </span>
+      </div>
+      {legacyUnsafe ? (
+        <div className="rounded-md border border-(--ui-stroke-secondary) px-2 py-1.5 text-[0.65rem] leading-4 text-(--ui-accent)">
+          Paused for security: delete and recreate this legacy job before running it again.
+        </div>
+      ) : null}
+    </div>
+  )
+}
+
+// Structured schedule picker: frequency first, then only the detail that
+// frequency needs (time of day, weekday, day of month, interval). Emits a
+// Hermes-native schedule string; Advanced exposes it raw.
+type ScheduleFreq = 'once' | 'hourly' | 'daily' | 'weekdays' | 'weekly' | 'monthly' | 'interval' | 'advanced'
+
+/** Picker form state. Every detail field stays a string: they are edited as
+ *  raw `Input` text and only coerced when the schedule string is composed. */
+interface ScheduleState {
+  freq: ScheduleFreq
+  intervalN: string
+  intervalUnit: string
+  monthday: string
+  onceN: string
+  onceUnit: string
+  raw: string
+  repeatN: string
+  time: string
+  weekday: string
+}
+
+/** Built per call, not frozen at module load: the labels are translated, and
+ *  a module const would pin whichever locale happened to be active at import. */
+function frequencies(): Array<{ id: ScheduleFreq; label: string }> {
+  const c = botsText().cron
+
+  return [
+    { id: 'once', label: c.freqOnce },
+    { id: 'hourly', label: c.freqHourly },
+    { id: 'daily', label: c.freqDaily },
+    { id: 'weekdays', label: c.freqWeekdays },
+    { id: 'weekly', label: c.freqWeekly },
+    { id: 'monthly', label: c.freqMonthly },
+    { id: 'interval', label: c.freqInterval },
+    { id: 'advanced', label: c.freqAdvanced }
+  ]
+}
+
+/** Weekday names come from core's cron section — it already ships them in
+ *  every locale, keyed by the same cron day numbers. */
+function weekdays(): Array<{ id: string; label: string }> {
+  return ['1', '2', '3', '4', '5', '6', '0'].map(id => ({ id, label: translateNow(`cron.days.${id}`) }))
+}
+
+const TIMES = (() => {
+  const out = []
+
+  for (let h = 0; h < 24; h++) {
+    for (const m of [0, 30]) {
+      const ampm = h < 12 ? 'AM' : 'PM'
+      const h12 = h % 12 === 0 ? 12 : h % 12
+      out.push({
+        id: `${h}:${m}`,
+        label: `${h12}:${String(m).padStart(2, '0')} ${ampm}`,
+        h,
+        m
+      })
+    }
+  }
+
+  return out
+})()
+
+/** Compose the Hermes schedule string from picker state. */
+function composeSchedule(state: ScheduleState): string {
+  const [h, m] = (state.time || '9:0').split(':').map(Number)
+
+  switch (state.freq) {
+    case 'once': {
+      const n = Math.max(1, parseInt(state.onceN, 10) || 1)
+
+      return `${n}${state.onceUnit || 'h'}`
+    }
+
+    case 'hourly':
+      return 'every 1h'
+
+    case 'daily':
+      return `${m} ${h} * * *`
+
+    case 'weekdays':
+      return `${m} ${h} * * 1-5`
+
+    case 'weekly':
+      return `${m} ${h} * * ${state.weekday || '1'}`
+
+    case 'monthly':
+      return `${m} ${h} ${state.monthday || '1'} * *`
+    case 'interval': {
+      const n = Math.max(1, parseInt(state.intervalN, 10) || 1)
+
+      return `every ${n}${state.intervalUnit || 'h'}`
+    }
+
+    default:
+      return state.raw || ''
+  }
+}
+
+function scheduleSummary(state: ScheduleState): string {
+  const c = botsText().cron
+  const t = TIMES.find(x => x.id === state.time)
+  const tl = t ? t.label : '9:00 AM'
+  const unitWord = (u: string) => (u === 'm' ? c.unitMinutes : u === 'd' ? c.unitDays : c.unitHours)
+
+  const cap =
+    state.freq !== 'once' && String(state.repeatN || '').trim()
+      ? c.timesTotal(Math.max(1, parseInt(state.repeatN, 10) || 1))
+      : ''
+
+  switch (state.freq) {
+    case 'once':
+      return c.runsOnce(Math.max(1, parseInt(state.onceN, 10) || 1), unitWord(state.onceUnit))
+
+    case 'hourly':
+      return c.runsHourly + cap
+
+    case 'daily':
+      return c.runsDaily(tl) + cap
+
+    case 'weekdays':
+      return c.runsWeekdays(tl) + cap
+    case 'weekly': {
+      const days = weekdays()
+
+      return c.runsWeekly((days.find(w => w.id === state.weekday) || days[0]).label, tl) + cap
+    }
+
+    case 'monthly':
+      return c.runsMonthly(state.monthday || '1', tl) + cap
+
+    case 'interval':
+      return c.runsInterval(Math.max(1, parseInt(state.intervalN, 10) || 1), unitWord(state.intervalUnit)) + cap
+
+    default:
+      return c.runsRaw
+  }
+}
+
+function pickerSelect<T extends string>(
+  value: T,
+  onChange: (value: T) => void,
+  options: Array<{ id: T; label: string }>
+) {
+  return (
+    <Select onValueChange={onChange} value={value}>
+      <SelectTrigger className="h-8 rounded-md">
+        <SelectValue />
+      </SelectTrigger>
+      <SelectContent>
+        {options.map(o => (
+          <SelectItem key={o.id} value={o.id}>
+            {o.label}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  )
+}
+
+interface SchedulePickerProps {
+  setState: React.Dispatch<React.SetStateAction<ScheduleState>>
+  state: ScheduleState
+}
+
+function SchedulePicker({ state, setState }: SchedulePickerProps) {
+  const b = useBots()
+
+  const upd = (patch: Partial<ScheduleState>) =>
+    setState(prev => ({
+      ...prev,
+      ...patch
+    }))
+
+  const needsTime = ['daily', 'weekdays', 'weekly', 'monthly'].includes(state.freq)
+
+  return (
+    <div className="grid gap-2">
+      <div className={cn('grid gap-2', needsTime ? 'grid-cols-2' : 'grid-cols-1')}>
+        {pickerSelect(
+          state.freq,
+          v =>
+            upd({
+              freq: v
+            }),
+          frequencies()
+        )}
+        {needsTime
+          ? pickerSelect(
+              state.time,
+              v =>
+                upd({
+                  time: v
+                }),
+              TIMES
+            )
+          : null}
+      </div>
+      {state.freq === 'once' ? (
+        <div className="grid grid-cols-2 gap-2">
+          <Input
+            className="h-8"
+            onChange={event =>
+              upd({
+                onceN: event.target.value.replace(/[^0-9]/g, '').slice(0, 4)
+              })
+            }
+            placeholder="30"
+            value={state.onceN}
+          />
+          {pickerSelect(
+            state.onceUnit,
+            v =>
+              upd({
+                onceUnit: v
+              }),
+            [
+              {
+                id: 'm',
+                label: 'minutes from now'
+              },
+              {
+                id: 'h',
+                label: 'hours from now'
+              },
+              {
+                id: 'd',
+                label: 'days from now'
+              }
+            ]
+          )}
+        </div>
+      ) : null}
+      {state.freq === 'weekly'
+        ? pickerSelect(
+            state.weekday,
+            v =>
+              upd({
+                weekday: v
+              }),
+            weekdays()
+          )
+        : null}
+      {state.freq === 'monthly'
+        ? labeled(
+            b.cron.dayOfMonth,
+            <Input
+              className="h-8"
+              onChange={event =>
+                upd({
+                  monthday: event.target.value.replace(/[^0-9]/g, '').slice(0, 2)
+                })
+              }
+              placeholder="1"
+              value={state.monthday}
+            />
+          )
+        : null}
+      {state.freq === 'interval' ? (
+        <div className="grid grid-cols-2 gap-2">
+          <Input
+            className="h-8"
+            onChange={event =>
+              upd({
+                intervalN: event.target.value.replace(/[^0-9]/g, '').slice(0, 4)
+              })
+            }
+            placeholder="2"
+            value={state.intervalN}
+          />
+          {pickerSelect(
+            state.intervalUnit,
+            v =>
+              upd({
+                intervalUnit: v
+              }),
+            [
+              {
+                id: 'm',
+                label: 'minutes'
+              },
+              {
+                id: 'h',
+                label: 'hours'
+              },
+              {
+                id: 'd',
+                label: 'days'
+              }
+            ]
+          )}
+        </div>
+      ) : null}
+      {state.freq === 'advanced' ? (
+        <Input
+          className="h-8 font-mono text-xs"
+          onChange={event =>
+            upd({
+              raw: event.target.value
+            })
+          }
+          placeholder="every 1d · every 2h · 0 9 * * * (cron)"
+          value={state.raw}
+        />
+      ) : null}
+      {state.freq !== 'once' && state.freq !== 'advanced' ? (
+        <div className="flex items-center gap-2">
+          <span className="text-xs text-(--ui-text-tertiary)">Stop after</span>
+          <Input
+            className="h-7 w-16 text-xs"
+            onChange={event =>
+              upd({
+                repeatN: event.target.value.replace(/[^0-9]/g, '').slice(0, 4)
+              })
+            }
+            placeholder="∞"
+            value={state.repeatN}
+          />
+          <span className="text-xs text-(--ui-text-tertiary)">runs (blank = forever)</span>
+        </div>
+      ) : null}
+      <div className="text-[0.65rem] text-(--ui-text-quaternary)">{`${scheduleSummary(state)} \u00b7 ${composeSchedule(state) || '\u2014'}`}</div>
+    </div>
+  )
+}
+
+function defaultScheduleState(): ScheduleState {
+  return {
+    freq: 'daily',
+    time: '9:0',
+    weekday: '1',
+    monthday: '1',
+    intervalN: '2',
+    intervalUnit: 'h',
+    onceN: '30',
+    onceUnit: 'm',
+    repeatN: '',
+    raw: ''
+  }
+}
+
+interface CreateRoutineDialogProps {
+  /** Never nullish: the pane early-returns its empty state before it renders
+   *  this dialog, so `createTarget` has already fallen back to the active
+   *  profile name — which is the bare-name arm, normalized to a row on entry. */
+  bot: RosterRow | string
+  onClose: () => void
+  open: boolean
+}
+
+export function CreateRoutineDialog({ bot, open, onClose }: CreateRoutineDialogProps) {
+  const b = useBots()
+  const { t } = useI18n()
+  const c = t.cron
+  const [name, setName] = useState('')
+  const [instruction, setInstruction] = useState('')
+  const [sched, setSched] = useState(defaultScheduleState())
+  const [continuity, setContinuity] = useState(false)
+  // Where the run's output lands: 'history' = the run session only (Run
+  // history / cron page, today's behavior); 'bot-chat' = inject into this
+  // bot's canonical Bot Chat as a real message — the bot reads it, acts on
+  // it, and responds there (costs the bot one agent turn per run).
+  const [target, setTarget] = useState('history')
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState<null | string>(null)
+  const activeProfile = useValue(host.state.profile)
+  // Normalize the bare-name arm to a row once, the way loadRoutines /
+  // useRoutines / invalidateRoutineOwner already do. Everything below reads
+  // `owner.name` — on a raw string those reads are undefined, which silently
+  // costs the dialog its title and costs requestForBot its route.
+  const owner: RosterRow = typeof bot === 'string' ? { name: bot } : bot
+  const profile = owner.name
+  const schedule = composeSchedule(sched)
+
+  const reset = () => {
+    setName('')
+    setInstruction('')
+    setSched(defaultScheduleState())
+    setContinuity(false)
+    setTarget('history')
+    setBusy(false)
+    setError(null)
+  }
+
+  const submit = async () => {
+    const title = name.trim()
+    const task = instruction.trim()
+    const inputError = routineInputError(title, task)
+
+    if (inputError) {
+      setError(inputError)
+
+      return
+    }
+
+    if (!title || !task || !schedule.trim() || busy) {
+      return
+    }
+
+    setBusy(true)
+    setError(null)
+
+    try {
+      const repeatN =
+        sched.freq !== 'once' && sched.freq !== 'advanced' && String(sched.repeatN || '').trim()
+          ? Math.max(1, parseInt(sched.repeatN, 10) || 1)
+          : null
+
+      await requestForBot(owner, 'cron.manage', {
+        action: 'add',
+        name: `[bot:${profile}] ${title}`,
+        schedule: schedule.trim(),
+        prompt: routinePrompt(profile, title, task, activeProfile),
+        ...(profile
+          ? {
+              profile
+            }
+          : {}),
+        ...(repeatN
+          ? {
+              repeat: repeatN
+            }
+          : {}),
+        ...(continuity
+          ? {
+              continuity: true
+            }
+          : {}),
+        // 'bot-chat' (bare, no name): the job is created IN the bot's own
+        // cron store (profile scoping above), so the scheduler resolves the
+        // token to that profile — no cross-gateway name ambiguity possible.
+        ...(target === 'bot-chat'
+          ? {
+              deliver: 'bot-chat'
+            }
+          : {})
+      })
+      await invalidateRoutineOwner(owner)
+      host.notify({
+        kind: 'success',
+        message: `${c.created}: ${title}`
+      })
+      reset()
+      onClose()
+    } catch (err) {
+      setBusy(false)
+      setError(err instanceof Error ? err.message : String(err))
+    }
+  }
+
+  const ownerLabel = displayName(owner, botRosterMeta(owner, $botMeta.get()))
+
+  return (
+    <Dialog
+      onOpenChange={value => {
+        if (!value && !busy) {
+          reset()
+          onClose()
+        }
+      }}
+      open={open}
+    >
+      <DialogContent className="max-w-md">
+        <DialogHeader>
+          <DialogTitle>{c.createTitle}</DialogTitle>
+          <DialogDescription>{b.cron.createDesc(ownerLabel)}</DialogDescription>
+        </DialogHeader>
+        <div className="grid gap-3.5">
+          {labeled(
+            c.nameLabel,
+            <Input
+              autoFocus
+              onChange={event => setName(event.target.value)}
+              placeholder={c.namePlaceholder}
+              value={name}
+            />
+          )}
+          {labeled(
+            c.promptLabel,
+            <Textarea
+              className="min-h-20"
+              onChange={event => setInstruction(event.target.value)}
+              placeholder={c.promptPlaceholder}
+              value={instruction}
+            />
+          )}
+          {labeled(b.cron.whenToRun, <SchedulePicker setState={setSched} state={sched} />)}
+          {labeled(
+            b.cron.sendResultsTo,
+            pickerSelect(target, setTarget, [
+              {
+                id: 'history',
+                label: b.cron.runHistoryOnly
+              },
+              {
+                id: 'bot-chat',
+                label: b.cron.botChatTarget(ownerLabel)
+              }
+            ])
+          )}
+          <label className="flex items-center gap-2 text-xs text-(--ui-text-tertiary) cursor-pointer select-none">
+            <Checkbox checked={continuity} onCheckedChange={value => setContinuity(Boolean(value))} />
+            {b.cron.continuity}
+          </label>
+          {error ? (
+            <div className="rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs text-(--ui-accent)">
+              {error}
+            </div>
+          ) : null}
+        </div>
+        <DialogFooter>
+          <Button
+            disabled={busy}
+            onClick={() => {
+              reset()
+              onClose()
+            }}
+            variant="ghost"
+          >
+            {t.common.cancel}
+          </Button>
+          <Button disabled={busy || !name.trim() || !instruction.trim() || !schedule.trim()} onClick={submit}>
+            {busy ? t.common.saving : c.createAction}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+interface ProfileSyncOwnerRow {
+  connectionId?: string
+  profile?: string
+}
+
+/** `$focusedBotOwner`: the SDK atom on newer desktops, the synthesized
+ *  profile-only fallback on older ones. */
+interface ProfileSyncStore {
+  get?: () => ProfileSyncOwnerRow | null | string | undefined
+  listen: (listener: (owner: ProfileSyncOwnerRow | null | string | undefined) => void) => () => void
+}
+
+/** Keeps $selectedBot in sync with the focused chat's owner profile.
+ *  nanostores' `.listen()` never replays the current value the way
+ *  `.subscribe()` does, so a disable → profile switch → re-enable sequence
+ *  would otherwise leave $selectedBot pointed at whichever bot was active
+ *  before the plugin was disabled — reseeding here on every register() call
+ *  closes that gap. Connection qualification keeps same-named owners isolated.
+ *  Returns the unbind function for ctx.onDispose. */
+export function bindProfileSync(ownerStore: ProfileSyncStore) {
+  const sync = (owner: ProfileSyncOwnerRow | null | string | undefined) => {
+    const profile = typeof owner === 'string' ? owner : owner?.profile
+
+    if (!profile || typeof profile !== 'string') {
+      return
+    }
+
+    const connectionId = String(typeof owner === 'object' ? owner?.connectionId || '' : '').trim()
+    $selectedBot.set(connectionId ? `${connectionId}::${profile}` : profile)
+  }
+
+  sync(ownerStore.get?.())
+
+  return ownerStore.listen(sync)
+}
+
+export function resolveRoutineOwner(
+  roster: RosterRow[],
+  focusedOwner: { authoritative?: boolean; connectionId?: string; name: string } | null,
+  selected: string
+): RosterRow | null {
+  // A null focused owner is NOT a failure: the SDK fails closed to null
+  // whenever the focused session has no unique bot owner (a normal chat,
+  // ambiguous owner hints) — the common case while the user browses the
+  // Bots pane. Fall through to the roster-clicked bot (the previously
+  // working scope) instead of dead-ending the pane on the unavailable
+  // placeholder for every agent (#94516).
+  const selectedBot = roster.find(bot => botSelectionKey(bot) === selected)
+  const focusedBot = focusedOwner ? roster.find(bot => isActiveRosterBot(bot, focusedOwner)) : null
+
+  if (focusedOwner?.authoritative) {
+    // An authoritative focused owner wins, but only through its exact roster
+    // row. If that row is absent, fail closed instead of routing cron
+    // reads/mutations through a stale selection or an unscoped profile name.
+    return focusedBot || null
+  }
+
+  return (
+    focusedBot ||
+    selectedBot ||
+    (focusedOwner
+      ? {
+          name: focusedOwner.name
+        }
+      : null)
+  )
+}
+
+export function RoutinesPane() {
+  const selected = useValue($selectedBot)
+  const focusedOwner = focusedRosterOwner(useValue($focusedBotOwner))
+  // Subscribe instead of a bare read: BotsPane owns the roster fetch and
+  // can hydrate (or replace) rows after this pane mounted, so a .get()
+  // snapshot captured while the roster was still empty pinned the pane on
+  // "unavailable" until some unrelated atom happened to re-render it (#94483).
+  // A complete focused owner is still authoritative. If its exact roster row
+  // is absent, fail closed rather than routing cron reads/mutations through a
+  // stale selection or an unscoped profile name.
+  const owner = resolveRoutineOwner(useValue($lastRoster), focusedOwner, selected)
+  const bot = String(owner?.name || focusedOwner?.name || 'default').trim() || 'default'
+  const allMeta = useValue($botMeta)
+  const meta = owner ? botRosterMeta(owner, allMeta) : null
+  const { shape, color, image } = botAppearance(bot, meta)
+  const { data, error, isLoading, refetch } = useRoutines(owner)
+  const b = useBots()
+  const { t } = useI18n()
+  const c = t.cron
+  const [createOpen, setCreateOpen] = useState(false)
+  const [createOwner, setCreateOwner] = useState<RosterRow | null>(null)
+  // Hold the id, not the record: the 20s poll replaces every job object, and
+  // an open inspector must follow the live row (next run, pause, last error)
+  // instead of freezing the snapshot that was on screen when it opened.
+  const [detailJobId, setDetailJobId] = useState<null | string>(null)
+  const createTarget = owner ? routineCreateTarget(createOwner, bot) : null
+
+  const openCreate = () => {
+    if (!owner) {
+      return
+    }
+
+    setCreateOwner(owner)
+    setCreateOpen(true)
+  }
+
+  if (!owner) {
+    return <PanelEmpty description={b.cron.needsRosterFirst} icon="hubot" title={c.title} />
+  }
+
+  const view = selectRoutineJobs(data, error, $lastJobs.get(), bot)
+
+  if (view.live) {
+    $lastJobs.set(view.live)
+  }
+
+  const jobs = view.jobs
+  const detailJob = detailJobId ? jobs.find(job => job.job_id === detailJobId) || null : null
+
+  const staleNotice = error && !view.live && view.all.length ? b.cron.staleNotice : null
+
+  const filterHint = routineFilterHint(view.all, jobs)
+
+  return (
+    <div className="flex h-full flex-col">
+      <div className="flex items-center gap-2 px-3 pt-3 pb-2">
+        <BotFace color={avatarColor(color, bot)} image={image} name={bot} shape={shape} size={22} />
+        <div className="min-w-0 flex-1">
+          <div className="flex min-w-0 items-baseline gap-1.5 truncate">
+            <div className="truncate text-xs font-semibold">
+              {displayName(
+                {
+                  name: bot
+                },
+                meta
+              )}
+            </div>
+            {showsHandle(bot, meta) ? (
+              <span className="shrink-0 font-mono text-[0.65rem] text-(--ui-text-quaternary)">{`@${botHandle(bot)}`}</span>
+            ) : null}
+          </div>
+          <div className="text-[0.65rem] uppercase tracking-wider text-(--ui-text-quaternary)">{c.title}</div>
+        </div>
+        <Tip label={c.newCron}>
+          <Button aria-label={c.newCron} onClick={openCreate} size="icon-xs" variant="ghost">
+            <Codicon name="add" />
+          </Button>
+        </Tip>
+      </div>
+      <div className="mx-3 border-t border-(--ui-stroke-secondary)" />
+      {staleNotice ? (
+        <div className="mx-3 mt-2 rounded-md bg-(--chrome-action-hover) px-2 py-1.5 text-[0.6875rem] text-(--ui-text-tertiary)">
+          {staleNotice}
+        </div>
+      ) : null}
+      {isLoading && !view.all.length ? (
+        <div className="flex flex-1 items-center justify-center">
+          <GlyphSpinner className="text-(--ui-text-tertiary)" spinner="breathe" />
+        </div>
+      ) : error && !view.all.length ? (
+        <PanelEmpty
+          action={
+            <Button onClick={() => void refetch()} size="sm" variant="secondary">
+              {t.common.retry}
+            </Button>
+          }
+          description={b.cron.readFailure}
+          icon="warning"
+          title={c.failedLoad}
+        />
+      ) : jobs.length === 0 ? (
+        // `filterHint` is the informative case (jobs exist on the profile but
+        // none are tagged for this bot), so it wins the description slot.
+        <PanelEmpty
+          action={
+            <Button onClick={openCreate} size="sm">
+              {c.newCron}
+            </Button>
+          }
+          description={filterHint || c.emptyDescNew}
+          icon="watch"
+          title={c.emptyTitleNew}
+        />
+      ) : (
+        <div className="min-h-0 flex-1 overflow-y-auto overscroll-contain">
+          <div className="grid gap-1.5 px-2.5 py-2">
+            {jobs.map(job => (
+              <RoutineRow job={job} key={job.job_id} onOpen={opened => setDetailJobId(opened.job_id)} owner={owner} />
+            ))}
+          </div>
+        </div>
+      )}
+      <RoutineDetailDialog job={detailJob} onClose={() => setDetailJobId(null)} open={Boolean(detailJob)} />
+      <CreateRoutineDialog
+        // Non-null past the `!owner` early return above: `routineCreateTarget`
+        // falls back to the active profile name.
+        bot={createTarget!}
+        // TODO(bot-mode-types): `createTarget` is a roster row whenever a create
+        // owner is set, so this key stringifies to "[object Object]" instead of
+        // identifying the target bot. Cast to keep the as-written behavior.
+        key={createTarget as string}
+        onClose={() => {
+          setCreateOpen(false)
+          setCreateOwner(null)
+        }}
+        open={createOpen}
+      />
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/cross-connection-bots.test.ts b/apps/desktop/src/plugins/hermes-bots/cross-connection-bots.test.ts
new file mode 100644
index 000000000000..2c075e83487c
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/cross-connection-bots.test.ts
@@ -0,0 +1,178 @@
+/**
+ * Cross-connection Bot Mode: a roster row can belong to another registered
+ * connection's backend, and a group chat can seat members from several
+ * machines at once.
+ *
+ * Everything hangs off one rule — a source-scoped row carries an IMMUTABLE
+ * route descriptor and every RPC for it goes through `host.requestProfile`
+ * with that descriptor, never through the active gateway. The alias case is
+ * the sharp edge: Desktop's identity for the row (`route.profile`) and the
+ * backend's own name for it (`route.targetProfile`) differ, so the params of
+ * every profile-shaped RPC have to be translated on the way out while the
+ * route keeps the Desktop identity.
+ *
+ * Ported from tests/cross-connection-bots.test.mjs, which ran the whole
+ * plugin.js bundle under `vm`.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { GroupMember, ProfileRoute, RosterRow } from './types'
+
+const { overrides, request, requestProfile } = vi.hoisted(() => ({
+  overrides: {} as Record<string, unknown>,
+  request: vi.fn(),
+  requestProfile: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  overrides.request = request
+  overrides.requestProfile = requestProfile
+
+  return {
+    ...sdk,
+    host: new Proxy(sdk.host, {
+      get: (target, prop) => (prop in overrides ? overrides[prop as string] : Reflect.get(target, prop))
+    })
+  }
+})
+
+const { botBackendProfileScope, botConnectionRoute, requestForBot } = await import('./routing')
+const { groupMemberKey } = await import('./group-membership')
+
+const { buildGroupChatTurnPrompt, formatGroupChatLine, parseGroupChatMentions, resolveGroupResponders } =
+  await import('./group-rounds')
+
+const aliasBot = {
+  name: 'worker',
+  route: {
+    connectionId: 'remote-a',
+    mode: 'remote',
+    profile: 'worker',
+    targetProfile: 'backend-worker'
+  } satisfies ProfileRoute,
+  sourceScoped: true
+} as RosterRow
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  request.mockResolvedValue({})
+  requestProfile.mockResolvedValue({})
+})
+
+describe('every source-scoped row resolves to an immutable owner', () => {
+  it('routes only source-annotated rows, and freezes the descriptor', () => {
+    expect(botConnectionRoute({ connectionId: 'local', name: 'writer' })).toBeNull()
+    expect(botConnectionRoute({ name: 'writer' })).toBeNull()
+    expect(Object.isFrozen(botConnectionRoute({ connectionId: 'spark', name: 'writer', sourceScoped: true }))).toBe(
+      true
+    )
+    expect(botConnectionRoute({ connectionId: 'mac-mini', name: 'dixie', remoteSource: true })).toEqual({
+      connectionId: 'mac-mini',
+      mode: 'remote',
+      profile: 'dixie',
+      targetProfile: 'dixie'
+    })
+  })
+
+  it('keeps Desktop identity separate from the backend target in the capability scope', () => {
+    expect(
+      botBackendProfileScope({
+        connectionId: 'remote-a',
+        mode: 'remote',
+        profile: 'worker',
+        targetProfile: 'backend-worker'
+      })
+    ).toEqual({ connectionId: 'remote-a', profile: 'backend-worker' })
+  })
+})
+
+describe('requestForBot dispatches on the owner, not the active gateway', () => {
+  it('sends source-scoped rows through requestProfile and local rows through request', async () => {
+    await requestForBot({ name: 'local-bot' }, 'session.create', { title: 'x' })
+    await requestForBot({ connectionId: 'local', name: 'local-bot', sourceScoped: true }, 'session.create', {
+      title: 'x'
+    })
+    await requestForBot({ connectionId: 'mac-mini', name: 'dixie', remoteSource: true }, 'prompt.submit', {
+      text: 'hi'
+    })
+
+    expect(request.mock.calls.map(([method]) => method)).toEqual(['session.create'])
+    // A registered LOCAL source still uses the explicit descriptor.
+    expect(requestProfile.mock.calls.map(([route, method]) => [route.connectionId, method])).toEqual([
+      ['local', 'session.create'],
+      ['mac-mini', 'prompt.submit']
+    ])
+  })
+
+  it('translates every backend-profile RPC shape for a non-identity alias', async () => {
+    await requestForBot(aliasBot, 'profiles.describe', { name: 'worker' })
+    await requestForBot(aliasBot, 'profiles.configure', { name: 'worker', soul: 'x' })
+    await requestForBot(aliasBot, 'profiles.create', { clone_from: 'worker', name: 'worker-2' })
+    await requestForBot(aliasBot, 'session.create', { profile: 'worker', title: 'Bot Chat' })
+    await requestForBot(aliasBot, 'cli.exec', { argv: ['--profile', 'worker', 'config', 'unset', 'model'] })
+    await requestForBot(aliasBot, 'cli.exec', { argv: ['profile', 'describe', 'worker', '--text', 'worker'] })
+
+    expect(requestProfile.mock.calls.map(([, , params]) => params)).toEqual([
+      { name: 'backend-worker' },
+      { name: 'backend-worker', soul: 'x' },
+      { clone_from: 'backend-worker', name: 'worker-2' },
+      { profile: 'backend-worker', title: 'Bot Chat' },
+      { argv: ['--profile', 'backend-worker', 'config', 'unset', 'model'] },
+      // Only the profile operand is rewritten — the trailing --text value is
+      // the user's own argument and stays untouched.
+      { argv: ['profile', 'describe', 'backend-worker', '--text', 'worker'] }
+    ])
+    // The route keeps Desktop's identity for the row throughout.
+    expect(requestProfile.mock.calls.every(([route]) => route.profile === 'worker')).toBe(true)
+  })
+})
+
+describe('a group room seats members from several machines', () => {
+  it('source-qualifies remote member keys and leaves local ones bare', () => {
+    // Bare names keep persisted-room compatibility for single-source rooms.
+    expect(groupMemberKey({ name: 'ops' } as GroupMember)).toBe('ops')
+    expect(groupMemberKey({ connectionId: 'mac-mini', name: 'dixie', remoteSource: true } as GroupMember)).toBe(
+      'mac-mini::dixie'
+    )
+  })
+
+  it('resolves @name-device to the remote member, keeping same-named agents distinct', () => {
+    const members = [
+      { name: 'dixie', title: '' },
+      { connectionId: 'mac-mini', handle: 'dixie-mac-mini', name: 'dixie', remoteSource: true }
+    ] as GroupMember[]
+
+    const parsed = parseGroupChatMentions('hey @dixie-mac-mini can you check disk space', members)
+
+    expect([...parsed.mentioned]).toEqual(['mac-mini::dixie'])
+
+    const responders = resolveGroupResponders(
+      [{ at: 1, from: { kind: 'user', name: 'You' }, text: '@dixie-mac-mini ping' }],
+      members
+    )
+
+    expect(responders).toHaveLength(1)
+    expect(responders[0].remoteSource).toBe(true)
+  })
+
+  it('badges cross-connection speakers with their device in lines and turn prompts', () => {
+    expect(
+      formatGroupChatLine({ at: 1, from: { kind: 'member', name: 'dixie', source: 'Mac Mini' }, text: 'done' }, 'ops')
+    ).toBe('dixie [Mac Mini]: done')
+    expect(
+      buildGroupChatTurnPrompt({
+        deltaLines: ['You (user): hi'],
+        groupName: 'infra',
+        members: [
+          { name: 'ops', title: '' },
+          { connectionId: 'mac-mini', connectionLabel: 'Mac Mini', name: 'dixie', remoteSource: true }
+        ] as GroupMember[],
+        viewer: { name: 'ops' } as GroupMember
+      })
+    ).toMatch(/@dixie \[on Mac Mini\]/)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/data.bot-meta-migration.test.ts b/apps/desktop/src/plugins/hermes-bots/data.bot-meta-migration.test.ts
new file mode 100644
index 000000000000..a82d9d0e4f50
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/data.bot-meta-migration.test.ts
@@ -0,0 +1,276 @@
+/**
+ * The v1 -> v2 bot-metadata migration and the commit protocol that guards it.
+ *
+ * v1 keyed appearance by bare bot name, which collides the moment two sources
+ * expose a same-named profile; v2 keys by `connectionId::profile`. Re-keying is
+ * only sound on a topology where every v1 name provably means the LOCAL bot, so
+ * migration refuses anything else and leaves v1 in place rather than guessing.
+ *
+ * The commit is three storage operations that cannot be made atomic (clear the
+ * marker, write the snapshot, set the marker), so the marker — not the snapshot
+ * — is what makes v2 authoritative. That is what makes a crash mid-write
+ * survivable: a markerless v2 is ignored and v1 still loads. A failed commit
+ * rolls back to the last committed generation, or clears both keys when there
+ * is no generation to roll back to.
+ *
+ * Ported from the migration half of
+ * tests/remote-routing-races.test.mjs, which drove a `vm` copy of plugin.js.
+ * `migratedLocalRoutes` is module-private, so where that suite asserted the
+ * map's size this one asserts what the map is FOR: no route is adopted and
+ * nothing is written.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { hostMock } = vi.hoisted(() => ({
+  hostMock: { agents: vi.fn(), profileRoutes: vi.fn() }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return { atom, host: hostMock, queryClient: undefined, useQuery: vi.fn(), useValue: vi.fn() }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+type Operation = ['remove', string] | ['set', string, unknown]
+
+interface RecordingStorage {
+  get: (key: string) => Promise<unknown>
+  operations: Operation[]
+  remove: (key: string) => Promise<void>
+  set: (key: string, value: unknown) => Promise<void>
+}
+
+/** A ctx.storage that records every operation and can be told to fail specific
+ *  ones — the only way to reach the rollback and crash-window branches. */
+function recordingStorage(
+  initial: Record<string, unknown>,
+  { failRemove = [], failSet = null, failSetTimes = Infinity }: FailureSpec = {}
+): RecordingStorage {
+  const values = new Map(Object.entries(initial))
+  const operations: Operation[] = []
+  let failedSets = 0
+
+  return {
+    get: async key => values.get(key) ?? null,
+    operations,
+    remove: async key => {
+      operations.push(['remove', key])
+
+      if (failRemove.includes(key)) {
+        throw new Error('remove failed')
+      }
+
+      values.delete(key)
+    },
+    set: async (key, value) => {
+      operations.push(['set', key, value])
+
+      if (key === failSet && failedSets < failSetTimes) {
+        failedSets += 1
+        throw new Error('disk full')
+      }
+
+      values.set(key, value)
+    }
+  }
+}
+
+interface FailureSpec {
+  failRemove?: string[]
+  failSet?: null | string
+  failSetTimes?: number
+}
+
+/** A fresh module graph — the commit chain and the migrated-route map are
+ *  module state, so a reload is what "the user restarts the app" means here. */
+async function loadData() {
+  vi.resetModules()
+
+  return import('./data')
+}
+
+/** The one topology migration accepts: a single local source owning the bot. */
+function soleLocalTopology(profile: string, targetProfile = profile) {
+  hostMock.agents.mockResolvedValue({
+    agents: [{ connectionId: 'local', connectionKind: 'local', profile }],
+    sources: [{ connectionId: 'local', kind: 'local' }]
+  })
+  hostMock.profileRoutes.mockResolvedValue([{ connectionId: 'local', mode: 'local', profile, targetProfile }])
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  hostMock.agents.mockResolvedValue({ agents: [], sources: [] })
+  hostMock.profileRoutes.mockResolvedValue([])
+})
+
+describe('v1 is re-keyed only where the new key is provable', () => {
+  it('migrates a sole-local topology and commits the marker after the data', async () => {
+    soleLocalTopology('default')
+
+    const storage = recordingStorage({ 'bot-meta': { default: { title: 'Local' } } })
+    const { $botMeta, migrateBotMeta } = await loadData()
+
+    await expect(migrateBotMeta(storage)).resolves.toBe(true)
+
+    expect(Object.keys($botMeta.get())).toEqual(['local::default'])
+    expect(storage.operations.map(([op, key]) => `${op} ${key}`)).toEqual([
+      'remove bot-meta-v2-migrated',
+      'set bot-meta-v2',
+      'set bot-meta-v2-migrated'
+    ])
+  })
+
+  it('refuses a multi-source topology rather than project v1 onto a same-named twin', async () => {
+    hostMock.agents.mockResolvedValue({
+      agents: [
+        { connectionId: 'local', connectionKind: 'local', profile: 'default' },
+        { connectionId: 'remote-a', connectionKind: 'remote', profile: 'default' }
+      ],
+      sources: [
+        { connectionId: 'local', kind: 'local' },
+        { connectionId: 'remote-a', kind: 'remote' }
+      ]
+    })
+    hostMock.profileRoutes.mockResolvedValue([
+      { connectionId: 'local', mode: 'local', profile: 'default', targetProfile: 'default' },
+      { connectionId: 'remote-a', mode: 'remote', profile: 'default', targetProfile: 'remote-default' }
+    ])
+
+    const storage = recordingStorage({ 'bot-meta': { default: { title: 'Legacy local' } } })
+    const { $botMeta, migrateBotMeta } = await loadData()
+
+    await expect(migrateBotMeta(storage)).resolves.toBe(false)
+
+    // v1 still loads, under its original bare-name key.
+    expect($botMeta.get()).toEqual({ default: { title: 'Legacy local' } })
+    expect(storage.operations).toEqual([])
+  })
+
+  it('refuses the whole batch when even one v1 profile has no local route', async () => {
+    // All-or-nothing: adopting routes for the profiles that DO resolve would
+    // half-migrate the snapshot, and the unresolved half would keep its bare
+    // key forever.
+    soleLocalTopology('first', 'backend-first')
+
+    const storage = recordingStorage({
+      'bot-meta': { first: { title: 'First' }, missing: { title: 'Missing' } }
+    })
+
+    const { $botMeta, migrateBotMeta } = await loadData()
+
+    await expect(migrateBotMeta(storage)).resolves.toBe(false)
+
+    expect($botMeta.get()).toEqual({ first: { title: 'First' }, missing: { title: 'Missing' } })
+    expect(storage.operations).toEqual([])
+  })
+})
+
+describe('the marker, not the snapshot, is what makes v2 authoritative', () => {
+  it('hydrates a committed v2 without rewriting it', async () => {
+    const v2 = { 'remote-a::default': { title: 'A' }, 'remote-b::default': { title: 'B' } }
+    const storage = recordingStorage({ 'bot-meta-v2': v2, 'bot-meta-v2-migrated': true })
+    const { $botMeta, migrateBotMeta } = await loadData()
+
+    await expect(migrateBotMeta(storage)).resolves.toBe(true)
+
+    expect($botMeta.get()).toEqual(v2)
+    expect(storage.operations).toEqual([])
+  })
+
+  it('ignores a markerless v2 instead of adopting it implicitly', async () => {
+    const storage = recordingStorage({ 'bot-meta-v2': { 'remote-a::default': { title: 'Uncommitted' } } })
+    const { $botMeta, migrateBotMeta } = await loadData()
+
+    await expect(migrateBotMeta(storage)).resolves.toBe(false)
+
+    expect($botMeta.get()).toEqual({})
+    expect(storage.operations).toEqual([])
+  })
+
+  it('reloads v1 when a crash left a markerless v2 behind', async () => {
+    // The crash window is between the snapshot write and the marker write.
+    // Whatever v2 holds there is a partial generation; v1 is the last good one.
+    const storage = recordingStorage({
+      'bot-meta': { first: { title: 'Rollback' } },
+      'bot-meta-v2': { 'local::first': { title: 'Crash window' } }
+    })
+
+    const { $botMeta, migrateBotMeta } = await loadData()
+
+    await expect(migrateBotMeta(storage)).resolves.toBe(false)
+
+    expect($botMeta.get()).toEqual({ first: { title: 'Rollback' } })
+  })
+})
+
+describe('a failed commit falls back to the last committed generation', () => {
+  it('restores the previous snapshot when the marker write fails', async () => {
+    const committed = { 'remote-a::default': { title: 'B' } }
+
+    const storage = recordingStorage(
+      { 'bot-meta-v2': committed, 'bot-meta-v2-migrated': true },
+      { failSet: 'bot-meta-v2-migrated', failSetTimes: 1 }
+    )
+
+    const { commitBotMetaV2 } = await loadData()
+
+    await expect(commitBotMetaV2(storage, { 'remote-a::default': { title: 'D' } })).rejects.toThrow('disk full')
+
+    // Reload: the successor never became authoritative, so the generation the
+    // marker last vouched for is what comes back.
+    const reloaded = await loadData()
+
+    await expect(reloaded.migrateBotMeta(storage)).resolves.toBe(true)
+    expect(reloaded.$botMeta.get()).toEqual(committed)
+  })
+
+  it('clears both keys when the failed commit had no committed generation behind it', async () => {
+    // First-ever migration: rolling "back" to a previous v2 is not an option,
+    // so both keys must go, leaving v1 authoritative again.
+    soleLocalTopology('first', 'backend-first')
+
+    const storage = recordingStorage({ 'bot-meta': { first: { title: 'First' } } }, { failSet: 'bot-meta-v2-migrated' })
+
+    const { $botMeta, migrateBotMeta } = await loadData()
+
+    await expect(migrateBotMeta(storage)).resolves.toBe(false)
+
+    expect($botMeta.get()).toEqual({ first: { title: 'First' } })
+    expect(storage.operations.map(([op, key]) => `${op} ${key}`)).toEqual([
+      'remove bot-meta-v2-migrated',
+      'set bot-meta-v2',
+      'set bot-meta-v2-migrated',
+      'remove bot-meta-v2-migrated',
+      'remove bot-meta-v2'
+    ])
+
+    const reloaded = await loadData()
+
+    await expect(reloaded.migrateBotMeta(storage)).resolves.toBe(false)
+    expect(reloaded.$botMeta.get()).toEqual({ first: { title: 'First' } })
+  })
+
+  it('still reloads v1 when even the rollback cleanup fails', async () => {
+    // Worst case: marker write fails AND the v2 cleanup fails, so a markerless
+    // v2 is left on disk. The marker rule is what saves it — v1 still wins.
+    soleLocalTopology('first', 'backend-first')
+
+    const storage = recordingStorage(
+      { 'bot-meta': { first: { title: 'Rollback' } } },
+      { failRemove: ['bot-meta-v2'], failSet: 'bot-meta-v2-migrated' }
+    )
+
+    const { migrateBotMeta } = await loadData()
+
+    await expect(migrateBotMeta(storage)).resolves.toBe(false)
+
+    const reloaded = await loadData()
+
+    await expect(reloaded.migrateBotMeta(storage)).resolves.toBe(false)
+    expect(reloaded.$botMeta.get()).toEqual({ first: { title: 'Rollback' } })
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/data.bot-meta.test.ts b/apps/desktop/src/plugins/hermes-bots/data.bot-meta.test.ts
new file mode 100644
index 000000000000..23d080e801e2
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/data.bot-meta.test.ts
@@ -0,0 +1,320 @@
+/**
+ * Bot metadata: the write path (`saveBotMeta`), the disk-load path
+ * (`migrateBotMeta`), and the server-reconciliation overlay
+ * (`mergeServerMeta`).
+ *
+ * Every case below is a shipped regression:
+ *  - a save must report a REAL remote failure differently from the documented
+ *    older-gateway fallback, or the editor toasts "remote persistence failed"
+ *    on every save forever;
+ *  - `profiles.set_asset` must fire only when the avatar actually changed — a
+ *    no-op `clear` from one machine raced another machine's just-pushed avatar
+ *    and wiped it server-side;
+ *  - a slow disk load must not wipe metadata written earlier in the session;
+ *  - the server overlay is authoritative for the fields it carries (a dropped
+ *    `chat` pointer, a disbanded group) but must NOT resurrect state a local
+ *    write already removed — the disband-resurrection fence.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { $botMeta, botMetaWriteAt, saveBotMeta } from './data'
+import { mergeServerMeta } from './profile-ops'
+import type { RosterRow } from './types'
+
+const { hostMock, storageMock } = vi.hoisted(() => ({
+  hostMock: {
+    agents: undefined as unknown,
+    profileRoutes: undefined as unknown,
+    request: vi.fn(),
+    requestProfile: vi.fn(),
+    state: { connectionId: { get: () => 'local' }, profile: { get: () => 'default' } }
+  },
+  storageMock: { get: vi.fn(), remove: vi.fn(), set: vi.fn() }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    atom,
+    forgetSessionUnread: vi.fn(),
+    host: hostMock,
+    queryClient: { invalidateQueries: vi.fn() },
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => ({ storage: storageMock }), ID: 'hermes-bots' }))
+
+// profile-ops pulls in the roster surfaces for delete/duplicate; the overlay
+// under test needs none of them.
+vi.mock('./avatar-image', () => ({ isBackfilledFacePng: () => false }))
+vi.mock('./canonical-chat', () => ({ ensureBotMetadata: vi.fn() }))
+
+/** Every `host.request` recorded, with the params frozen at call time. */
+function recordRequests(reply: (method: string) => unknown = () => ({})) {
+  const calls: Array<{ method: string; params: Record<string, unknown> }> = []
+
+  hostMock.request.mockImplementation(async (method: string, params: Record<string, unknown>) => {
+    calls.push({ method, params: structuredClone(params ?? {}) })
+
+    return reply(method)
+  })
+
+  return calls
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  $botMeta.set({})
+  botMetaWriteAt.clear()
+  storageMock.get.mockResolvedValue(null)
+  storageMock.set.mockResolvedValue(undefined)
+  storageMock.remove.mockResolvedValue(undefined)
+  recordRequests()
+})
+
+describe('a save reports what the SERVER did, not just what the screen shows', () => {
+  it('keeps the look locally and reports the remote failure', async () => {
+    recordRequests(method => (method === 'profiles.configure' ? { applied: { ui_meta: false } } : {}))
+
+    const result = await saveBotMeta('researcher', { color: '#38bdf8', custom: true, shape: 'cloud' })
+
+    expect($botMeta.get().researcher).toMatchObject({ color: '#38bdf8', shape: 'cloud' })
+    expect(result).toEqual({ serverOutcome: 'failed', serverPersisted: false })
+  })
+
+  it('reports success once ui_meta is applied', async () => {
+    recordRequests(method => (method === 'profiles.configure' ? { applied: { ui_meta: true } } : {}))
+
+    await expect(saveBotMeta('researcher', { color: '#8b5cf6', custom: true, shape: 'hexagon' })).resolves.toEqual({
+      serverOutcome: 'persisted',
+      serverPersisted: true
+    })
+  })
+
+  it('treats an older gateway with no `applied` contract as unsupported, not failed', async () => {
+    // An error toast on this path would fire on EVERY save forever.
+    recordRequests(() => ({}))
+
+    await expect(saveBotMeta('researcher', { custom: true, shape: 'circle' })).resolves.toEqual({
+      serverOutcome: 'unsupported',
+      serverPersisted: false
+    })
+  })
+
+  it('treats a rejected configure the same way', async () => {
+    hostMock.request.mockRejectedValue(new Error('param shape rejected'))
+
+    await expect(saveBotMeta('researcher', { custom: true, shape: 'circle' })).resolves.toMatchObject({
+      serverOutcome: 'unsupported'
+    })
+  })
+})
+
+describe('avatar asset sync fires only on a real change', () => {
+  // Edit Profile always sends the image key, changed or not. Firing
+  // set_asset for every patch re-uploaded the full data URL — and a no-op
+  // `clear` from one machine could race another machine's just-pushed
+  // avatar and wipe it server-side.
+  it('pushes once, skips the re-save, clears on removal, ignores an absent key', async () => {
+    const calls = recordRequests()
+    const png = 'data:image/png;base64,AAAA'
+
+    await saveBotMeta('ops', { image: png, title: 'One' })
+    await saveBotMeta('ops', { image: png, title: 'Two' })
+    await saveBotMeta('ops', { image: null, title: 'Three' })
+    await saveBotMeta('ops', { title: 'Four' })
+
+    expect(calls.filter(call => call.method === 'profiles.set_asset').map(call => call.params)).toEqual([
+      { asset: 'avatar', data: png, name: 'ops' },
+      { asset: 'avatar', clear: true, name: 'ops' }
+    ])
+    // Meta still merges per patch, and ui_meta sync is unaffected.
+    expect($botMeta.get().ops.title).toBe('Four')
+    expect(calls.filter(call => call.method === 'profiles.configure')).toHaveLength(4)
+  })
+
+  it('still pushes the copied avatar when a bot is duplicated', async () => {
+    const calls = recordRequests()
+    const png = 'data:image/png;base64,BBBB'
+
+    await saveBotMeta('source', { image: png, title: 'Original' })
+    await saveBotMeta('source-2', { image: png, title: 'Original (copy)' })
+
+    // The fresh profile's image differs from its (empty) meta, so it pushes.
+    expect(calls.filter(call => call.method === 'profiles.set_asset').map(call => call.params)).toEqual([
+      { asset: 'avatar', data: png, name: 'source' },
+      { asset: 'avatar', data: png, name: 'source-2' }
+    ])
+  })
+
+  it('never ships the image or the pet icon inside ui_meta', async () => {
+    // ui_meta rides every profiles.list and is capped at 64KB; the image goes
+    // to the uncapped profile asset store instead.
+    const calls = recordRequests()
+
+    await saveBotMeta('ops', { image: 'data:image/png;base64,CCCC', pet: 'pet-cat', title: 'Ops' })
+
+    const configure = calls.find(call => call.method === 'profiles.configure')
+    const uiMeta = (configure?.params.ui_meta as Record<string, Record<string, unknown>>)['hermes-bots']
+
+    expect(uiMeta).toEqual({ title: 'Ops' })
+  })
+})
+
+describe('the disk load never clobbers a write from this session', () => {
+  async function loadWithStorage(value: unknown) {
+    vi.resetModules()
+
+    const data = await import('./data')
+
+    storageMock.get.mockImplementation(async (key: string) => (key === 'bot-meta' ? await value : null))
+
+    return data
+  }
+
+  it('keeps a value written while the load was still in flight', async () => {
+    let resolveStorage!: (value: unknown) => void
+
+    const pending = new Promise(resolve => {
+      resolveStorage = resolve
+    })
+
+    const data = await loadWithStorage(pending)
+
+    void data.saveBotMeta('researcher', { pinned: true, title: 'Research' })
+    expect(data.$botMeta.get().researcher.pinned).toBe(true)
+
+    const migration = data.migrateBotMeta(storageMock)
+
+    resolveStorage({ researcher: { title: 'Research' } })
+    await migration
+
+    expect(data.$botMeta.get().researcher).toMatchObject({ pinned: true, title: 'Research' })
+  })
+
+  it('still merges looks from disk under the fresher in-session write', async () => {
+    const data = await loadWithStorage({ researcher: { color: '#38bdf8', shape: 'cloud', title: 'Research' } })
+
+    void data.saveBotMeta('researcher', { pinned: true })
+    await data.migrateBotMeta(storageMock)
+
+    expect(data.$botMeta.get().researcher).toMatchObject({
+      color: '#38bdf8',
+      pinned: true,
+      shape: 'cloud',
+      title: 'Research'
+    })
+  })
+
+  it('fills in bots this session has not touched', async () => {
+    const data = await loadWithStorage({
+      researcher: { pinned: true, title: 'Research' },
+      writer: { title: 'Writer' }
+    })
+
+    await data.migrateBotMeta(storageMock)
+
+    expect(data.$botMeta.get().researcher.pinned).toBe(true)
+    expect(data.$botMeta.get().writer.title).toBe('Writer')
+  })
+})
+
+describe('server metadata reconciliation', () => {
+  const serverRow = (name: string, meta: Record<string, unknown>) =>
+    ({ name, ui_meta: { 'hermes-bots': meta } }) as unknown as RosterRow
+
+  it('removes a stale local canonical-chat pointer on sight', () => {
+    // Identity is the profile's "Bot Chat" registry row, resolved by name.
+    // Old `meta.chat` pointers must never look meaningful again.
+    $botMeta.set({
+      default: { chat: '4f6f6798ad6f', image: 'data:image/png;base64,avatar', pet: 'pet-cat', shape: 'cloud' }
+    })
+
+    mergeServerMeta([serverRow('default', { color: '#8b5cf6', shape: 'cloud', title: 'Hermana' })])
+
+    const current = $botMeta.get().default
+
+    expect(Object.hasOwn(current, 'chat')).toBe(false)
+    // Local-only fields the server copy never carries survive the overlay.
+    expect(current.image).toBe('data:image/png;base64,avatar')
+    expect(current.pet).toBe('pet-cat')
+
+    const [key, value] = storageMock.set.mock.calls.at(-1) as [string, Record<string, Record<string, unknown>>]
+
+    expect(key).toBe('bot-meta')
+    expect(Object.hasOwn(value.default, 'chat')).toBe(false)
+  })
+
+  it('drops the legacy scalar when authoritative groups say the membership is gone', () => {
+    // A server-side `group: null` is represented by OMISSION, so retaining
+    // the local scalar resurrects a membership another desktop just removed.
+    $botMeta.set({ researcher: { group: 'Old', groups: ['Old'], title: 'Researcher' } })
+
+    mergeServerMeta([serverRow('researcher', { groups: [], title: 'Researcher' })])
+
+    const current = $botMeta.get().researcher
+
+    expect(current.groups).toEqual([])
+    expect(Object.hasOwn(current, 'group')).toBe(false)
+  })
+
+  it('leaves local metadata alone when the gateway has none', () => {
+    $botMeta.set({ default: { chat: 'local-chat', shape: 'cloud' } })
+
+    mergeServerMeta([{ name: 'default' } as RosterRow])
+
+    expect($botMeta.get().default.chat).toBe('local-chat')
+    expect(storageMock.set).not.toHaveBeenCalled()
+  })
+
+  it('cannot resurrect a membership a later local write removed (disband-resurrection)', async () => {
+    $botMeta.set({ builder: { group: 'Team', groups: ['Team'], title: 'Builder' } })
+
+    // Snapshot fetched now — its ui_meta still names the group.
+    const staleFetchedAt = Date.now()
+    const staleRow = serverRow('builder', { group: 'Team', groups: ['Team'], title: 'Builder' })
+
+    // Disband path: the local write lands AFTER that fetch.
+    await new Promise(resolve => setTimeout(resolve, 5))
+    await saveBotMeta('builder', { group: null, groups: [] })
+    expect($botMeta.get().builder.groups).toEqual([])
+
+    mergeServerMeta([staleRow], staleFetchedAt)
+    expect($botMeta.get().builder.groups).toEqual([])
+
+    // A FRESH snapshot still gets the last word — server truth wins once it
+    // actually post-dates the local change.
+    mergeServerMeta([staleRow], Date.now() + 5)
+    expect($botMeta.get().builder.groups).toEqual(['Team'])
+  })
+
+  it('overlays without a fence when the caller has no fetch time (older callers)', async () => {
+    await saveBotMeta('builder', { group: null, groups: [] })
+    mergeServerMeta([serverRow('builder', { groups: ['Team'] })])
+
+    expect($botMeta.get().builder.groups).toEqual(['Team'])
+  })
+
+  it('forgets write stamps far too old to fence any snapshot', async () => {
+    vi.useFakeTimers()
+
+    try {
+      await saveBotMeta('builder', { title: 'Builder' })
+
+      expect([...botMetaWriteAt.keys()]).toEqual(['builder'])
+
+      // The renderer stays up for days. Once no snapshot can still be in
+      // flight from before a stamp, keeping it just costs a row per bot.
+      vi.advanceTimersByTime(120_000)
+      await saveBotMeta('researcher', { title: 'Research' })
+
+      expect([...botMetaWriteAt.keys()]).toEqual(['researcher'])
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/data.cached-roster.test.ts b/apps/desktop/src/plugins/hermes-bots/data.cached-roster.test.ts
new file mode 100644
index 000000000000..fe9a18b22726
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/data.cached-roster.test.ts
@@ -0,0 +1,87 @@
+/**
+ * `cachedUnionRoster` is the imperative roster read — the @mention popover
+ * must answer per keystroke and the composer middleware runs on submit, so
+ * neither can wait on the hook.
+ *
+ * `useRoster` keys its query on `[...ROSTER_KEY, connectionId]`, one entry per
+ * connection the window has been on. Reading it back with the BARE key is an
+ * exact-key match in TanStack Query and therefore matches NOTHING — the
+ * regression where completions offered no handles and remote `@name-device`
+ * mentions passed through unresolved. The read has to fall back to a prefix
+ * match over the key family, newest snapshot wins.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { cache, connection } = vi.hoisted(() => ({
+  cache: new Map<string, { key: unknown[]; value: unknown }>(),
+  connection: { id: 'local' }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+  const keyOf = (key: unknown[]) => JSON.stringify(key)
+
+  return {
+    atom,
+    host: { state: { connectionId: { get: () => connection.id }, profile: { get: () => 'default' } } },
+    queryClient: {
+      getQueriesData: ({ queryKey }: { queryKey: unknown[] }) =>
+        [...cache.values()]
+          .filter(entry => queryKey.every((part, index) => entry.key[index] === part))
+          .map(entry => [entry.key, entry.value]),
+      getQueryData: (key: unknown[]) => cache.get(keyOf(key))?.value,
+      invalidateQueries: vi.fn(),
+      setQueryData: (key: unknown[], value: unknown) => cache.set(keyOf(key), { key, value })
+    },
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+const seed = (key: unknown[], value: unknown) => cache.set(JSON.stringify(key), { key, value })
+
+beforeEach(() => {
+  cache.clear()
+  connection.id = 'local'
+})
+
+describe('cachedUnionRoster', () => {
+  it('reads the entry useRoster wrote under the connection-suffixed key', async () => {
+    const { cachedUnionRoster } = await import('./data')
+
+    seed(['hermes-bots', 'roster', 'local'], { profiles: [{ name: 'default' }] })
+
+    expect(cachedUnionRoster()?.profiles).toHaveLength(1)
+    // The bare key is what the broken read used — it must still miss, or this
+    // test would pass for the wrong reason.
+    expect(cache.has(JSON.stringify(['hermes-bots', 'roster']))).toBe(false)
+  })
+
+  it('falls back to another connection’s entry when the window has moved', async () => {
+    const { cachedUnionRoster } = await import('./data')
+
+    seed(['hermes-bots', 'roster', 'vera'], { profiles: [{ connectionId: 'vera', name: 'default' }] })
+    connection.id = 'local'
+
+    expect(cachedUnionRoster()?.profiles?.[0]).toMatchObject({ connectionId: 'vera' })
+  })
+
+  it('prefers the freshest snapshot among several cached connections', async () => {
+    const { cachedUnionRoster } = await import('./data')
+
+    seed(['hermes-bots', 'roster', 'old'], { fetchedAt: 1_000, profiles: [{ name: 'stale' }] })
+    seed(['hermes-bots', 'roster', 'new'], { fetchedAt: 9_000, profiles: [{ name: 'fresh' }] })
+    connection.id = 'neither'
+
+    expect(cachedUnionRoster()?.profiles?.[0]).toMatchObject({ name: 'fresh' })
+  })
+
+  it('reports nothing rather than throwing on a cold cache', async () => {
+    const { cachedUnionRoster } = await import('./data')
+
+    expect(cachedUnionRoster()).toBeNull()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/data.identity.test.ts b/apps/desktop/src/plugins/hermes-bots/data.identity.test.ts
new file mode 100644
index 000000000000..e398be9fcb40
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/data.identity.test.ts
@@ -0,0 +1,416 @@
+/**
+ * The identity layer every Bot Mode surface files a bot under: the @handle it
+ * is tagged with, the friendly forms a rename makes taggable, the
+ * source-qualified keys that keep two same-named bots apart, which session
+ * counts as "what this bot is doing", roster search, and the needs-attention
+ * badge.
+ *
+ * Drives the real `data` module (with real `labels` / `routing` underneath);
+ * only the SDK is mocked.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  $botAttention,
+  $botMeta,
+  botActivitySession,
+  botFriendlyNames,
+  botHandle,
+  botMentionTag,
+  botMetaKey,
+  botRosterKey,
+  botSelectionKey,
+  clearBotAttention,
+  filterBots,
+  mentionNameForms,
+  noteBotAttention,
+  preferReachableSameNameRows,
+  resolveRosterMentions
+} from './data'
+import { indexAliasRoutes } from './routing'
+import type { RosterRow } from './types'
+
+const { hostMock } = vi.hoisted(() => ({
+  hostMock: {
+    request: vi.fn(),
+    requestProfile: vi.fn(),
+    state: { connectionId: { get: vi.fn(() => 'local') }, profile: { get: vi.fn(() => 'default') } }
+  }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom: nanoAtom } = await import('nanostores')
+
+  return {
+    atom: nanoAtom,
+    host: hostMock,
+    queryClient: undefined,
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+/** Gateway rows carry a session id on `last_session` that the plugin's
+ *  `SessionPreview` type deliberately does not model; the fixtures keep it so
+ *  "which session speaks for a bot" can be asserted by id. */
+interface RowFixture extends Omit<Partial<RosterRow>, 'last_session'> {
+  last_session?: { id?: string; last_active?: number; preview?: string }
+}
+
+const row = (bot: RowFixture) => bot as RosterRow
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  hostMock.state.connectionId.get.mockReturnValue('local')
+  indexAliasRoutes([])
+  $botMeta.set({})
+  $botAttention.set({})
+})
+
+describe('the @handle a bot answers to', () => {
+  it('presents the primary profile as @hermes — "default" never surfaces in the UI', () => {
+    expect(botHandle('default')).toBe('hermes')
+    expect(botHandle('ops')).toBe('ops')
+  })
+
+  it('prefers a precomputed multi-source handle over the bare name', () => {
+    expect(botHandle('default', row({ handle: 'default-vera', name: 'default' }))).toBe('default-vera')
+  })
+})
+
+describe('renamed bots stay taggable', () => {
+  // Discord report, Aug 2026: renaming a bot — Bot Mode title or `hermes
+  // profile rename` display_name — must change what you can @-tag it with,
+  // while the old profile handle keeps resolving.
+  it('reduces a friendly name to its slugged and collapsed forms', () => {
+    expect(mentionNameForms('Research Buddy')).toEqual(['research-buddy', 'researchbuddy'])
+    expect(mentionNameForms('Ops')).toEqual(['ops'])
+  })
+
+  it('drops reserved tokens so a rename cannot hijack a built-in tag', () => {
+    expect(mentionNameForms('Hermes')).toEqual([])
+    expect(mentionNameForms('@everyone')).toEqual([])
+    expect(mentionNameForms('')).toEqual([])
+  })
+
+  it('inserts the renamed slug, falling back to the profile handle', () => {
+    $botMeta.set({ writer: { title: 'Research Buddy' } })
+
+    expect(botMentionTag(row({ name: 'writer' }))).toBe('research-buddy')
+    expect(botMentionTag(row({ name: 'ops' }))).toBe('ops')
+    expect(botMentionTag(row({ name: 'default' }))).toBe('hermes')
+    // display_name (`hermes profile rename`) drives the tag too.
+    expect(botMentionTag(row({ display_name: 'Deal Finder', name: 'scout' }))).toBe('deal-finder')
+  })
+
+  it('resolves a renamed bot by its friendly tag AND its old handle', () => {
+    $botMeta.set({ writer: { title: 'Research Buddy' } })
+
+    const roster = [
+      row({ name: 'default' }),
+      row({ name: 'writer' }),
+      row({ display_name: 'Deal Finder', name: 'scout' })
+    ]
+
+    const live = { connectionId: 'local', name: 'default' }
+    const names = (text: string) => resolveRosterMentions(text, roster, live).map(bot => bot.name)
+
+    expect(names('hey @research-buddy check this')).toEqual(['writer'])
+    expect(names('ping @dealfinder please')).toEqual(['scout'])
+    expect(names('hey @writer')).toEqual(['writer'])
+  })
+})
+
+describe('resolving @mentions against the roster', () => {
+  const roster = [
+    row({ connectionId: 'local', name: 'default' }),
+    row({ connectionId: 'mac-mini', connectionLabel: 'Mac Mini', name: 'dixie', remoteSource: true }),
+    row({ connectionId: 'mac-mini', handle: 'bob-mac-mini', name: 'bob', remoteSource: true })
+  ]
+
+  it('reaches Connections bots by bare name and by @name-device handle', () => {
+    const live = { connectionId: 'local', name: 'default' }
+
+    expect(resolveRosterMentions('@dixie how is disk space?', roster, live).map(bot => bot.name)).toEqual(['dixie'])
+    expect(resolveRosterMentions('ping @bob-mac-mini', roster, live).map(bot => bot.name)).toEqual(['bob'])
+  })
+
+  it('never treats @hermes in your own chat as a handoff to yourself', () => {
+    expect(resolveRosterMentions('@hermes do it', roster, { connectionId: 'local', name: 'default' })).toEqual([])
+    // From ANOTHER bot's chat the same tag is a real handoff.
+    expect(
+      resolveRosterMentions('@hermes do it', roster, { connectionId: 'mac-mini', name: 'dixie' }).map(bot => bot.name)
+    ).toEqual(['default'])
+  })
+
+  it('ignores tags inside code spans and fences', () => {
+    const live = { connectionId: 'local', name: 'default' }
+
+    expect(resolveRosterMentions('run `@dixie` literally', roster, live)).toEqual([])
+    expect(resolveRosterMentions('```\n@dixie\n```', roster, live)).toEqual([])
+  })
+
+  it('refuses an ambiguous bare name — the device-qualified handle is required', () => {
+    const twins = [
+      row({ connectionId: 'a', handle: 'ops-a', name: 'ops', remoteSource: true }),
+      row({ connectionId: 'b', handle: 'ops-b', name: 'ops', remoteSource: true })
+    ]
+
+    expect(resolveRosterMentions('@ops ping', twins, { connectionId: 'local', name: 'default' })).toEqual([])
+    expect(
+      resolveRosterMentions('@ops-b ping', twins, { connectionId: 'local', name: 'default' }).map(
+        bot => bot.connectionId
+      )
+    ).toEqual(['b'])
+  })
+})
+
+describe('source-qualified keys', () => {
+  it('gives the same profile name on two sources distinct React keys', () => {
+    const here = row({ connectionId: 'local', name: 'default' })
+    const there = row({ connectionId: 'vera', name: 'default', remoteSource: true, sourceScoped: true })
+
+    expect(botRosterKey(here)).not.toBe(botRosterKey(there))
+  })
+
+  it('keeps selection and metadata keys from colliding across connections', () => {
+    const scoped = (connectionId: string) =>
+      row({
+        connectionId,
+        name: 'default',
+        route: { connectionId, mode: 'remote', profile: 'default', targetProfile: 'default' },
+        sourceScoped: true
+      })
+
+    expect(botSelectionKey(scoped('a'))).not.toBe(botSelectionKey(scoped('b')))
+    expect(botMetaKey(scoped('a'))).toBe('a::default')
+    expect(botMetaKey(scoped('b'))).toBe('b::default')
+  })
+
+  it('leaves an unscoped legacy row on its bare name', () => {
+    expect(botSelectionKey(row({ name: 'ops' }))).toBe('ops')
+    expect(botMetaKey(row({ name: 'ops' }))).toBe('ops')
+  })
+})
+
+describe('which session speaks for a bot', () => {
+  // The "6d ago" bug: canonical Bot Chats are hidden from session lists, so
+  // last_session alone never sees them — a bot you DM all day read as a week
+  // idle because its newest VISIBLE session was a week old.
+  const now = 1_000_000_000
+
+  it('prefers the fresher canonical Bot Chat over a stale visible session', () => {
+    const bot = row({
+      canonical_session: { id: 'bot-chat', last_active: now - 5, preview: 'fresh DM' },
+      last_session: { id: 'old-scratch', last_active: now - 6 * 86_400, preview: 'ancient' }
+    })
+
+    expect(botActivitySession(bot)?.preview).toBe('fresh DM')
+  })
+
+  it('keeps last_session when that is the fresher one', () => {
+    const bot = row({
+      canonical_session: { id: 'bot-chat', last_active: now - 3600, preview: 'older DM' },
+      last_session: { id: 'scratch', last_active: now - 10, preview: 'just now' }
+    })
+
+    expect(botActivitySession(bot)?.preview).toBe('just now')
+  })
+
+  it('degrades to whichever summary an older gateway sent', () => {
+    expect(botActivitySession(row({ last_session: { last_active: 1, preview: 'visible only' } }))?.preview).toBe(
+      'visible only'
+    )
+    expect(
+      botActivitySession(row({ canonical_session: { id: 'canonical', last_active: 1, preview: 'chat only' } }))?.preview
+    ).toBe('chat only')
+    expect(botActivitySession(row({}))).toBeNull()
+    expect(botActivitySession(null)).toBeNull()
+  })
+})
+
+describe('roster search narrows without re-ranking', () => {
+  const roster = [
+    row({ name: 'agency-audio-designer', title: 'Audio Designer' }),
+    row({ name: 'agency-ai-engineer', title: 'AI Engineer' }),
+    row({ name: 'default' })
+  ]
+
+  const meta = { 'agency-audio-designer': { title: 'Sound Studio' }, default: {} }
+
+  it('matches the visible display name, case-insensitively', () => {
+    expect(filterBots(roster, meta, 'SOUND').map(bot => bot.name)).toEqual(['agency-audio-designer'])
+  })
+
+  it('matches profile handles and preserves roster order', () => {
+    expect(filterBots(roster, meta, 'agency-').map(bot => bot.name)).toEqual([
+      'agency-audio-designer',
+      'agency-ai-engineer'
+    ])
+    expect(filterBots(roster, meta, '@hermes').map(bot => bot.name)).toEqual(['default'])
+    expect(filterBots(roster, meta, 'default').map(bot => bot.name)).toEqual(['default'])
+  })
+
+  it('also matches roles, message previews, and the source device name', () => {
+    const richer = [
+      row({
+        connectionLabel: 'Work Studio',
+        description: 'Release quality and compliance',
+        last_session: { id: 's1', last_active: 1, preview: 'Checked the deployment checklist' },
+        name: 'reviewer'
+      }),
+      row({ description: 'Editorial support', name: 'writer' })
+    ]
+
+    expect(filterBots(richer, {}, 'compliance')[0].name).toBe('reviewer')
+    expect(filterBots(richer, {}, 'deployment checklist')[0].name).toBe('reviewer')
+    expect(filterBots(richer, {}, 'work studio')[0].name).toBe('reviewer')
+  })
+
+  it('returns the existing roster reference for a blank query', () => {
+    expect(filterBots(roster, meta, '   ')).toBe(roster)
+  })
+})
+
+describe('unreachable same-name twins (#92286)', () => {
+  // After Desktop moves to the built-in This-device source, the old loopback
+  // row (127.0.0.1:port, not listening) still sits beside the live profile
+  // and looks like a second agent. Only sidebar tiles are filtered — routing
+  // identities, group members and @-mentions still see every row.
+  const live = row({ connectionId: 'local', name: 'default', sourceReachable: true, sourceScoped: true })
+  const dead = row({ connectionId: 'loopback', name: 'default', sourceReachable: false, sourceScoped: true })
+
+  it('drops a dead twin when a live copy exists', () => {
+    expect(preferReachableSameNameRows([live, dead]).map(bot => bot.connectionId)).toEqual(['local'])
+  })
+
+  it('keeps two live sources sharing a profile name', () => {
+    const other = row({ connectionId: 'vera', name: 'default', sourceReachable: true, sourceScoped: true })
+
+    expect(preferReachableSameNameRows([live, other])).toHaveLength(2)
+  })
+
+  it('counts connect-on-demand as reachable', () => {
+    const onDemand = row({
+      connectionId: 'vera',
+      name: 'default',
+      sourceError: 'connect-on-demand',
+      sourceScoped: true
+    })
+
+    expect(preferReachableSameNameRows([live, onDemand])).toHaveLength(2)
+  })
+
+  it('keeps an unreachable row when there is no live twin, so a down source still has a tile', () => {
+    expect(preferReachableSameNameRows([dead])).toHaveLength(1)
+  })
+
+  it('keeps a ghost so a selected-but-offline owner is never replaced by a twin', () => {
+    expect(preferReachableSameNameRows([live, { ...dead, ghost: true }])).toHaveLength(2)
+  })
+
+  it('does not mutate the input list', () => {
+    const input = [live, dead]
+
+    preferReachableSameNameRows(input)
+    expect(input).toHaveLength(2)
+  })
+})
+
+describe('needs-attention badge (#93091 item 3)', () => {
+  // Background failures whose class is attention-worthy (auth, quota, missing
+  // config, blocked) badge the roster tile; transient failures never do; the
+  // bot's next good turn clears it.
+  it('passes a typed reason code straight through', () => {
+    for (const code of ['agent_blocked', 'missing_config', 'provider_auth_or_access', 'provider_quota_limit']) {
+      noteBotAttention('radar', code)
+      expect($botAttention.get().radar.reason).toBe(code)
+    }
+  })
+
+  it('classifies the raw gateway error strings current backends emit', () => {
+    const reasonFor = (text: string) => {
+      $botAttention.set({})
+      noteBotAttention('radar', text)
+
+      return $botAttention.get().radar?.reason ?? null
+    }
+
+    // The anthropic 401 shape observed on current main.
+    expect(
+      reasonFor(
+        'Error code: 401 - {"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"}}'
+      )
+    ).toBe('provider_auth_or_access')
+    expect(reasonFor('No LLM provider configured. Run hermes model to pick one.')).toBe('missing_config')
+    expect(reasonFor('No access token found for profile')).toBe('missing_config')
+    expect(reasonFor('Your account is out of funds')).toBe('provider_quota_limit')
+    expect(reasonFor('quota exceeded for this billing period')).toBe('provider_quota_limit')
+    expect(reasonFor('agent is blocked awaiting approval')).toBe('agent_blocked')
+  })
+
+  it('never badges a transient class — a retryable error must not stick', () => {
+    for (const text of [
+      'Rate limit exceeded, retry shortly',
+      'Error code: 429 - too many requests',
+      '500 Internal Server Error',
+      'upstream 503 service unavailable',
+      'the model is overloaded, try again',
+      'request timed out after 180s',
+      'temporarily unavailable',
+      '',
+      null,
+      undefined
+    ]) {
+      $botAttention.set({})
+      noteBotAttention('radar', text)
+      expect($botAttention.get()).toEqual({})
+    }
+  })
+
+  it('keeps the latest failure per bot, independently, and clears on a good turn', () => {
+    noteBotAttention('radar', 'Error code: 401 authentication_error')
+
+    const first = $botAttention.get().radar
+
+    expect(first.reason).toBe('provider_auth_or_access')
+    expect(first.at).toBeGreaterThan(0)
+    expect(first.message).toMatch(/401/)
+
+    noteBotAttention('radar', 'No LLM provider configured')
+    expect($botAttention.get().radar.reason).toBe('missing_config')
+
+    noteBotAttention('dixie', 'quota exceeded')
+    expect($botAttention.get().dixie.reason).toBe('provider_quota_limit')
+
+    clearBotAttention('radar')
+    expect($botAttention.get().radar).toBeUndefined()
+    expect($botAttention.get().dixie.reason).toBe('provider_quota_limit')
+
+    // Clearing an unbadged bot is a no-op.
+    clearBotAttention('radar')
+    clearBotAttention('')
+    expect($botAttention.get().dixie.reason).toBe('provider_quota_limit')
+  })
+})
+
+describe('alias identity reaches the mention layer (#89131)', () => {
+  it('keeps @moxie resolving against the hosted row after handoff', () => {
+    indexAliasRoutes([{ connectionId: 'cloud-abc', mode: 'remote', profile: 'moxie', targetProfile: 'default' }])
+    $botMeta.set({ 'cloud-abc::moxie': { title: 'Moxie' } })
+
+    const hostedRow = row({
+      connectionId: 'cloud-abc',
+      name: 'default',
+      remoteSource: true,
+      sourceScoped: true,
+      targetProfile: 'default'
+    })
+
+    expect(botFriendlyNames(hostedRow).filter(Boolean)).toEqual(['Moxie'])
+    expect(botMentionTag(hostedRow)).toBe('moxie')
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/data.roster.test.tsx b/apps/desktop/src/plugins/hermes-bots/data.roster.test.tsx
new file mode 100644
index 000000000000..60f558c9b638
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/data.roster.test.tsx
@@ -0,0 +1,599 @@
+/**
+ * The multi-source roster merge, driven through the real `useRoster` query.
+ *
+ * The union agent roster (`host.agents`) enumerates EVERY registered
+ * connection — including the gateway that just answered `profiles.list`. The
+ * merge exists to fold the active source's agents into the rich rows it
+ * already has, and to append only the genuinely-other sources. Getting that
+ * classification wrong is the whole bug family this suite pins:
+ *
+ *  - #88344 — a remote-primary desktop listed every bot twice, because the
+ *    active gateway's own agents were appended as phantom rows;
+ *  - the live-id override — after the user activates a non-primary source,
+ *    `profiles.list` answers from THAT source, so classifying against the
+ *    registry primary duplicated the active source's agents all over again;
+ *  - #88828 + #88697 composed — a primary registered under two addresses
+ *    collapses to one union row carrying the PRIMARY's connection id, and the
+ *    boot descriptor now reports that same id, so those rows must annotate;
+ *  - connect-on-demand — SSH sources drop off the union the moment their
+ *    tunnel is not the live gateway, so clicking the local agent emptied Bot
+ *    Mode until previously-painted rows were carried forward.
+ */
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { renderHook, waitFor } from '@testing-library/react'
+import type { ReactNode } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { $lastRoster, useRoster } from './data'
+import type { RosterRow } from './types'
+
+const { hostMock } = vi.hoisted(() => ({
+  hostMock: {
+    agents: vi.fn(),
+    profileRoutes: undefined as unknown,
+    request: vi.fn(),
+    requestProfile: vi.fn(),
+    state: { connectionId: { get: vi.fn(() => 'local') }, profile: { get: () => 'default' } }
+  }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+  const { useQuery } = await import('@tanstack/react-query')
+
+  return {
+    atom,
+    host: hostMock,
+    queryClient: { getQueryData: vi.fn(), invalidateQueries: vi.fn() },
+    useQuery,
+    useValue: (store: { get: () => unknown }) => store.get()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+interface UnionAgent {
+  connectionId: string
+  connectionKind: string
+  connectionLabel?: string
+  handle: string
+  profile: string
+}
+
+interface Union {
+  agents: UnionAgent[]
+  primaryConnectionId?: string
+  sources?: Array<{ connectionId: string; error?: string; kind: string; reachable?: boolean }>
+}
+
+/** Gateway rows carry a session id on `last_session` that the plugin's
+ *  `SessionPreview` type deliberately does not model; the merge must carry it
+ *  through untouched, so the fixtures keep it. */
+interface RowFixture extends Omit<Partial<RosterRow>, 'last_session'> {
+  last_session?: { id?: string; last_active?: number; preview?: string }
+}
+
+/** Run the real roster query once and hand back the merged rows. */
+async function mergedRoster(
+  local: { profiles: RowFixture[] },
+  union: Union | null,
+  liveConnectionId: null | string = 'local'
+): Promise<RowFixture[]> {
+  hostMock.state.connectionId.get.mockReturnValue(liveConnectionId as string)
+  hostMock.request.mockResolvedValue(local)
+
+  if (union) {
+    hostMock.agents.mockResolvedValue(union)
+  } else {
+    hostMock.agents.mockRejectedValue(new Error('no union roster on this build'))
+  }
+
+  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>{children}</QueryClientProvider>
+  )
+
+  const { result } = renderHook(() => useRoster(), { wrapper })
+
+  await waitFor(() => expect(result.current.data).toBeTruthy())
+
+  return (result.current.data?.profiles ?? []) as RowFixture[]
+}
+
+const identities = (rows: RowFixture[]) => rows.map(row => `${row.connectionId}:${row.name}`)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  $lastRoster.set([])
+})
+
+afterEach(() => {
+  $lastRoster.set([])
+})
+
+describe('no union roster', () => {
+  it('leaves the local list exactly as it was', async () => {
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 's1', last_active: 1 }, name: 'default' }] },
+      null
+    )
+
+    expect(rows).toHaveLength(1)
+    expect(rows[0].name).toBe('default')
+    expect(rows[0].last_session?.id).toBe('s1')
+  })
+
+  it('appends nothing when the union is empty', async () => {
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 's1', last_active: 1 }, name: 'default' }] },
+      { agents: [] }
+    )
+
+    expect(identities(rows)).toEqual(['undefined:default'])
+  })
+})
+
+describe('the active source annotates; other sources append', () => {
+  it('keeps rich fields on the annotated row and tags the rest by source', async () => {
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 's1', last_active: 1 }, name: 'research' }] },
+      {
+        agents: [
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'research-this-device',
+            profile: 'research'
+          },
+          {
+            connectionId: 'homelab',
+            connectionKind: 'remote',
+            connectionLabel: 'Homelab',
+            handle: 'research-homelab',
+            profile: 'research'
+          },
+          {
+            connectionId: 'homelab',
+            connectionKind: 'remote',
+            connectionLabel: 'Homelab',
+            handle: 'coder',
+            profile: 'coder'
+          }
+        ]
+      }
+    )
+
+    expect(rows).toHaveLength(3)
+
+    const annotated = rows.find(row => row.name === 'research' && !row.remoteSource)!
+
+    expect(annotated.last_session?.id).toBe('s1')
+    expect(annotated.handle).toBe('research-this-device')
+    expect(annotated.sourceScoped).toBe(true)
+    expect(annotated.remoteSource).toBeUndefined()
+
+    expect(rows.find(row => row.name === 'research' && row.remoteSource)).toMatchObject({
+      connectionId: 'homelab',
+      connectionLabel: 'Homelab',
+      handle: 'research-homelab'
+    })
+    expect(rows.find(row => row.name === 'coder')).toMatchObject({ handle: 'coder', remoteSource: true })
+  })
+
+  it('never invents a thin row for an active-source profile profiles.list did not return', async () => {
+    // An older backend mid-refresh: skip rather than paint a bot that has no
+    // rich row behind it.
+    const rows = await mergedRoster(
+      { profiles: [{ name: 'default' }] },
+      {
+        agents: [
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'ghost',
+            profile: 'ghost'
+          }
+        ]
+      }
+    )
+
+    expect(rows.map(row => row.name)).toEqual(['default'])
+  })
+
+  it('renders duplicate source and local identities once', async () => {
+    const rows = await mergedRoster(
+      {
+        profiles: [
+          { last_session: { id: 'newest', last_active: 2 }, name: 'default' },
+          { last_session: { id: 'stale', last_active: 1 }, name: 'default' }
+        ]
+      },
+      {
+        agents: [
+          { connectionId: 'local', connectionKind: 'local', handle: 'default-this-device', profile: 'default' },
+          { connectionId: 'local', connectionKind: 'local', handle: 'default-this-device', profile: 'default' },
+          {
+            connectionId: 'homelab',
+            connectionKind: 'remote',
+            connectionLabel: 'Homelab',
+            handle: 'default-homelab',
+            profile: 'default'
+          },
+          {
+            connectionId: 'homelab',
+            connectionKind: 'remote',
+            connectionLabel: 'Homelab',
+            handle: 'default-homelab',
+            profile: 'default'
+          }
+        ]
+      }
+    )
+
+    expect(rows).toHaveLength(2)
+    expect(rows[0].last_session?.id).toBe('newest')
+    expect(rows[0].handle).toBe('default-this-device')
+    expect(rows[1].connectionId).toBe('homelab')
+  })
+
+  it('follows the ACTIVE remote source, so the local twin is the appended one', async () => {
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 'remote-session', last_active: 1 }, name: 'default' }] },
+      {
+        agents: [
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'default-this-device',
+            profile: 'default'
+          },
+          {
+            connectionId: 'work',
+            connectionKind: 'remote',
+            connectionLabel: 'Work',
+            handle: 'default-work',
+            profile: 'default'
+          }
+        ]
+      },
+      'work'
+    )
+
+    const active = rows.find(row => row.connectionId === 'work')!
+
+    expect(active.remoteSource).toBeUndefined()
+    expect(active.sourceScoped).toBe(true)
+    expect(active.last_session?.id).toBe('remote-session')
+    expect(rows.find(row => row.connectionId === 'local')).toMatchObject({
+      remoteSource: true,
+      sourceScoped: true
+    })
+  })
+
+  it('annotates every active-gateway agent instead of duplicating them (#88344)', async () => {
+    const primary = '10-244-108-128-9119'
+
+    const rows = await mergedRoster(
+      {
+        profiles: [
+          { last_session: { id: 's-default', last_active: 1 }, name: 'default' },
+          { last_session: { id: 's-dev', last_active: 1 }, name: 'dev' }
+        ]
+      },
+      {
+        agents: [
+          // The ACTIVE remote gateway itself — same identities as the rich
+          // rows, so it must annotate in place.
+          {
+            connectionId: primary,
+            connectionKind: 'remote',
+            connectionLabel: '10.244.108.128:9119',
+            handle: `default-${primary}`,
+            profile: 'default'
+          },
+          {
+            connectionId: primary,
+            connectionKind: 'remote',
+            connectionLabel: '10.244.108.128:9119',
+            handle: 'dev',
+            profile: 'dev'
+          },
+          // A genuinely separate source with a same-named profile keeps its row.
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'default-this-device',
+            profile: 'default'
+          },
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'agent-mentor',
+            profile: 'agent-mentor'
+          }
+        ],
+        primaryConnectionId: primary
+      },
+      primary
+    )
+
+    // 2 annotated rows + 2 other-source rows = 4, NOT 6.
+    expect(rows).toHaveLength(4)
+    expect(rows.filter(row => row.remoteSource)).toHaveLength(2)
+
+    const annotated = rows.find(row => row.name === 'default' && !row.remoteSource)!
+
+    expect(annotated.last_session?.id).toBe('s-default')
+    expect(annotated.handle).toBe(`default-${primary}`)
+    expect(rows.find(row => row.name === 'default' && row.remoteSource)).toMatchObject({
+      connectionId: 'local',
+      handle: 'default-this-device'
+    })
+  })
+
+  it('keeps single-source behavior on a primary-local desktop', async () => {
+    const rows = await mergedRoster(
+      { profiles: [{ name: 'default' }, { name: 'dev' }] },
+      {
+        agents: [
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'default-this-device',
+            profile: 'default'
+          },
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'dev',
+            profile: 'dev'
+          }
+        ],
+        primaryConnectionId: 'local'
+      }
+    )
+
+    expect(rows).toHaveLength(2)
+    expect(rows.filter(row => row.remoteSource)).toHaveLength(0)
+    expect(rows[0].handle).toBe('default-this-device')
+  })
+
+  it('lets the live id beat primaryConnectionId', async () => {
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 's1', last_active: 1 }, name: 'default' }] },
+      {
+        agents: [
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'default-this-device',
+            profile: 'default'
+          },
+          {
+            connectionId: 'vps',
+            connectionKind: 'remote',
+            connectionLabel: 'VPS',
+            handle: 'default-vps',
+            profile: 'default'
+          }
+        ],
+        primaryConnectionId: 'local'
+      },
+      'vps'
+    )
+
+    expect(rows).toHaveLength(2)
+    expect(rows.find(row => row.last_session)?.handle).toBe('default-vps')
+    expect(rows.filter(row => row.remoteSource).map(row => row.connectionId)).toEqual(['local'])
+  })
+
+  it('composes the install_id collapse with the live id, with no re-append (#88828 + #88697)', async () => {
+    const rows = await mergedRoster(
+      {
+        profiles: [
+          { last_session: { id: 's-default', last_active: 1 }, name: 'default' },
+          { last_session: { id: 's-dev', last_active: 1 }, name: 'dev' }
+        ]
+      },
+      {
+        agents: [
+          // Post-#88828 union: the tailscale twin of the primary collapsed
+          // into these rows — one per profile, keyed to the PRIMARY id.
+          {
+            connectionId: 'spark-lan',
+            connectionKind: 'remote',
+            connectionLabel: 'Spark',
+            handle: 'default-spark',
+            profile: 'default'
+          },
+          {
+            connectionId: 'spark-lan',
+            connectionKind: 'remote',
+            connectionLabel: 'Spark',
+            handle: 'dev',
+            profile: 'dev'
+          },
+          // A real second backend survives the collapse as its own row.
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'default-this-device',
+            profile: 'default'
+          }
+        ],
+        primaryConnectionId: 'spark-lan'
+      },
+      'spark-lan'
+    )
+
+    // Pre-fix (live id null) this was 5: both primary rows re-appended.
+    expect(rows).toHaveLength(3)
+    expect(rows.filter(row => row.remoteSource).map(row => row.connectionId)).toEqual(['local'])
+    expect(rows.find(row => row.name === 'default' && !row.remoteSource)).toMatchObject({
+      connectionId: 'spark-lan',
+      handle: 'default-spark'
+    })
+  })
+})
+
+describe('a null live id', () => {
+  it('does not treat the registry primary as active on a local window', async () => {
+    // Clicking the local agent leaves host.state.connectionId null while the
+    // registry primary stays on Spark. That must not skip Spark's bots or
+    // invent a second "This device" shadow of default.
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 'this-chat', last_active: 1 }, name: 'default' }] },
+      {
+        agents: [
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'default-this-device',
+            profile: 'default'
+          },
+          { connectionId: 'spark', connectionKind: 'ssh', connectionLabel: 'Spark', handle: 'bob', profile: 'bob' },
+          { connectionId: 'spark', connectionKind: 'ssh', connectionLabel: 'Spark', handle: 'kai', profile: 'kai' },
+          { connectionId: 'spark', connectionKind: 'ssh', connectionLabel: 'Spark', handle: 'rook', profile: 'rook' }
+        ],
+        primaryConnectionId: 'spark'
+      },
+      null
+    )
+
+    expect(rows.filter(row => row.name === 'default')).toHaveLength(1)
+    expect(rows.find(row => row.name === 'default')?.last_session?.id).toBe('this-chat')
+    expect(rows.filter(row => row.remoteSource && row.connectionId === 'local')).toHaveLength(0)
+    expect(
+      rows
+        .filter(row => row.remoteSource)
+        .map(row => row.name)
+        .sort()
+    ).toEqual(['bob', 'kai', 'rook'])
+  })
+
+  it('infers a matching remote primary when the local inventory does not match', async () => {
+    // Legacy remote descriptors carry mode:'remote' but no connectionId, so
+    // the host state reads null even though profiles.list is answering from
+    // the registry primary.
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 'noah-chat', last_active: 1 }, name: 'default' }] },
+      {
+        agents: [
+          {
+            connectionId: 'local',
+            connectionKind: 'local',
+            connectionLabel: 'This device',
+            handle: 'archie',
+            profile: 'archie'
+          },
+          {
+            connectionId: 'noah',
+            connectionKind: 'remote',
+            connectionLabel: 'Noah',
+            handle: 'default',
+            profile: 'default'
+          }
+        ],
+        primaryConnectionId: 'noah'
+      },
+      null
+    )
+
+    expect(rows).toHaveLength(2)
+
+    const inferred = rows.find(row => row.name === 'default')!
+
+    expect(inferred.connectionId).toBe('noah')
+    expect(inferred.remoteSource).toBeUndefined()
+    expect(rows.find(row => row.name === 'archie')).toMatchObject({ connectionId: 'local', remoteSource: true })
+  })
+})
+
+describe('connect-on-demand sources', () => {
+  const previouslyPainted = (connectionId: string) =>
+    [
+      { last_session: { id: 'this-chat', last_active: 1 }, name: 'default' },
+      {
+        connectionId,
+        connectionKind: 'ssh',
+        connectionLabel: 'Spark',
+        handle: 'bob',
+        name: 'bob',
+        remoteSource: true,
+        sourceScoped: true
+      }
+    ] as RosterRow[]
+
+  const localOnlyUnion = (sources: Union['sources']): Union => ({
+    agents: [
+      {
+        connectionId: 'local',
+        connectionKind: 'local',
+        connectionLabel: 'This device',
+        handle: 'default',
+        profile: 'default'
+      }
+    ],
+    primaryConnectionId: 'local',
+    sources
+  })
+
+  it('carries a previously painted remote row through an empty union', async () => {
+    $lastRoster.set(previouslyPainted('spark'))
+
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 'this-chat', last_active: 1 }, name: 'default' }] },
+      localOnlyUnion([{ connectionId: 'spark', error: 'connect-on-demand', kind: 'ssh' }])
+    )
+
+    expect(rows.find(row => row.name === 'bob' && row.connectionId === 'spark')).toMatchObject({ remoteSource: true })
+    expect(rows.filter(row => row.name === 'default')).toHaveLength(1)
+  })
+
+  it('does not resurrect a row whose connection was removed from the registry', async () => {
+    $lastRoster.set(previouslyPainted('gone'))
+
+    const rows = await mergedRoster(
+      { profiles: [{ last_session: { id: 'this-chat', last_active: 1 }, name: 'default' }] },
+      localOnlyUnion([{ connectionId: 'local', kind: 'local' }])
+    )
+
+    expect(rows.find(row => row.connectionId === 'gone')).toBeUndefined()
+  })
+})
+
+describe('a stalled profiles.list cannot pin the spinner forever', () => {
+  it('gives up after bounded retries and surfaces the error', async () => {
+    // `retry: true` keeps React Query in isLoading until the first success, so
+    // a stalled profiles.list (live state.db write lock, SSH flap) left the
+    // Bots sidebar on a spinner with no error card. The 5s refetchInterval and
+    // the gateway-open effect already recover drops.
+    hostMock.state.connectionId.get.mockReturnValue('local')
+    hostMock.request.mockRejectedValue(new Error('state.db is locked'))
+
+    const client = new QueryClient({ defaultOptions: { queries: { retryDelay: 0 } } })
+
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={client}>{children}</QueryClientProvider>
+    )
+
+    const { result } = renderHook(() => useRoster(), { wrapper })
+
+    await waitFor(() => expect(result.current.isError).toBe(true), { timeout: 5000 })
+
+    expect(result.current.isLoading).toBe(false)
+    expect(hostMock.request.mock.calls.length).toBeGreaterThan(1)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/data.ts b/apps/desktop/src/plugins/hermes-bots/data.ts
new file mode 100644
index 000000000000..188aa756c10f
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/data.ts
@@ -0,0 +1,1420 @@
+/**
+ * Bot Mode's domain layer: the roster query, bot metadata storage, the
+ * identity keys everything else is filed under, and needs-attention state.
+ *
+ * Framework-light — useRoster is the one React binding — and it depends only
+ * on routing.ts, for the owner descriptors it dispatches through.
+ */
+
+import { atom, host, queryClient, useQuery, useValue } from '@hermes/plugin-sdk'
+
+import { displayName } from './labels'
+import {
+  aliasIdentityFor,
+  beginAliasRouteIndex,
+  botConnectionRoute,
+  botRosterMeta,
+  botRouteKey,
+  botWorkspaceOwnerKey,
+  indexAliasRoutes,
+  requestForBot,
+  setBotsWorkspaceOwner
+} from './routing'
+import { getPluginCtx, ID } from './shared'
+import type {
+  AttentionClass,
+  BotMeta,
+  CanonicalSession,
+  GatewaySource,
+  GroupMember,
+  ProfileRoute,
+  RosterRow,
+  SessionPreview
+} from './types'
+
+export const ROSTER_KEY = [ID, 'roster']
+// Bounded retries. `retry: true` keeps React Query in isLoading until the
+// first success, so a stalled profiles.list (live state.db write lock, SSH
+// flap) leaves the Bots sidebar on a spinner with no error card. The 5s
+// refetchInterval and the gateway-open effect already recover drops.
+const ROSTER_QUERY_RETRY = 2
+
+export const BOT_META_V1_KEY = 'bot-meta'
+const BOT_META_V2_KEY = 'bot-meta-v2'
+const BOT_META_MIGRATION_KEY = 'bot-meta-v2-migrated'
+export let botMetaV2Active = false
+let botMetaV2Commit = Promise.resolve()
+const migratedLocalRoutes = new Map<string, ProfileRoute>()
+
+/** Live roster snapshot for imperative handlers (context menus). */
+export const $lastRoster = atom<RosterRow[]>([])
+
+// ── needs-attention badge (#93091 item 3) ───────────────────────────────────
+// Attention-worthy failure classes — matches the #93091 item-1 reason-code
+// enum (shipped separately). Until reason codes flow end-to-end,
+// attentionReasonFromError ALSO classifies raw error text as a fallback so
+// the badge works against current gateway error strings.
+const BOT_ATTENTION_CLASSES: ReadonlySet<string> = new Set<AttentionClass>([
+  'agent_blocked',
+  'provider_auth_or_access',
+  'provider_quota_limit',
+  'missing_config'
+])
+
+/** One-line user hint per attention class (roster badge tooltip). */
+export const BOT_ATTENTION_HINTS: Record<string, string> = {
+  provider_auth_or_access: 'Sign in again for this profile',
+  provider_quota_limit: 'Quota or balance exhausted',
+  missing_config: 'Provider not configured — run hermes model',
+  agent_blocked: 'Bot is blocked — see its last message'
+}
+
+/** Map an error (a #93091 reason code or raw error text) to an attention
+ *  class, or null when the failure is transient (rate limit, server error,
+ *  timeout) — transient classes must NEVER badge. Pure; tested directly. */
+function attentionReasonFromError(errorTextOrReason: unknown) {
+  const raw = String(errorTextOrReason || '').trim()
+
+  if (!raw) {
+    return null
+  }
+
+  if (BOT_ATTENTION_CLASSES.has(raw)) {
+    return raw
+  }
+
+  const text = raw.toLowerCase()
+
+  // Transient failures first, so a retryable error never sticks a badge.
+  if (
+    /rate.?limit|too many requests|\b429\b|\b5\d\d\b|server error|overloaded|timed?.?out|timeout|temporar/.test(text)
+  ) {
+    return null
+  }
+
+  if (/no llm provider|no access token|not configured|no api key|missing api key/.test(text)) {
+    return 'missing_config'
+  }
+
+  if (
+    /\b401\b|\b403\b|unauthorized|forbidden|authentication|invalid.?api.?key|credentials? (are )?(invalid|expired)/.test(
+      text
+    )
+  ) {
+    return 'provider_auth_or_access'
+  }
+
+  if (/quota|out of funds|insufficient (credits?|funds|balance)|payment required|\b402\b|billing/.test(text)) {
+    return 'provider_quota_limit'
+  }
+
+  if (/\bblocked\b/.test(text)) {
+    return 'agent_blocked'
+  }
+
+  return null
+}
+
+/** Per-bot needs-attention state: roster key -> {reason, at, message}.
+ *  Display-only presentation state (never persisted, never alters delivery).
+ *  Latest failure wins; the bot's next good turn clears it. Hidden bots keep
+ *  their entry — hiding is a roster-DISPLAY concern only. */
+export const $botAttention = atom<Record<string, { at: number; message: string; reason: string }>>({})
+
+/** Record attention for a bot after a failed turn/delivery. Transient errors
+ *  classify to null and set nothing. Latest failure wins. */
+export function noteBotAttention(key: string, errorTextOrReason: unknown) {
+  const reason = attentionReasonFromError(errorTextOrReason)
+
+  if (!key || !reason) {
+    return
+  }
+
+  $botAttention.set({
+    ...$botAttention.get(),
+    [key]: {
+      reason,
+      at: Date.now(),
+      message: String(errorTextOrReason || '')
+        .trim()
+        .slice(0, 200)
+    }
+  })
+}
+
+/** A good turn clears the badge. */
+export function clearBotAttention(key: string) {
+  if (!key || !$botAttention.get()[key]) {
+    return
+  }
+
+  const next = {
+    ...$botAttention.get()
+  }
+
+  delete next[key]
+  $botAttention.set(next)
+}
+
+/** The persisted record adds two keys the shared domain model deliberately
+ *  omits: `chat`, the dead canonical-chat pointer that mergeServerMeta strips
+ *  on sight, and `pet`, the extracted pet icon that stays local and is never
+ *  sent to the server. */
+interface StoredBotMeta extends BotMeta {
+  chat?: unknown
+  pet?: unknown
+}
+
+/** Appearance records keyed by meta key — `connectionId::profile`, or the bare
+ *  bot name on legacy single-source installs. */
+export type BotMetaSnapshot = Record<string, StoredBotMeta>
+
+/** `ctx.storage` as this file consumes it. `get` is optional because the write
+ *  path feature-detects it mid-body, and it is called without the SDK's
+ *  required `fallback`, so it resolves whatever JSON was persisted. */
+interface BotMetaStorage {
+  get?: (key: string, fallback?: unknown) => any
+  remove: (key: string) => unknown
+  set: (key: string, value: unknown) => unknown
+}
+
+/** Per-bot appearance + display meta, persisted via ctx.storage:
+ *  { [botName]: { shape, color, title } } */
+export const $botMeta = atom<BotMetaSnapshot>({})
+
+export function commitBotMetaV2(storage: BotMetaStorage | undefined, snapshot: BotMetaSnapshot) {
+  const commit = botMetaV2Commit.then(async () => {
+    if (typeof storage?.remove !== 'function' || typeof storage?.set !== 'function') {
+      throw new Error('bot metadata v2 storage is unavailable')
+    }
+
+    const [previousSnapshot, previousMarker] =
+      typeof storage.get === 'function'
+        ? await Promise.all([storage.get(BOT_META_V2_KEY), storage.get(BOT_META_MIGRATION_KEY)])
+        : [null, null]
+
+    const hasCommittedPrevious =
+      previousMarker === true &&
+      previousSnapshot &&
+      typeof previousSnapshot === 'object' &&
+      !Array.isArray(previousSnapshot)
+
+    try {
+      await storage.remove(BOT_META_MIGRATION_KEY)
+      await storage.set(BOT_META_V2_KEY, snapshot)
+      await storage.set(BOT_META_MIGRATION_KEY, true)
+    } catch (error) {
+      if (hasCommittedPrevious) {
+        try {
+          await storage.set(BOT_META_V2_KEY, previousSnapshot)
+          await storage.set(BOT_META_MIGRATION_KEY, true)
+        } catch {
+          await Promise.allSettled([storage.remove(BOT_META_MIGRATION_KEY), storage.remove(BOT_META_V2_KEY)])
+        }
+      } else {
+        await Promise.allSettled([BOT_META_MIGRATION_KEY, BOT_META_V2_KEY].map(key => storage.remove(key)))
+      }
+
+      throw error
+    }
+  })
+
+  botMetaV2Commit = commit.catch(() => undefined)
+
+  return commit
+}
+
+/** A save target resolved into the four things every write site needs. */
+interface BotOwner {
+  bot: RosterRow
+  key: string
+  name: string
+  route: null | ProfileRoute
+}
+
+export function botOwner(owner: RosterRow | string): BotOwner {
+  if (typeof owner === 'string') {
+    const name = owner.trim()
+    const route = migratedLocalRoutes.get(name)
+
+    return {
+      bot: route
+        ? {
+            name,
+            sourceScoped: true,
+            route
+          }
+        : {
+            name
+          },
+      name,
+      key: route ? botRouteKey(route) : name,
+      route: route || null
+    }
+  }
+
+  const name = String(owner?.name || '').trim()
+  const route = botConnectionRoute(owner)
+
+  return {
+    bot: owner,
+    name,
+    key: route ? botRouteKey(route) : name,
+    route
+  }
+}
+
+/** Freshness fence for the server-meta overlay: a roster snapshot fetched
+ * before the latest local/server metadata write must not overwrite it. */
+export const botMetaWriteAt = new Map<string, number>()
+
+/** How long a write can still outrank a roster snapshot. The overlay only
+ *  skips a bot while some snapshot ISSUED before the write is still landing,
+ *  and the roster refetches every 5s with retry backoff capped at 15s — well
+ *  inside a minute. Past that the stamp can never fence anything again, so
+ *  keeping it just grows the map for the life of the renderer. */
+const BOT_META_WRITE_FENCE_MS = 60_000
+
+export function noteBotMetaWrite(key: string) {
+  const now = Date.now()
+
+  for (const [written, at] of botMetaWriteAt) {
+    if (now - at > BOT_META_WRITE_FENCE_MS) {
+      botMetaWriteAt.delete(written)
+    }
+  }
+
+  botMetaWriteAt.set(key, now)
+}
+
+/** Three-way outcome of the server half of a save — see the block comment on
+ *  `serverOutcome` below for what separates 'unsupported' from 'failed'. */
+type BotMetaServerOutcome = 'failed' | 'persisted' | 'unsupported'
+
+interface BotMetaSaveResult {
+  serverOutcome: BotMetaServerOutcome
+  serverPersisted: boolean
+}
+
+/** `profiles.configure` reply. Older gateways answer without `applied` at all,
+ *  which is what makes the field optional rather than the contract. */
+interface ProfilesConfigureResult {
+  applied?: { ui_meta?: boolean }
+}
+
+export async function saveBotMeta(owner: RosterRow | string, patch: StoredBotMeta): Promise<BotMetaSaveResult> {
+  const { bot, key, name, route } = botOwner(owner)
+  const prevMeta = $botMeta.get()[key] || {}
+
+  const next = {
+    ...$botMeta.get(),
+    [key]: {
+      ...prevMeta,
+      ...patch
+    }
+  }
+
+  noteBotMetaWrite(key)
+  $botMeta.set(next)
+
+  // Local plugin storage: instant, and the fallback for older gateways.
+  let localPersistence = Promise.resolve()
+
+  try {
+    const persisted =
+      route || botMetaV2Active
+        ? commitBotMetaV2(getPluginCtx()?.storage, next)
+        : Promise.resolve(getPluginCtx()?.storage?.set?.(BOT_META_V1_KEY, next))
+
+    localPersistence = persisted.catch(() => undefined)
+  } catch {
+    /* storage unavailable — look persists for this window only */
+  }
+
+  // Server-side (source of truth when supported): profile.yaml ui_meta,
+  // namespaced under this plugin's id — every client machine sees the same
+  // roster. Return the outcome so user-initiated saves can distinguish a
+  // cross-machine save from a local-only fallback instead of reporting a
+  // false success. Data-URL fields are stripped from ui_meta (64KB cap,
+  // rides every profiles.list); the avatar IMAGE goes to the profile asset
+  // store instead (profiles.set_asset), which is server-side and uncapped by
+  // the list call — so pfps follow the profile across machines too.
+  let serverRequest: null | Promise<ProfilesConfigureResult> = null
+
+  try {
+    const { image, pet, ...rest } = next[key] || {}
+
+    const request = route
+      ? requestForBot(bot, 'profiles.configure', {
+          name,
+          ui_meta: {
+            'hermes-bots': rest
+          }
+        })
+      : host.request('profiles.configure', {
+          name,
+          ui_meta: {
+            'hermes-bots': rest
+          }
+        })
+
+    serverRequest = Promise.resolve(request) as Promise<ProfilesConfigureResult>
+  } catch {
+    /* older/unavailable gateway — the local fallback remains saved */
+  }
+
+  // Avatar image → profile asset store (feature-detected; local storage
+  // remains the fallback rendering source on older gateways) — but only when
+  // the image actually CHANGED. Every Edit Profile save sends the image key
+  // (changed or not); a no-op `clear` from one machine can race another
+  // machine's just-pushed avatar and wipe it server-side, and a no-op
+  // `data` push re-uploads the full data URL for nothing.
+  if ('image' in patch && patch.image !== (prevMeta.image ?? null)) {
+    try {
+      const req = patch.image
+        ? route
+          ? requestForBot(bot, 'profiles.set_asset', {
+              name,
+              asset: 'avatar',
+              data: patch.image
+            })
+          : host.request('profiles.set_asset', {
+              name,
+              asset: 'avatar',
+              data: patch.image
+            })
+        : route
+          ? requestForBot(bot, 'profiles.set_asset', {
+              name,
+              asset: 'avatar',
+              clear: true
+            })
+          : host.request('profiles.set_asset', {
+              name,
+              asset: 'avatar',
+              clear: true
+            })
+
+      req.catch(() => undefined)
+    } catch {
+      /* older gateway */
+    }
+  }
+
+  // Three-way outcome so callers can tell a REAL remote failure from the
+  // documented legacy fallback ("older gateways reject the param shape;
+  // that's fine, local wins"):
+  //   'persisted'   — gateway confirmed applied.ui_meta === true
+  //   'unsupported' — older gateway: request rejected, or response carries
+  //                   no `applied` contract at all. Silent local fallback;
+  //                   an error toast here would fire on EVERY save forever.
+  //   'failed'      — gateway speaks the contract and explicitly reported
+  //                   the ui_meta write did NOT apply.
+  let serverOutcome: BotMetaServerOutcome = 'unsupported'
+
+  if (serverRequest) {
+    try {
+      const result = await serverRequest
+
+      if (result?.applied?.ui_meta === true) {
+        serverOutcome = 'persisted'
+      } else if (result && typeof result === 'object' && result.applied && typeof result.applied === 'object') {
+        serverOutcome = 'failed'
+      }
+    } catch {
+      /* older/unavailable gateway — the local fallback remains saved */
+    }
+
+    // Re-stamp now that the server write settled: a roster snapshot fetched
+    // while profiles.configure was still in flight predates the new ui_meta
+    // just as surely as one fetched before the local write.
+    noteBotMetaWrite(key)
+  }
+
+  await localPersistence
+
+  return {
+    serverPersisted: serverOutcome === 'persisted',
+    serverOutcome
+  }
+}
+
+/** Migrate name-keyed appearance state only when the live registry proves
+ * there is one local source. A v1 name cannot identify a machine in a
+ * multi-source desktop, so the conservative result there is to retain v1 as
+ * rollback data and leave remote rows unpainted. */
+function hydrateBotMeta(snapshot: BotMetaSnapshot, remap: Map<string, string> | null = null): BotMetaSnapshot {
+  const next = {
+    ...snapshot
+  }
+
+  for (const [key, meta] of Object.entries($botMeta.get())) {
+    const target = remap?.get(key) || key
+    next[target] = {
+      ...(next[target] || {}),
+      ...meta
+    }
+  }
+
+  $botMeta.set(next)
+
+  return next
+}
+
+export async function migrateBotMeta(storage: BotMetaStorage | undefined = getPluginCtx()?.storage) {
+  let v1: BotMetaSnapshot | null = null
+  let v2: BotMetaSnapshot | null = null
+  let v2Committed = false
+
+  try {
+    ;[v1, v2, v2Committed] = await Promise.all([
+      storage?.get?.(BOT_META_V1_KEY),
+      storage?.get?.(BOT_META_V2_KEY),
+      storage?.get?.(BOT_META_MIGRATION_KEY)
+    ])
+  } catch {
+    return false
+  }
+
+  if (v2Committed === true && v2 && typeof v2 === 'object' && !Array.isArray(v2)) {
+    hydrateBotMeta(v2)
+    botMetaV2Active = true
+
+    return true
+  }
+
+  if (!v1 || typeof v1 !== 'object' || Array.isArray(v1) || typeof host.agents !== 'function') {
+    if (v1 && typeof v1 === 'object' && !Array.isArray(v1)) {
+      hydrateBotMeta(v1)
+    }
+
+    return false
+  }
+
+  let union
+  let routes
+
+  try {
+    union = await host.agents()
+    routes = typeof host.profileRoutes === 'function' ? await host.profileRoutes() : []
+  } catch {
+    hydrateBotMeta(v1)
+
+    return false
+  }
+
+  const sources = Array.isArray(union?.sources) ? union.sources : []
+  const localAgents = (union?.agents || []).filter(agent => agent?.connectionKind === 'local')
+
+  const soleLocal =
+    sources.length === 1
+      ? sources[0]?.kind === 'local'
+      : sources.length === 0 &&
+        localAgents.length > 0 &&
+        (union?.agents || []).every(agent => agent?.connectionKind === 'local')
+
+  if (!soleLocal) {
+    hydrateBotMeta(v1)
+
+    return false
+  }
+
+  const migrated: BotMetaSnapshot = {}
+  const pendingLocalRoutes = new Map<string, ProfileRoute>()
+
+  for (const [name, meta] of Object.entries(v1)) {
+    const route =
+      (routes || []).find(candidate => candidate?.mode === 'local' && candidate?.profile === name) ||
+      (() => {
+        const agent = localAgents.find(candidate => candidate.profile === name)
+
+        return agent
+          ? {
+              connectionId: agent.connectionId,
+              mode: 'local',
+              profile: name,
+              targetProfile: agent.targetProfile || name
+            }
+          : null
+      })()
+
+    if (!route?.connectionId) {
+      // A missing route makes the topology proof unusable for this key. Keep
+      // the v1 record intact rather than guessing a local/remote projection.
+      hydrateBotMeta(v1)
+
+      return false
+    }
+
+    const captured: ProfileRoute = {
+      connectionId: route.connectionId,
+      mode: 'local',
+      profile: name,
+      targetProfile: route.targetProfile || name
+    }
+
+    migrated[botRouteKey(captured)] = meta
+    pendingLocalRoutes.set(name, captured)
+  }
+
+  const remap = new Map([...pendingLocalRoutes].map(([name, route]) => [name, botRouteKey(route)]))
+
+  const hydrated = {
+    ...migrated
+  }
+
+  for (const [key, meta] of Object.entries($botMeta.get())) {
+    const target = remap.get(key) || key
+    hydrated[target] = {
+      ...(hydrated[target] || {}),
+      ...meta
+    }
+  }
+
+  try {
+    await commitBotMetaV2(storage, hydrated)
+  } catch {
+    botMetaV2Active = false
+    hydrateBotMeta(v1)
+
+    return false
+  }
+
+  migratedLocalRoutes.clear()
+
+  for (const [name, route] of pendingLocalRoutes) {
+    migratedLocalRoutes.set(name, route)
+  }
+
+  hydrateBotMeta(hydrated)
+  botMetaV2Active = true
+
+  return true
+}
+
+// ── data ─────────────────────────────────────────────────────────────────────
+
+/** True once profiles.list reports the backend injects the bot-to-bot
+ *  protocol into the system prompt itself (hermes-agent bot_mode_probe).
+ *  Gates every SOUL.md protocol append below. */
+export let serverInjectsProtocol = false
+
+/** A `profiles.list` answer as Bot Mode consumes it, plus the fields the
+ *  multi-source merge and the roster query stamp on afterwards. Not in
+ *  types.ts: this is the query-cache envelope around RosterRow, not a domain
+ *  object. */
+interface RosterSnapshot {
+  /** Newer backends inject the teammate protocol into the system prompt. */
+  bot_mode_protocol?: boolean
+  /** Time the request was ISSUED, the conservative bound mergeServerMeta wants. */
+  fetchedAt?: number
+  primaryConnectionId?: string
+  profiles?: RosterRow[]
+  sources?: GatewaySource[]
+}
+
+/** One row of the desktop-wide union agent roster (`host.agents`). */
+interface UnionAgentRow {
+  connectionId?: string
+  connectionKind?: string
+  connectionLabel?: string
+  handle?: string
+  profile?: string
+  targetProfile?: string
+}
+
+/** The union roster payload. `primaryConnectionId` is served by Electron but
+ *  absent from the SDK's `DesktopAgentRoster`, so the merge reads it here. */
+interface UnionRoster {
+  agents?: UnionAgentRow[]
+  primaryConnectionId?: string
+  sources?: GatewaySource[]
+}
+
+export function useRoster() {
+  const activeConnectionId = useValue(host.state.connectionId)
+
+  return useQuery({
+    queryKey: [...ROSTER_KEY, activeConnectionId],
+    queryFn: async () => {
+      // Stamp the ISSUE time on the snapshot: mergeServerMeta compares it
+      // against each bot's last local meta write, and a fetch issued before
+      // a write can only carry pre-write ui_meta. (Issue time is the
+      // conservative bound — the server answered no earlier than this.)
+      const issuedAt = Date.now()
+
+      // Rich rows (last_session, canonical_session, ui_meta, has_avatar)
+      // come from the ACTIVE gateway's profiles.list — the canonical Bot
+      // Chat is resolved server-side by NAME (the "Bot Chat" registry row),
+      // so the roster never sends session pointers.
+      // Refresh the alias identity index alongside the roster: alias routes
+      // (Desktop profile → remote backend root) are what let a backend row
+      // keep its configured friendly identity after activation (#89131).
+      // Best-effort and feature-detected — a failed read keeps the last
+      // good index rather than dropping identities mid-session.
+      if (typeof host.profileRoutes === 'function') {
+        const epoch = beginAliasRouteIndex()
+
+        try {
+          indexAliasRoutes(await host.profileRoutes(), epoch)
+        } catch {
+          /* keep the previous alias index */
+        }
+      }
+
+      // Owner routing is ambient in the SDK now (post-#92731): requestForBot
+      // resolves the active owner itself, no captured route needed here.
+      const activeBot = {
+        name: String(host.state.profile?.get?.() || 'default').trim() || 'default'
+      }
+
+      const local = await requestForBot<RosterSnapshot>(activeBot, 'profiles.list', {})
+      // Newer backends inject the teammate-messaging protocol into every
+      // session's system prompt (agent.bot_mode_protocol) — SOUL.md must not
+      // carry a second copy. Older gateways lack the flag: keep appending.
+      serverInjectsProtocol = Boolean(local?.bot_mode_protocol)
+
+      // Multi-source desktops (hermes-agent #86875) also expose the union
+      // agent roster across every registered connection. Merge agents from
+      // OTHER sources in as additional rows. Feature-detected + best-effort:
+      // an older Desktop build (no host.agents) or a roster hiccup leaves
+      // the local list exactly as it was.
+      if (typeof host.agents === 'function') {
+        try {
+          const union = await host.agents()
+          const previous: RosterRow[] = $lastRoster.get().filter(row => !row?.ghost)
+          const merged = mergeMultiSourceRoster(local, union, activeConnectionId, previous)
+          const sources = Array.isArray(union?.sources) ? union.sources : []
+
+          return {
+            ...merged,
+            profiles: (merged?.profiles || []).map(row => annotateBotSource(row, sources)),
+            sources,
+            fetchedAt: issuedAt
+          }
+        } catch {
+          /* older build or roster failure — single-source list stands */
+        }
+      }
+
+      return {
+        ...(local && typeof local === 'object' ? local : {}),
+        fetchedAt: issuedAt
+      }
+    },
+    refetchInterval: 5000,
+    staleTime: 5000,
+    retry: ROSTER_QUERY_RETRY,
+    retryDelay: attempt => Math.min(15000, 1000 * 2 ** attempt)
+  })
+}
+
+/** Synchronous union-roster read for the composer surfaces (autocomplete
+ *  provider + mention middleware). useRoster caches under
+ *  [...ROSTER_KEY, activeConnectionId] — a 3-element key — so a bare
+ *  getQueryData(ROSTER_KEY) exact-match lookup returns undefined forever
+ *  (issue #89303: remote handles absent from @ autocomplete, mentions
+ *  unrouted). Read the live connection's entry first, then fall back to a
+ *  prefix scan keeping the freshest snapshot. Never throws: cold cache or
+ *  legacy queryClient returns null and callers fall back to their own path. */
+export function cachedUnionRoster(): RosterSnapshot | null {
+  if (typeof queryClient === 'undefined' || !queryClient || typeof queryClient.getQueryData !== 'function') {
+    return null
+  }
+
+  try {
+    const connectionId = String(host.state.connectionId?.get?.() || host.activeConnectionId?.() || 'local')
+    const exact = queryClient.getQueryData<RosterSnapshot>([...ROSTER_KEY, connectionId])
+
+    if (Array.isArray(exact?.profiles)) {
+      return exact
+    }
+
+    if (typeof queryClient.getQueriesData === 'function') {
+      let best: RosterSnapshot | null = null
+
+      // v5 takes a filters object; a legacy v3 queryClient treats the same
+      // object as the key itself and simply matches nothing — harmless.
+      for (const [, data] of queryClient.getQueriesData<RosterSnapshot>({
+        queryKey: ROSTER_KEY
+      })) {
+        if (Array.isArray(data?.profiles) && (!best || Number(data.fetchedAt || 0) > Number(best.fetchedAt || 0))) {
+          best = data
+        }
+      }
+
+      return best
+    }
+  } catch {
+    /* cache hiccup — caller falls back (middleware refetches) */
+  }
+
+  return null
+}
+
+/** Merge the union agent roster (host.agents) over the active gateway's
+ *  profiles.list. Active-source rows — matched by the LIVE connection id,
+ *  falling back to the roster's primaryConnectionId, then the legacy
+ *  kind==='local' rule on older desktops — are the agents profiles.list
+ *  already returned: they only ANNOTATE the rich rows (handle, connection
+ *  fields); rich fields stay authoritative and they are NOT duplicated.
+ *  Rows from other sources become new roster entries tagged with their
+ *  source label so BotRow can badge them, warm the captured agent, and route
+ *  every open directly through that descriptor. Pure — exercised directly by
+ *  the tests. */
+function mergeMultiSourceRoster(
+  local: RosterSnapshot | null | undefined,
+  union: UnionRoster | null | undefined,
+  activeConnectionId?: null | string,
+  previous: RosterRow[] = []
+): RosterSnapshot {
+  const localProfiles = Array.isArray(local?.profiles) ? local.profiles : []
+  const agents = Array.isArray(union?.agents) ? union.agents : []
+  // A live id of null/'' means the window is on the unscoped local backend
+  // (legacy hosts reported null for mode:'local'; the SDK now reports
+  // 'local'). Do NOT fall back to registry primary when the third argument
+  // was passed — primary can still say "spark" after the user clicked a
+  // local bot, which skipped every Spark row as "active" and invented a
+  // This-device shadow of default.
+  const liveProvided = arguments.length >= 3
+  const liveId = String(activeConnectionId || '').trim()
+  let activeId = liveId || (liveProvided ? '' : String(union?.primaryConnectionId || '').trim())
+
+  // Migrated remote-primary windows can still expose a legacy remote
+  // descriptor without connectionId. That produces a null live id even
+  // though profiles.list is answering from the registry primary. Infer the
+  // primary only when its inventory matches the rich rows and the local
+  // inventory does not. A genuinely local window has a matching local row,
+  // so it keeps the null-is-local behavior used after clicking This device.
+  if (!activeId && liveProvided) {
+    const primaryId = String(union?.primaryConnectionId || '').trim()
+    const richNames = new Set(localProfiles.map(profile => String(profile?.name || '').trim()).filter(Boolean))
+
+    const localMatches = agents.some(
+      agent => agent?.connectionKind === 'local' && richNames.has(String(agent?.profile || '').trim())
+    )
+
+    const primaryMatches = agents.some(
+      agent =>
+        String(agent?.connectionId || '').trim() === primaryId && richNames.has(String(agent?.profile || '').trim())
+    )
+
+    if (!localMatches && primaryId && primaryMatches) {
+      activeId = primaryId
+    }
+  }
+
+  const activeByName = new Map<string, RosterRow>()
+
+  // Treat the rich list as one row per active-source profile. Clone every
+  // row: some gateway clients reuse response objects, and annotating those in
+  // place made each five-second refresh feed the previous union back into the
+  // next merge, growing duplicate source rows indefinitely.
+  for (const profile of localProfiles) {
+    const name = String(profile?.name || '').trim()
+
+    if (!name || profile?.remoteSource) {
+      continue
+    }
+
+    if (profile?.sourceScoped && activeId && profile.connectionId !== activeId) {
+      continue
+    }
+
+    if (!activeByName.has(name)) {
+      activeByName.set(name, {
+        ...profile,
+        name
+      })
+    }
+  }
+
+  const profiles = [...activeByName.values()]
+
+  // host.agents is an Electron/main-process capability. Defend the plugin
+  // boundary too: older shells or reconnect races can still hand us repeated
+  // identities even after the core roster deduplicates them.
+  const seenSources = new Set<string>()
+
+  for (const agent of agents) {
+    const profile = String(agent?.profile || '').trim()
+    const connectionId = String(agent?.connectionId || '').trim()
+    const sourceKey = `${connectionId}::${profile || 'default'}`
+
+    if (!profile || seenSources.has(sourceKey)) {
+      continue
+    }
+
+    seenSources.add(sourceKey)
+
+    // The union enumerates EVERY registered connection, including the active
+    // gateway that already answered profiles.list. Without this the active
+    // gateway's own agents (connectionKind 'remote' on a remote-primary
+    // desktop) would be appended as phantom duplicates — every bot listed
+    // twice. Older Electron builds predate the connection ids; fall back to
+    // the legacy local-source rule so single-source behavior stays intact.
+    const isActiveSource = activeId ? connectionId === activeId : agent.connectionKind === 'local'
+    const row = isActiveSource ? activeByName.get(profile) : null
+
+    if (row) {
+      // Annotate in place: the @name-device handle only differs from the
+      // bare name when the profile exists on several sources.
+      row.handle = agent.handle
+      row.connectionId = agent.connectionId
+      row.connectionKind = agent.connectionKind
+      row.connectionLabel = agent.connectionLabel
+      row.targetProfile = agent.targetProfile || profile
+      row.route = {
+        connectionId,
+        mode: agent.connectionKind === 'local' ? 'local' : 'remote',
+        profile,
+        targetProfile: agent.targetProfile || profile
+      }
+      row.sourceScoped = true
+
+      continue
+    }
+
+    if (isActiveSource) {
+      // Union saw an active-source profile profiles.list didn't return (older
+      // backend mid-refresh) — skip rather than invent a thin row.
+      continue
+    }
+
+    profiles.push({
+      name: profile,
+      handle: agent.handle,
+      connectionId,
+      connectionKind: agent.connectionKind,
+      connectionLabel: agent.connectionLabel,
+      targetProfile: agent.targetProfile || profile,
+      route: {
+        connectionId,
+        mode: agent.connectionKind === 'local' ? 'local' : 'remote',
+        profile,
+        targetProfile: agent.targetProfile || profile
+      },
+      remoteSource: true,
+      sourceScoped: true
+    })
+  }
+
+  // SSH sources drop to connect-on-demand the moment their tunnel is not
+  // the live gateway. Keep previously painted remote rows so clicking the
+  // local agent does not empty Bot Mode.
+  if (Array.isArray(previous) && previous.length > 0) {
+    const present = new Set(profiles.map(row => `${row.connectionId || ''}::${row.name}`))
+    const unionSourceIds = new Set(agents.map(agent => String(agent?.connectionId || '').trim()).filter(Boolean))
+
+    const omitted = new Set(
+      (Array.isArray(union?.sources) ? union.sources : [])
+        .filter(source => source?.error === 'connect-on-demand' || source?.reachable === false)
+        .map(source => String(source.connectionId || '').trim())
+        .filter(Boolean)
+    )
+
+    const registered = new Set(
+      (Array.isArray(union?.sources) ? union.sources : [])
+        .map(source => String(source?.connectionId || '').trim())
+        .filter(Boolean)
+    )
+
+    for (const row of previous) {
+      const connectionId = String(row?.connectionId || '').trim()
+      const name = String(row?.name || '').trim()
+      const key = `${connectionId}::${name || 'default'}`
+
+      if (!row?.remoteSource || !connectionId || !name || present.has(key)) {
+        continue
+      }
+
+      if (registered.size > 0 && !registered.has(connectionId)) {
+        continue
+      }
+
+      if (omitted.has(connectionId) || !unionSourceIds.has(connectionId)) {
+        profiles.push({
+          ...row,
+          remoteSource: true,
+          sourceScoped: true
+        })
+        present.add(key)
+      }
+    }
+  }
+
+  return {
+    ...local,
+    profiles
+  }
+}
+
+/** The @handle users tag a bot with. Multi-source rosters precompute the
+ *  handle (bare name, or name-device when the profile exists on several
+ *  registered sources) — prefer it when present. The primary profile's
+ *  callable alias is 'hermes' — the mention middleware resolves it back to
+ *  'default' — so the word 'default' never surfaces in the UI. */
+export function botHandle(name: string, bot?: Partial<RosterRow> | null): string {
+  if (bot?.handle && bot.handle !== name) {
+    return bot.handle
+  }
+
+  return (name || '').trim().toLowerCase() === 'default' ? 'hermes' : name
+}
+
+/** Taggable @-forms derived from a bot's friendly names — the core profile
+ *  display name (`hermes profile rename`) and the Bot Mode title. Free text
+ *  reduces to the mention charset two ways: slugified ("Research Buddy" →
+ *  research-buddy, the form autocomplete inserts) and collapsed
+ *  (researchbuddy). Reserved tokens are dropped so a bot renamed "Hermes"
+ *  can never hijack the primary profile's @hermes alias. */
+export function mentionNameForms(value: null | string | undefined): string[] {
+  const name = String(value || '')
+    .trim()
+    .toLowerCase()
+
+  if (!name) {
+    return []
+  }
+
+  const slug = name.replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '')
+  const collapsed = name.replace(/[^a-z0-9_-]+/g, '')
+
+  return [...new Set([slug, collapsed])].filter(
+    form => /^[a-z0-9][a-z0-9_-]*$/.test(form) && !['all', 'everyone', 'user', 'default', 'hermes'].includes(form)
+  )
+}
+
+/** Every friendly (renameable) name a roster row carries: the Bot Mode title
+ *  (server-synced via ui_meta, locally stored, or persisted on a durable
+ *  group descriptor) and the core profile display_name — in displayName's
+ *  precedence order. Remote rows never borrow local meta (two `default`s
+ *  must not share a title) — EXCEPT the connection-exact alias identity
+ *  (#89131): a backend row claimed by a configured alias route carries the
+ *  alias's friendly names, so @moxie keeps resolving after handoff. */
+export function botFriendlyNames(bot: Partial<RosterRow> | null | undefined): Array<null | string | undefined> {
+  const metaByName: Record<string, BotMeta | undefined> | null = typeof $botMeta !== 'undefined' ? $botMeta.get() : null
+  const localTitle = !bot?.remoteSource ? metaByName?.[bot?.name!]?.title : null
+  const alias = aliasIdentityFor(bot)
+
+  const aliasTitle = alias
+    ? alias.metaKeys.map(key => metaByName?.[key]?.title).find(title => typeof title === 'string' && title.trim()) ||
+      alias.name
+    : null
+
+  return [bot?.ui_meta?.['hermes-bots']?.title, localTitle, aliasTitle, bot?.title, bot?.display_name]
+}
+
+/** The tag autocomplete inserts for a bot: the renamed (friendly) slug when
+ *  the user gave the bot a real name, otherwise the profile @handle. The
+ *  resolvers accept both, so older muscle memory keeps working. */
+export function botMentionTag(bot: GroupMember | RosterRow): string {
+  for (const friendly of botFriendlyNames(bot)) {
+    const forms = mentionNameForms(friendly)
+
+    if (forms.length) {
+      return forms[0]
+    }
+  }
+
+  return botHandle(bot?.name, bot)
+}
+
+/** Who a roster row is being compared against: a profile name plus the
+ *  registry connection it lives on. Covers the focused chat's owner, the live
+ *  gateway pair, and the bare `{ name }` the mention provider builds. */
+interface RosterOwnerRef {
+  connectionId?: null | string
+  name?: null | string
+}
+
+export function isActiveRosterBot(
+  bot: Partial<RosterRow> | null | undefined,
+  active: RosterOwnerRef | null | undefined
+) {
+  if (!active) {
+    return false
+  }
+
+  const activeName = String(active.name || 'default').trim() || 'default'
+  const activeId = String(active?.connectionId || '').trim()
+  const botId = String(bot?.connectionId || '').trim()
+  const botName = String(bot?.name || '').trim() || 'default'
+
+  if (bot?.remoteSource) {
+    return Boolean(activeId) && activeId === botId && botName === activeName
+  }
+
+  if (activeId && activeId !== 'local' && botId && activeId !== botId) {
+    return false
+  }
+
+  return botName === activeName
+}
+
+/** The key a bot is selected/badged/watermarked under. `undefined` is
+ *  load-bearing on the nullable overload — callers use it to CLEAR a
+ *  selection, so it must never be coerced to a 'default' fallback the way
+ *  botRosterKey does. A real row always yields a key (`name` is required). */
+/* eslint-disable no-redeclare -- overload signatures; the rule predates TS */
+export function botSelectionKey(bot: RosterRow): string
+export function botSelectionKey(bot: Partial<RosterRow> | null | undefined): string | undefined
+
+export function botSelectionKey(bot: Partial<RosterRow> | null | undefined): string | undefined {
+  return bot?.sourceScoped || bot?.remoteSource ? botRosterKey(bot) : bot?.name
+}
+/* eslint-enable no-redeclare */
+
+export function isDefaultBot(bot: Partial<RosterRow> | null | undefined): boolean {
+  const route = botConnectionRoute(bot)
+
+  return (
+    String(route?.profile || bot?.name || '')
+      .trim()
+      .toLowerCase() === 'default'
+  )
+}
+
+export function newBotChat(bot: RosterRow) {
+  if (typeof host.newChat !== 'function') {
+    host.notify?.({
+      kind: 'error',
+      message:
+        getPluginCtx()?.i18n?.t('bot.openAnotherChatUnsupported') ?? 'Update Hermes Desktop to open another Bot chat.'
+    })
+
+    return
+  }
+
+  const route = botConnectionRoute(bot)
+
+  if (!route) {
+    host.notify?.({
+      kind: 'error',
+      message:
+        getPluginCtx()?.i18n?.t('bot.openAnotherChatUnsupported') ?? 'Update Hermes Desktop to open another Bot chat.'
+    })
+
+    return
+  }
+
+  const ownerKey = botWorkspaceOwnerKey(bot)
+  setBotsWorkspaceOwner(ownerKey, bot)
+  host.newChat(route, {
+    workspaceMode: 'bots',
+    workspaceOwnerKey: ownerKey
+  })
+}
+
+/** Resolve @handles in prose against the Bot Mode roster (local + Connections).
+ *  Skips the bot already speaking in this chat. Unique bare names match;
+ *  duplicate names require the @name-device handle. */
+export function resolveRosterMentions(
+  text: null | string | undefined,
+  roster: RosterRow[] | null | undefined,
+  active: RosterOwnerRef = {}
+): RosterRow[] {
+  const members = Array.isArray(roster) ? roster : []
+
+  const prose = String(text || '')
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/`[^`\n]*`/g, ' ')
+
+  const byForm = new Map<string, RosterRow | null>()
+
+  for (const bot of members) {
+    if (!bot?.name || isActiveRosterBot(bot, active)) {
+      continue
+    }
+
+    const handle = String(botHandle(bot.name, bot) || '').toLowerCase()
+    const name = String(bot.name || '').toLowerCase()
+    const forms = new Set([handle, name])
+
+    if (bot.handle) {
+      forms.add(String(bot.handle).toLowerCase())
+    }
+
+    // Renamed bots are taggable by their friendly names too — the core
+    // profile display_name and the Bot Mode title (issue: renaming a bot
+    // didn't change what you @-tag it with).
+    for (const friendly of botFriendlyNames(bot)) {
+      for (const form of mentionNameForms(friendly)) {
+        forms.add(form)
+      }
+    }
+
+    for (const form of forms) {
+      if (!form) {
+        continue
+      }
+
+      const existing = byForm.get(form)
+
+      if (existing && existing !== bot) {
+        byForm.set(form, null)
+
+        continue
+      }
+
+      if (!existing) {
+        byForm.set(form, bot)
+      }
+    }
+  }
+
+  const mentioned: RosterRow[] = []
+  const seen = new Set<string>()
+
+  for (const match of prose.matchAll(/(^|\s)@([a-z0-9][a-z0-9_-]*)/gi)) {
+    let token = match[2].toLowerCase()
+
+    if (token === 'hermes') {
+      token = byForm.has('hermes') ? 'hermes' : token
+    }
+
+    const bot = byForm.get(token)
+
+    if (!bot) {
+      continue
+    }
+
+    const key = botRosterKey(bot)
+
+    if (seen.has(key)) {
+      continue
+    }
+
+    seen.add(key)
+    mentioned.push(bot)
+  }
+
+  return mentioned
+}
+
+/** Source-qualified identity for a roster row — the React list key AND the
+ *  cross-surface roster identity. Names alone are NOT unique in a
+ *  multi-source roster (two connections can both expose 'default');
+ *  duplicate keys make React reconciliation repeat whole blocks of the list
+ *  on every poll repaint (the Aug 2026 dupe-bots smear). */
+export function botRosterKey(bot: Partial<RosterRow> | null | undefined): string {
+  return `${bot?.connectionId || 'legacy'}::${bot?.name || 'default'}`
+}
+
+/** The key a bot's persisted appearance/meta lives under. Same nullable
+ *  contract as botSelectionKey: a real row always resolves to a key, a
+ *  partial/absent one may not. */
+/* eslint-disable no-redeclare -- overload signatures; the rule predates TS */
+export function botMetaKey(bot: RosterRow): string
+export function botMetaKey(bot: Partial<RosterRow> | null | undefined): string | undefined
+
+export function botMetaKey(bot: Partial<RosterRow> | null | undefined): string | undefined {
+  const route = botConnectionRoute(bot)
+
+  return route ? botRouteKey(route) : bot?.name
+}
+/* eslint-enable no-redeclare */
+
+export function persistBotMetaSnapshot(value: Record<string, BotMeta>, scoped = false): Promise<void> {
+  try {
+    const persisted = scoped
+      ? commitBotMetaV2(getPluginCtx()?.storage, value)
+      : Promise.resolve(getPluginCtx()?.storage?.set?.(BOT_META_V1_KEY, value))
+
+    return persisted.catch(() => undefined)
+  } catch {
+    return Promise.resolve()
+  }
+}
+
+export function sourceByConnection(sources: GatewaySource[] | null | undefined): Map<string, GatewaySource> {
+  return new Map(
+    (Array.isArray(sources) ? sources : [])
+      .filter(source => source?.connectionId)
+      .map(source => [String(source.connectionId), source])
+  )
+}
+
+/** Copy current source health onto a row without changing its owner. */
+export function annotateBotSource(bot: RosterRow, sources: GatewaySource[] | null | undefined): RosterRow {
+  const id = String(bot?.connectionId || '').trim()
+
+  if (!id) {
+    return bot
+  }
+
+  const list = Array.isArray(sources) ? sources : []
+  const source = sourceByConnection(list).get(id)
+
+  if (!source) {
+    return list.length && bot?.sourceScoped
+      ? {
+          ...bot,
+          sourceMissing: true,
+          sourceReachable: false
+        }
+      : bot
+  }
+
+  return {
+    ...bot,
+    connectionKind: bot.connectionKind || source.kind,
+    connectionLabel: bot.connectionLabel || source.label,
+    sourceError: source.error || null,
+    sourceMissing: false,
+    sourceReachable: source.reachable
+  }
+}
+
+/** The source-health fields botSourceStatus reads. Both a full RosterRow and
+ *  the reduced GroupMember satisfy it, and so do the ad-hoc literals the
+ *  group/connection headers build. */
+interface BotSourceFields {
+  ghost?: boolean
+  name?: string
+  sourceError?: null | string
+  sourceMissing?: boolean
+  sourceReachable?: boolean | null
+}
+
+/** How a row's owning gateway is doing, as the roster paints it. */
+interface BotSourceStatus {
+  available: boolean
+  key: 'missing' | 'on-demand' | 'ready' | 'unavailable' | 'unknown'
+  label: string
+  tone: 'bad' | 'good' | 'muted' | 'warn'
+}
+
+/** Called from plain functions rather than components, so there is no `useBots`
+ *  to lean on and the ctx may not be installed yet — the English text is the
+ *  floor, not the intended reading. Guard `i18n` as well as the ctx: this runs
+ *  on every roster row, and a throw here paints an empty rail. */
+function sourceLabel(key: string, fallback: string): string {
+  return getPluginCtx()?.i18n?.t(`roster.${key}`) ?? fallback
+}
+
+export function botSourceStatus(bot: BotSourceFields | null | undefined): BotSourceStatus {
+  const error = String(bot?.sourceError || '').trim()
+
+  if (bot?.sourceMissing) {
+    return {
+      available: false,
+      key: 'missing',
+      label: sourceLabel('gatewayRemoved', 'Gateway removed'),
+      tone: 'bad'
+    }
+  }
+
+  if (error === 'connect-on-demand') {
+    return {
+      available: true,
+      key: 'on-demand',
+      label: sourceLabel('onDemand', 'On demand'),
+      tone: 'muted'
+    }
+  }
+
+  if (error || bot?.sourceReachable === false) {
+    return {
+      available: false,
+      key: 'unavailable',
+      label: sourceLabel('unavailable', 'Unavailable'),
+      tone: 'warn'
+    }
+  }
+
+  if (bot?.sourceReachable === true) {
+    return {
+      available: true,
+      key: 'ready',
+      label: sourceLabel('ready', 'Ready'),
+      tone: 'good'
+    }
+  }
+
+  return {
+    available: true,
+    key: 'unknown',
+    label: sourceLabel('statusUnknown', 'Status unknown'),
+    tone: 'muted'
+  }
+}
+
+/** Drop unreachable same-name copies from the top-level agent list.
+ *
+ *  Group rooms persist source-qualified members. After Desktop moves to the
+ *  built-in This-device source, the old loopback row (127.0.0.1:port, not
+ *  listening) still sits next to the live profile and looks like a second
+ *  agent (#92286). Routing identities stay intact: this only filters sidebar
+ *  tiles. $lastRoster, group members, and @-mentions still see every
+ *  (connectionId, profile) row.
+ *
+ *  Ghosts stay: a selected-but-offline owner must remain visible rather than
+ *  being replaced by a same-named twin on another gateway. A name with no
+ *  reachable copy is kept, so a genuinely down source still has a row. */
+export function preferReachableSameNameRows(bots: RosterRow[] | null | undefined): RosterRow[] {
+  const rows = Array.isArray(bots) ? bots : []
+  const reachableNames = new Set<string>()
+
+  for (const bot of rows) {
+    if (botSourceStatus(bot).available) {
+      reachableNames.add(bot?.name)
+    }
+  }
+
+  return rows.filter(bot => botSourceStatus(bot).available || bot?.ghost || !reachableNames.has(bot?.name))
+}
+
+/** Filter by the two stable identities rendered in every roster row: the
+ * customizable display name and the profile's @handle. Keep the current
+ * activity order — search narrows the roster, it never re-ranks it. */
+export function filterBots(roster: RosterRow[], metaByName: Record<string, BotMeta>, query: string) {
+  const needle = query.trim().toLowerCase().replace(/^@/, '')
+
+  if (!needle) {
+    return roster
+  }
+
+  return roster.filter(bot => {
+    const meta = botRosterMeta(bot, metaByName)
+    const display = displayName(bot, meta).toLowerCase()
+    const profile = (bot.name || '').toLowerCase()
+    const handle = botHandle(bot.name, bot).toLowerCase()
+    // Multi-source rows also match on their device name ("homelab" finds
+    // every bot living on the Homelab connection).
+    const sourceLabel = (bot.connectionLabel || '').toLowerCase()
+    const role = `${meta?.description || ''} ${bot.description || ''}`.toLowerCase()
+    const preview = String(botActivitySession(bot)?.preview || '').toLowerCase()
+
+    return (
+      display.includes(needle) ||
+      profile.includes(needle) ||
+      handle.includes(needle) ||
+      sourceLabel.includes(needle) ||
+      role.includes(needle) ||
+      preview.includes(needle)
+    )
+  })
+}
+
+/** The session whose activity best represents this bot — the FRESHER of the
+ *  canonical Bot Chat (canonical_session, the profile's "Bot Chat" registry
+ *  row resolved server-side by name) and the profile's newest visible
+ *  conversation (last_session).
+ *
+ *  Canonical Bot Chats are hidden from the session list by design, so
+ *  last_session alone never sees them: a bot you talk to all day through its
+ *  Bot Chat reads "6d ago" because its newest VISIBLE session is a week old.
+ *  Every activity signal (age label, pulse dot, unread watermark, recency
+ *  sort) keys off this helper. Older gateways without the canonical_session
+ *  field degrade to last_session unchanged. */
+export function botActivitySession(bot: null | RosterRow | undefined): CanonicalSession | SessionPreview | null {
+  const preferred = bot?.canonical_session
+  const last = bot?.last_session
+
+  if (!preferred || !last) {
+    return preferred || last || null
+  }
+
+  return (preferred.last_active || 0) >= (last.last_active || 0) ? preferred : last
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/dialog-parts.tsx b/apps/desktop/src/plugins/hermes-bots/dialog-parts.tsx
new file mode 100644
index 000000000000..5c0655bdd2c1
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/dialog-parts.tsx
@@ -0,0 +1,43 @@
+/**
+ * The presentation leaves every Bot Mode dialog shares: a labelled control, and
+ * the frame the embedded Capabilities surface is rendered into.
+ *
+ * They sit below the dialogs rather than inside any one of them — the model
+ * picker, the advanced editor, Edit Profile, New Bot and the routines dialogs
+ * all render the same label-over-control pair, and none of them can own it
+ * without the others importing a sibling surface.
+ */
+
+import type { ReactNode } from 'react'
+
+export function labeled(label: ReactNode, control: ReactNode) {
+  return (
+    <div className="grid gap-1.5">
+      <label className="text-xs font-medium text-(--ui-text-secondary)">{label}</label>
+      {control}
+    </div>
+  )
+}
+
+interface ResizableFrameProps {
+  children: ReactNode
+  /** CSS `resize` has nothing to drag from without a concrete height, and the
+   *  two surfaces that embed Capabilities budget it different room. */
+  height: number
+  minHeight: number
+}
+
+/** A fixed-height viewport with the native vertical resize handle. */
+export function ResizableFrame({ children, height, minHeight }: ResizableFrameProps) {
+  return (
+    <div
+      className="resize-y overflow-auto rounded-md border border-(--ui-stroke-secondary)"
+      style={{
+        height,
+        minHeight
+      }}
+    >
+      {children}
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/edit-profile-dialog.tsx b/apps/desktop/src/plugins/hermes-bots/edit-profile-dialog.tsx
new file mode 100644
index 000000000000..65cd02af8750
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/edit-profile-dialog.tsx
@@ -0,0 +1,259 @@
+/**
+ * Edit Profile: appearance, title, description, and the advanced profile
+ * config disclosure for an existing bot.
+ */
+
+import {
+  Button,
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DisclosureCaret,
+  host,
+  Input,
+  queryClient,
+  Textarea,
+  useI18n,
+  useValue
+} from '@hermes/plugin-sdk'
+import { useState } from 'react'
+
+import { avatarColor, botAppearance, BotFace } from './avatar'
+import { AvatarPicker } from './avatar-picker'
+import { $botMeta, botSelectionKey, ROSTER_KEY, saveBotMeta } from './data'
+import { labeled } from './dialog-parts'
+import { useBots } from './i18n'
+import { displayName } from './labels'
+import { AdvancedProfileConfig, applyAdvancedConfig, emptyAdvancedState } from './profile-config'
+import { botRosterMeta, requestForBot } from './routing'
+import type { AvatarAppearance, RosterRow } from './types'
+
+// ── edit profile dialog ──────────────────────────────────────────────────────
+
+/** AvatarAppearance, minus the `image` guarantee — the dialog's no-bot fallback
+ *  literal doesn't supply one. See the TODO in EditProfileDialog. */
+interface EditProfileAppearance extends Omit<AvatarAppearance, 'image'> {
+  image?: null | string
+}
+interface EditProfileDialogProps {
+  bot: null | RosterRow
+  onClose: () => void
+  open: boolean
+}
+
+export function EditProfileDialog({ bot, open, onClose }: EditProfileDialogProps) {
+  const { t } = useI18n()
+  const b = useBots()
+  const metaAll = useValue($botMeta)
+  const meta = bot ? botRosterMeta(bot, metaAll) : null
+
+  // TODO(bot-mode-types): the no-bot fallback omits `image`, which the state
+  // seeding below reads — `appearance.image` is undefined on that branch, so
+  // this is NOT an AvatarAppearance. Harmless today only because the component
+  // returns null a few lines down when `bot` is null, so the seeded value is
+  // thrown away before anything renders.
+  const appearance: EditProfileAppearance = bot
+    ? botAppearance(bot.name, meta)
+    : {
+        shape: 'circle',
+        color: null
+      }
+
+  const [shape, setShape] = useState(appearance.shape)
+  const [color, setColor] = useState<null | string>(appearance.color)
+  const [image, setImage] = useState<null | string>(appearance.image ?? null)
+  const [title, setTitle] = useState(meta?.title || '')
+  const [description, setDescription] = useState(bot?.description || '')
+  const [busy, setBusy] = useState(false)
+  const [advanced, setAdvanced] = useState(false)
+  const [adv, setAdv] = useState(emptyAdvancedState())
+
+  // Re-seed local state each time a different bot opens the dialog.
+  const [seedKey, setSeedKey] = useState<null | string>(null)
+  const currentKey = bot ? `${botSelectionKey(bot)}:${open}` : null
+
+  if (currentKey !== seedKey) {
+    setSeedKey(currentKey)
+
+    if (bot && open) {
+      setShape(appearance.shape)
+      setColor(appearance.color)
+      setImage(appearance.image ?? null)
+      setTitle(meta?.title || '')
+      setDescription(bot.description || '')
+      setBusy(false)
+      setAdvanced(false)
+      setAdv(emptyAdvancedState())
+    }
+  }
+
+  if (!bot) {
+    return null
+  }
+
+  const submit = async () => {
+    if (busy) {
+      return
+    }
+
+    setBusy(true)
+    let advancedFailed = false
+
+    const persistence = await saveBotMeta(bot, {
+      shape,
+      color: color ?? undefined,
+      image,
+      imageKind: image ? 'photo' : 'shape',
+      title: title.trim(),
+      custom: true
+    })
+
+    // Only an explicit remote failure is an error — 'unsupported' is the
+    // documented older-gateway fallback (local wins, silently), and toasting
+    // it would flag every save on every legacy setup forever.
+    const lookFailed = persistence.serverOutcome === 'failed'
+
+    if (lookFailed) {
+      host.notify({
+        kind: 'error',
+        message: b.avatar.savedLocally
+      })
+    }
+
+    if (persistence.serverOutcome === 'persisted') {
+      queryClient.invalidateQueries({
+        queryKey: ROSTER_KEY
+      })
+    }
+
+    const desc = description.trim()
+
+    if (desc !== (bot.description || '').trim()) {
+      try {
+        await requestForBot(bot, 'cli.exec', {
+          argv: ['profile', 'describe', bot.name, '--text', desc]
+        })
+        queryClient.invalidateQueries({
+          queryKey: ROSTER_KEY
+        })
+      } catch (err) {
+        host.notifyError(err, b.avatar.savedLocallyDescriptionFailed)
+      }
+    }
+
+    if (adv.loaded && (adv.dirtyModel || adv.dirtySoul || adv.dirtySkills || adv.dirtyToolsets || adv.dirtyMcp)) {
+      try {
+        const res = await applyAdvancedConfig(bot, adv)
+        const failed = Object.entries(res?.applied || {}).filter(([, ok]) => !ok)
+
+        if (failed.length) {
+          advancedFailed = true
+          host.notify({
+            kind: 'error',
+            message: `Some sections failed: ${failed.map(([k]) => k).join(', ')}`
+          })
+        }
+      } catch (err) {
+        advancedFailed = true
+        host.notifyError(err, b.bot.advancedFailed)
+      }
+    }
+
+    if (!advancedFailed && !lookFailed) {
+      host.notify({
+        kind: 'success',
+        message: `${displayName(bot, {
+          title
+        })} updated`
+      })
+    }
+
+    setBusy(false)
+    onClose()
+  }
+
+  return (
+    <Dialog onOpenChange={value => !value && !busy && onClose()} open={open}>
+      <DialogContent
+        className={advanced ? 'max-w-3xl' : 'max-w-sm'} // Same resizable-window treatment as the create dialog.
+        style={
+          advanced
+            ? {
+                resize: 'both',
+                overflow: 'auto',
+                minWidth: 420,
+                minHeight: 360,
+                maxWidth: '95vw',
+                maxHeight: '90vh'
+              }
+            : undefined
+        }
+      >
+        <DialogHeader>
+          <DialogTitle>{b.bot.editTitle}</DialogTitle>
+          <DialogDescription>{`Appearance and role for ${displayName(bot, null)} (${bot.name}).`}</DialogDescription>
+        </DialogHeader>
+        <div className="grid gap-4">
+          <div className="flex justify-center py-1">
+            <BotFace color={avatarColor(color, bot.name)} image={image} name={bot.name} shape={shape} size={64} />
+          </div>
+          <AvatarPicker
+            color={color}
+            generateSeed={{
+              name: bot.name,
+              title,
+              description
+            }}
+            image={image}
+            onColor={setColor}
+            onImage={setImage}
+            onShape={setShape}
+            shape={shape}
+          />
+          {labeled(
+            'Title',
+            <Input
+              onChange={event => setTitle(event.target.value)}
+              placeholder={displayName(bot, null)}
+              value={title}
+            />
+          )}
+          {labeled(
+            'Description',
+            <Textarea
+              className="min-h-16"
+              onChange={event => setDescription(event.target.value)}
+              placeholder={b.bot.helpPromptPlaceholder}
+              value={description}
+            />
+          )}
+          <Button
+            className="flex items-center gap-1 text-xs font-medium text-(--ui-text-tertiary) hover:text-(--ui-text-secondary)"
+            onClick={() => setAdvanced(v => !v)}
+            size="inline"
+            variant="text"
+          >
+            <DisclosureCaret open={advanced} />
+            {b.bot.advancedHint}
+          </Button>
+          {advanced ? (
+            <div className="rounded-md border border-(--ui-stroke-secondary) p-3">
+              <AdvancedProfileConfig bot={bot} setState={setAdv} state={adv} />
+            </div>
+          ) : null}
+        </div>
+        <DialogFooter>
+          <Button disabled={busy} onClick={onClose} variant="ghost">
+            {t.common.cancel}
+          </Button>
+          <Button disabled={busy} onClick={submit}>
+            {busy ? t.common.saving : t.common.save}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-activity.test.ts b/apps/desktop/src/plugins/hermes-bots/group-activity.test.ts
new file mode 100644
index 000000000000..dab490020b72
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-activity.test.ts
@@ -0,0 +1,271 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as data from './data'
+import type { GroupActivityEntry } from './group-activity'
+import type * as groupActivity from './group-activity'
+import type * as groupChat from './group-chat'
+import type * as groupRounds from './group-rounds'
+import { createGroupGateway, drain, runTimersInline, scriptedStorage } from './group-test-utils'
+import type { GatewayOptions, ScriptedGateway } from './group-test-utils'
+import type { GroupMember } from './types'
+
+// Collapsible group Activity view: a runtime-only, bounded feed of truthful
+// turn events (queued / working / replied / passed / timed-out / failed /
+// cancelled / settled / delivered) that the room shows in a quiet disclosure.
+// The transcript stays the only durable record — activity is never persisted.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+
+  return pluginSdkMock(host)
+})
+
+const MEMBERS: GroupMember[] = [
+  { name: 'research', title: '' },
+  { name: 'builder', title: '' },
+  { name: 'ops', title: 'The Ops' }
+]
+
+/** A failed turn's activity row carries the typed reason the gateway sent.
+ *  `recordGroupActivity` spreads it through, so it isn't on the entry type. */
+type ActivityRow = GroupActivityEntry & { reason?: string }
+
+interface Room {
+  activity: typeof groupActivity
+  chat: typeof groupChat
+  data: typeof data
+  gateway: ScriptedGateway
+  rounds: typeof groupRounds
+}
+
+async function loadRoom(options: GatewayOptions = {}): Promise<Room> {
+  vi.resetModules()
+  const gateway = createGroupGateway(options)
+
+  for (const key of Object.keys(host)) {
+    delete host[key]
+  }
+
+  Object.assign(host, gateway.host)
+
+  const [activity, chat, data, rounds, shared] = await Promise.all([
+    import('./group-activity'),
+    import('./group-chat'),
+    import('./data'),
+    import('./group-rounds'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx(scriptedStorage(gateway.storage))
+
+  return { activity, chat, data, gateway, rounds }
+}
+
+function feed(room: Room, group: string): ActivityRow[] {
+  return (room.activity.$groupActivity.get()[group]?.events || []) as ActivityRow[]
+}
+
+beforeEach(() => {
+  runTimersInline()
+})
+
+describe('turn arc', () => {
+  it('a settled turn records the full truthful arc: queued, working, replies and passes, settled', async () => {
+    const room = await loadRoom({
+      turn: ({ profile, prompt }) =>
+        profile === 'research' && !prompt.includes('(you)') ? 'I looked into it — ship it.' : '(pass)'
+    })
+
+    room.rounds.sendToGroupChat('Room', MEMBERS, 'please review')
+    await drain(() => Boolean(room.chat.$groupChats.get().Room?.running))
+
+    const events = feed(room, 'Room')
+    const kinds = events.map(event => event.kind)
+
+    expect(kinds[0]).toBe('queued')
+    expect(kinds[kinds.length - 1]).toBe('settled')
+    expect(kinds.filter(kind => kind === 'working').length).toBeGreaterThanOrEqual(3)
+    expect(kinds).toContain('replied')
+    expect(kinds.filter(kind => kind === 'passed').length).toBeGreaterThanOrEqual(2)
+    expect(events.find(event => event.kind === 'replied')?.member).toBe('research')
+  })
+
+  it('a failed member turn records failed instead of a phantom reply', async () => {
+    const room = await loadRoom({
+      turn: ({ profile }) => {
+        if (profile === 'builder') {
+          throw new Error('gateway hiccup')
+        }
+
+        return '(pass)'
+      }
+    })
+
+    room.rounds.sendToGroupChat('Flaky', MEMBERS, 'anyone around?')
+    await drain(() => Boolean(room.chat.$groupChats.get().Flaky?.running))
+
+    expect(feed(room, 'Flaky').some(event => event.kind === 'failed' && event.member === 'builder')).toBe(true)
+  })
+
+  it('a failed member turn preserves and prefers its typed reason', async () => {
+    const room = await loadRoom({
+      turn: ({ profile }) => {
+        if (profile === 'builder') {
+          throw Object.assign(new Error('generic gateway failure'), {
+            data: { reason: 'provider_auth_or_access' }
+          })
+        }
+
+        return '(pass)'
+      }
+    })
+
+    room.rounds.sendToGroupChat('Typed failure', MEMBERS, 'anyone around?')
+    await drain(() => Boolean(room.chat.$groupChats.get()['Typed failure']?.running))
+
+    const failed = feed(room, 'Typed failure').find(event => event.kind === 'failed' && event.member === 'builder')
+
+    expect(failed?.reason).toBe('provider_auth_or_access')
+    expect(Object.values(room.data.$botAttention.get())[0]?.reason).toBe('provider_auth_or_access')
+  })
+
+  it('an untyped failed member turn keeps the message-classification fallback', async () => {
+    const room = await loadRoom({
+      turn: ({ profile }) => {
+        if (profile === 'builder') {
+          throw new Error('No LLM provider configured')
+        }
+
+        return '(pass)'
+      }
+    })
+
+    room.rounds.sendToGroupChat('Untyped failure', MEMBERS, 'anyone around?')
+    await drain(() => Boolean(room.chat.$groupChats.get()['Untyped failure']?.running))
+
+    const failed = feed(room, 'Untyped failure').find(event => event.kind === 'failed' && event.member === 'builder')
+
+    expect(failed?.reason).toBeUndefined()
+    expect(Object.values(room.data.$botAttention.get())[0]?.reason).toBe('missing_config')
+  })
+})
+
+describe('epoch scoping', () => {
+  it('a newer send interrupts the previous run and records cancelled in the CURRENT epoch', async () => {
+    const gates = new Map<number, { promise: Promise<string>; resolve: (value: string) => void }>()
+
+    const gate = (n: number) => {
+      const existing = gates.get(n)
+
+      if (existing) {
+        return existing.promise
+      }
+
+      let resolve!: (value: string) => void
+
+      const promise = new Promise<string>(settle => {
+        resolve = settle
+      })
+
+      gates.set(n, { promise, resolve })
+
+      return promise
+    }
+
+    const room = await loadRoom({ turn: ({ n }) => gate(n) })
+    const member: GroupMember[] = [{ name: 'research', title: '' }]
+
+    room.rounds.sendToGroupChat('Busy', member, 'first ask')
+    await drain(() => room.gateway.calls.length < 1, 50)
+    room.rounds.sendToGroupChat('Busy', member, 'second ask, supersede')
+    await drain(() => room.gateway.calls.length < 2, 50)
+
+    gates.get(2)?.resolve('from the new run')
+    await drain(() => Boolean(room.chat.$groupChats.get().Busy?.running))
+    gates.get(1)?.resolve('late from the old run')
+    await drain(() => false)
+
+    const epoch = room.chat.$groupChats.get().Busy?.epoch || 0
+
+    expect(feed(room, 'Busy').some(event => event.kind === 'cancelled')).toBe(true)
+    // The view shows only the current run: every visible event is this epoch.
+    expect(room.activity.currentGroupActivity('Busy').every(event => (event.epoch || 0) === epoch)).toBe(true)
+    expect(room.activity.currentGroupActivity('Busy').some(event => event.kind === 'cancelled')).toBe(true)
+  })
+
+  it('epoch filtering drops events from a superseded run', async () => {
+    const room = await loadRoom()
+    room.chat.updateGroupChat('Epoch', current => {
+      current.log = []
+      current.epoch = 5
+
+      return current
+    })
+    room.activity.recordGroupActivity('Epoch', { kind: 'queued', member: 'You' })
+    room.activity.recordGroupActivity('Epoch', { kind: 'working', member: 'research' })
+
+    room.chat.updateGroupChat('Epoch', current => {
+      current.epoch = 6
+
+      return current
+    })
+
+    expect(room.activity.currentGroupActivity('Epoch')).toHaveLength(0)
+
+    room.activity.recordGroupActivity('Epoch', { kind: 'working', member: 'research' })
+    const current = room.activity.currentGroupActivity('Epoch')
+
+    expect(current).toHaveLength(1)
+    expect(current[0].kind).toBe('working')
+  })
+})
+
+describe('feed shape', () => {
+  it('the feed is bounded: it stops growing and keeps the newest events', async () => {
+    const room = await loadRoom()
+    room.chat.updateGroupChat('Cap', current => {
+      current.log = []
+
+      return current
+    })
+
+    for (let i = 0; i < 500; i++) {
+      room.activity.recordGroupActivity('Cap', { kind: 'working', member: `member-${i}` })
+    }
+
+    const bounded = feed(room, 'Cap')
+
+    expect(bounded.length).toBeLessThan(500)
+    expect(bounded[bounded.length - 1].member).toBe('member-499')
+    expect(bounded.some(event => event.member === 'member-0')).toBe(false)
+
+    room.activity.recordGroupActivity('Cap', { kind: 'working', member: 'one more' })
+
+    expect(feed(room, 'Cap')).toHaveLength(bounded.length)
+  })
+
+  it('activity is runtime-only: never persisted, never hydrated', async () => {
+    const room = await loadRoom()
+
+    room.rounds.sendToGroupChat('Volatile', MEMBERS, 'hello')
+    await drain(() => Boolean(room.chat.$groupChats.get().Volatile?.running))
+
+    expect(feed(room, 'Volatile').length).toBeGreaterThan(0)
+    expect([...room.gateway.storage.keys()]).not.toContain('group-activity')
+  })
+
+  it('labels read like a person wrote them, with settled/cancelled as room-level lines', async () => {
+    const { activity } = await loadRoom()
+
+    const label = (event: Omit<GroupActivityEntry, 'at' | 'epoch'>) =>
+      activity.groupActivityLabel({ at: 0, epoch: 0, ...event })
+
+    expect(label({ kind: 'queued', member: 'You' })).toBe('You sent a message')
+    expect(label({ kind: 'replied', member: 'research' })).toBe('research replied')
+    expect(label({ kind: 'timed-out', member: 'ops' })).toBe('ops took too long')
+    expect(label({ kind: 'cancelled', member: null })).toBe('turn interrupted by a newer message')
+    expect(label({ kind: 'settled', member: null })).toBe('turn settled')
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-activity.ts b/apps/desktop/src/plugins/hermes-bots/group-activity.ts
new file mode 100644
index 000000000000..fb5be2f09cff
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-activity.ts
@@ -0,0 +1,129 @@
+/**
+ * The per-room activity feed: a bounded, runtime-only record of turn events
+ * for the room view's collapsible Activity list.
+ *
+ * Depends on the room store (for the epoch it tags events with and the
+ * speaker label it renders) and on nothing else, so the coordination engine
+ * can record into it without a cycle.
+ */
+
+import { atom } from '@hermes/plugin-sdk'
+
+import { $groupChats, groupSpeakerLabel } from './group-chat'
+import type { GroupActivityEvent, GroupActivityKind } from './types'
+
+// ── group activity feed ─────────────────────────────────────────────────────
+// Runtime-only, bounded per-room record of turn events that feeds the
+// collapsible Activity view. Never persisted — it is presentation state like
+// running/epoch, and the room transcript (log) stays the only durable record.
+// Every event is tagged with the room epoch it belongs to, so the view shows
+// only the CURRENT run: a newer send bumps the epoch (old-run events drop
+// away), and a rename re-keys the room (the feed starts clean under the new
+// name — stale events under the old key simply have no room to attach to).
+const GROUP_ACTIVITY_LIMIT = 50
+
+/** A recorded activity row: the caller's event tagged with the room epoch.
+ *  Deliberately not `GroupActivityEvent` — the recorder never stamps `group`
+ *  (the atom is already keyed by it) and callers carry a `thread`. */
+export interface GroupActivityEntry extends Omit<GroupActivityEvent, 'group' | 'member'> {
+  epoch: number
+  member?: null | string
+  thread?: null | string
+}
+export const $groupActivity = atom<Record<string, { events: GroupActivityEntry[] }>>({})
+
+export function recordGroupActivity(group: string, event: Omit<GroupActivityEntry, 'at' | 'epoch'>) {
+  const room = $groupChats.get()[group]
+
+  if (!room) {
+    return null
+  }
+
+  const current = $groupActivity.get()[group] || {
+    events: []
+  }
+
+  const entry = {
+    at: Date.now(),
+    epoch: room.epoch || 0,
+    ...event
+  }
+
+  const events = [...current.events, entry].slice(-GROUP_ACTIVITY_LIMIT)
+  $groupActivity.set({
+    ...$groupActivity.get(),
+    [group]: {
+      ...current,
+      events
+    }
+  })
+
+  return entry
+}
+
+/** Events for the room's CURRENT run — superseded runs (epoch moved on)
+ *  are dropped from view instead of describing work that already ended. */
+export function currentGroupActivity(group: string) {
+  const epoch = ($groupChats.get()[group] || {}).epoch || 0
+
+  return ($groupActivity.get()[group] || {}).events?.filter(event => (event.epoch || 0) === epoch) || []
+}
+
+/** Human label for one activity event, used by the collapsed summary and
+ *  the expanded rows. */
+export function groupActivityLabel(event: GroupActivityEntry) {
+  const kind = event?.kind
+  const base = GROUP_ACTIVITY_LABELS[kind] || kind || 'did something'
+
+  if (kind === 'cancelled' || kind === 'settled' || kind === 'capped') {
+    return base
+  }
+
+  const who = event?.member === 'You' ? 'You' : groupSpeakerLabel(event?.member || 'A bot')
+
+  return `${who} ${base}`
+}
+
+const GROUP_ACTIVITY_LABELS: Record<GroupActivityKind, string> = {
+  queued: 'sent a message',
+  working: 'is working…',
+  replied: 'replied',
+  passed: 'passed',
+  'timed-out': 'took too long',
+  failed: 'hit an error',
+  cancelled: 'turn interrupted by a newer message',
+  settled: 'turn settled',
+  capped: 'turn stopped at the round/message cap',
+  delivered: 'delivered a late reply',
+  held: 'is held (stopped by you) — @mention it or say resume to release',
+  stopped: 'stopped the room — remaining turns are held until resumed'
+}
+
+export const GROUP_ACTIVITY_GLYPHS: Record<GroupActivityKind, string> = {
+  queued: 'comment',
+  working: 'sync',
+  replied: 'check',
+  passed: 'circle-outline',
+  'timed-out': 'clock',
+  failed: 'error',
+  cancelled: 'close',
+  settled: 'check-all',
+  capped: 'debug-step-over',
+  delivered: 'mail-read',
+  held: 'debug-pause',
+  stopped: 'debug-stop'
+}
+
+/** Text tone for an activity row: quiet for pass/cancel/settle, accent for
+ *  work and real replies, destructive for failures and timeouts. */
+export function groupActivityTone(kind: GroupActivityKind) {
+  if (kind === 'failed' || kind === 'timed-out') {
+    return 'text-destructive'
+  }
+
+  if (kind === 'working' || kind === 'replied' || kind === 'delivered') {
+    return 'text-(--ui-accent)'
+  }
+
+  return 'text-(--ui-text-tertiary)'
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-attachments.ts b/apps/desktop/src/plugins/hermes-bots/group-attachments.ts
new file mode 100644
index 000000000000..0c83fbcf5362
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-attachments.ts
@@ -0,0 +1,113 @@
+/**
+ * Group-chat attachments: turning picked, pasted, or dropped files into the
+ * data-URL payloads a room's members are shown.
+ *
+ * A leaf module — it talks to the DOM and the toast host, nothing else in Bot
+ * Mode.
+ */
+
+import { host } from '@hermes/plugin-sdk'
+
+import type { Attachment, AttachmentKind } from './types'
+
+// ── group-chat attachments: pick/paste/drop files the room's members see ────
+
+/** Classify a picked file for the group-attachment pipeline. */
+function groupAttachmentKind(file: File): AttachmentKind {
+  if (/^image\//.test(file.type || '')) {
+    return 'image'
+  }
+
+  if (file.type === 'application/pdf' || /\.pdf$/i.test(file.name || '')) {
+    return 'pdf'
+  }
+
+  return 'file'
+}
+
+/** File objects → [{ name, data, kind }] (data URLs), oversized files skipped
+ *  with a toast. Images are downscaled; PDFs and other files ride as raw data
+ *  URLs for the gateway's pdf.attach / file.attach staging. Shared by the
+ *  picker button, the composer paste handler, and room drag & drop. */
+export async function filesToGroupAttachments(files: File[] | FileList | null | undefined): Promise<Attachment[]> {
+  const picked: Attachment[] = []
+
+  for (const file of [...(files || [])]) {
+    if (!file) {
+      continue
+    }
+
+    if (file.size > 15_000_000) {
+      host.notify({
+        kind: 'error',
+        message: `${file.name || 'attachment'}: too large (max 15MB).`
+      })
+
+      continue
+    }
+
+    const data = await new Promise<null | string>(done => {
+      const reader = new FileReader()
+      reader.onload = () => done(typeof reader.result === 'string' ? reader.result : null)
+      reader.onerror = () => done(null)
+      reader.readAsDataURL(file)
+    })
+
+    if (!data) {
+      continue
+    }
+
+    const kind = groupAttachmentKind(file)
+    picked.push({
+      name: file.name || (kind === 'image' ? 'pasted image' : 'attachment'),
+      data: kind === 'image' ? await normalizeGroupAttachment(data) : data,
+      kind
+    })
+  }
+
+  return picked
+}
+
+/** Multi-file picker for the group composer — any file type; kind decides
+ *  the staging RPC. Resolves to [{ name, data, kind }]. */
+export function pickGroupAttachments(): Promise<Attachment[]> {
+  return new Promise(resolve => {
+    const input = document.createElement('input')
+    input.type = 'file'
+    input.multiple = true
+    input.onchange = () => resolve(filesToGroupAttachments(input.files))
+    input.click()
+  })
+}
+
+/** Bound a group attachment's long edge so room logs (persisted with the
+ *  plugin's other durable state) stay light while screenshots keep enough
+ *  resolution for vision models to read text. No-op for small images or
+ *  anything the canvas can't decode. */
+function normalizeGroupAttachment(dataUrl: string, maxEdge = 1568): Promise<string> {
+  return new Promise(resolve => {
+    const img = new Image()
+
+    img.onload = () => {
+      try {
+        const long = Math.max(img.width, img.height)
+
+        if (!long || long <= maxEdge) {
+          return resolve(dataUrl)
+        }
+
+        const scale = maxEdge / long
+        const canvas = document.createElement('canvas')
+        canvas.width = Math.max(1, Math.round(img.width * scale))
+        canvas.height = Math.max(1, Math.round(img.height * scale))
+        canvas.getContext('2d')!.drawImage(img, 0, 0, canvas.width, canvas.height)
+        resolve(canvas.toDataURL('image/png'))
+      } catch {
+        resolve(dataUrl)
+      }
+    }
+
+    img.onerror = () => resolve(dataUrl)
+    img.src = dataUrl
+  })
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-bot-handoff.test.ts b/apps/desktop/src/plugins/hermes-bots/group-bot-handoff.test.ts
new file mode 100644
index 000000000000..cfc21bdc0eca
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-bot-handoff.test.ts
@@ -0,0 +1,175 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as groupChat from './group-chat'
+import type * as groupChatView from './group-chat-view'
+import type * as groupPanes from './group-panes'
+import { createGroupGateway, runTimersInline, scriptedStorage } from './group-test-utils'
+import type { ScriptedGateway } from './group-test-utils'
+import type * as rosterActions from './roster-actions'
+import type { GroupChat, RosterRow } from './types'
+
+// Clicking a bot while a group room owns the center is a HANDOFF: the room's
+// main-window tab has to be retired before the canonical chat opens, or two
+// surfaces fight for the center. And if the open fails, the room the user was
+// reading has to come back — the failed action must not steal the center.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+const { openBotCanonicalChat, prepareBotSource } = vi.hoisted(() => ({
+  openBotCanonicalChat: vi.fn(),
+  prepareBotSource: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+  const base = await pluginSdkMock(host)
+
+  return {
+    ...base,
+    ackStoredSessionId: vi.fn(),
+    haptic: vi.fn(),
+    markSessionUnreadFinished: vi.fn()
+  }
+})
+
+vi.mock('./canonical-chat', () => ({
+  notifyBotOpenFailure: (...args: unknown[]) => {
+    failures.push(args)
+  },
+  openBotCanonicalChat: (...args: unknown[]) => openBotCanonicalChat(...args),
+  prepareBotSource: (...args: unknown[]) => prepareBotSource(...args)
+}))
+
+const failures: unknown[][] = []
+
+interface Room {
+  actions: typeof rosterActions
+  chat: typeof groupChat
+  gateway: ScriptedGateway
+  panes: typeof groupPanes
+  view: typeof groupChatView
+}
+
+async function loadRoom(): Promise<Room> {
+  vi.resetModules()
+  const gateway = createGroupGateway()
+
+  for (const key of Object.keys(host)) {
+    delete host[key]
+  }
+
+  Object.assign(host, gateway.host)
+
+  const [actions, chat, panes, view, shared] = await Promise.all([
+    import('./roster-actions'),
+    import('./group-chat'),
+    import('./group-panes'),
+    import('./group-chat-view'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx(scriptedStorage(gateway.storage))
+
+  return { actions, chat, gateway, panes, view }
+}
+
+const BOT: RosterRow = { name: 'alpha', title: 'Alpha' }
+
+/** Seat a room and front it as a main-window tab, recording tab closes in
+ *  the order they happen relative to the canonical open. */
+function registerGroup(room: Room, group: string, timeline: string[]) {
+  room.chat.$groupChats.set({
+    ...room.chat.$groupChats.get(),
+    [group]: { log: [], sessions: {}, watermarks: {} }
+  } as unknown as Record<string, GroupChat>)
+  host.openWorkspace = (id: string) => () => timeline.push(`close:${id}`)
+  room.view.openGroupChat(group)
+}
+
+beforeEach(() => {
+  runTimersInline()
+  failures.length = 0
+  prepareBotSource.mockReset().mockResolvedValue(undefined)
+  openBotCanonicalChat.mockReset().mockResolvedValue({ openedId: 'stored-chat', registryId: 'stored-chat' })
+})
+
+describe('opening a bot from a fronted room', () => {
+  it('retires the group tab BEFORE the canonical open', async () => {
+    const timeline: string[] = []
+    const room = await loadRoom()
+    registerGroup(room, 'Core', timeline)
+    openBotCanonicalChat.mockImplementation(async () => {
+      timeline.push('canonicalOpen')
+
+      return { openedId: 'stored-chat', registryId: 'stored-chat' }
+    })
+
+    expect(await room.actions.openRosterBot(BOT)).toBe(true)
+    expect(timeline.filter(event => event.includes(':group:'))).toHaveLength(1)
+    expect(timeline.findIndex(event => event.includes(':group:'))).toBeLessThan(timeline.indexOf('canonicalOpen'))
+    expect(room.panes.groupChatMainTabs.has('Core')).toBe(false)
+  })
+
+  it('is safe with no room fronted', async () => {
+    const timeline: string[] = []
+    const room = await loadRoom()
+    host.openWorkspace = (id: string) => () => timeline.push(`close:${id}`)
+
+    expect(await room.actions.openRosterBot(BOT)).toBe(true)
+    expect(timeline).toHaveLength(0)
+  })
+})
+
+describe('a failed open must not steal the center', () => {
+  it('restores the group and surfaces the error when the canonical open rejects', async () => {
+    const timeline: string[] = []
+    const room = await loadRoom()
+    registerGroup(room, 'Core', timeline)
+    openBotCanonicalChat.mockRejectedValue(new Error('canonical open failed'))
+
+    expect(await room.actions.openRosterBot(BOT)).toBe(false)
+    expect(timeline.filter(event => event.includes(':group:'))).toHaveLength(1)
+    expect(room.chat.$groupChatWorkspace.get()).toBe('Core')
+    // Re-fronted, not merely re-selected: the tab is registered again.
+    expect(room.panes.groupChatMainTabs.has('Core')).toBe(true)
+    expect(failures).toHaveLength(1)
+  })
+
+  it('restores the group when source preparation rejects', async () => {
+    const room = await loadRoom()
+    registerGroup(room, 'Core', [])
+    prepareBotSource.mockRejectedValue(new Error('source preparation failed'))
+
+    expect(await room.actions.openRosterBot({ ...BOT, connectionId: 'local', sourceScoped: true })).toBe(false)
+    expect(room.chat.$groupChatWorkspace.get()).toBe('Core')
+  })
+
+  it('restores the room by its immutable roomId, so a rename mid-open still finds it', async () => {
+    const room = await loadRoom()
+    room.chat.$groupChats.set({
+      Core: { log: [], roomId: 'r-core', sessions: {}, watermarks: {} }
+    } as unknown as Record<string, GroupChat>)
+    host.openWorkspace = () => () => undefined
+    room.view.openGroupChat('Core')
+    openBotCanonicalChat.mockImplementation(async () => {
+      const rooms = room.chat.$groupChats.get()
+      room.chat.$groupChats.set({ Renamed: rooms.Core } as unknown as Record<string, GroupChat>)
+      throw new Error('canonical open failed')
+    })
+
+    expect(await room.actions.openRosterBot(BOT)).toBe(false)
+    expect(room.chat.$groupChatWorkspace.get()).toBe('Renamed')
+  })
+
+  it('does not resurrect a room that was disbanded during the open', async () => {
+    const room = await loadRoom()
+    registerGroup(room, 'Core', [])
+    openBotCanonicalChat.mockImplementation(async () => {
+      room.chat.$groupChats.set({})
+      throw new Error('canonical open failed')
+    })
+
+    expect(await room.actions.openRosterBot(BOT)).toBe(false)
+    expect(room.chat.$groupChatWorkspace.get()).toBeNull()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-chat-parts.test.tsx b/apps/desktop/src/plugins/hermes-bots/group-chat-parts.test.tsx
new file mode 100644
index 000000000000..e9ecd226dede
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-chat-parts.test.tsx
@@ -0,0 +1,213 @@
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { useState } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { translateBots } from './i18n-test-helper'
+import type { GroupMember } from './types'
+
+// Group-composer mentions (#89049): the core composer's @-completion area
+// doesn't mount inside workspace tiles, so the room's composers wrap the SDK
+// input with a member-scoped popover of their own. Everything it inserts has
+// to be a string parseGroupChatMentions resolves.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+  const base = await pluginSdkMock(host)
+
+  return {
+    ...base,
+    Button: (props: React.ComponentProps<'button'>) => <button type="button" {...props} />,
+    cn: (...values: unknown[]) => values.filter(Boolean).join(' '),
+    Codicon: () => null,
+    Input: (props: React.ComponentProps<'input'>) => <input {...props} />,
+    RowButton: (props: React.ComponentProps<'button'>) => <button type="button" {...props} />,
+    Textarea: (props: React.ComponentProps<'textarea'>) => <textarea {...props} />,
+    useI18n: () => ({ t: (_key: string, fallback: string) => fallback }),
+    // The plugin bundle normally lands via `ctx.i18n.register` at load, so
+    // without this every localized label renders empty.
+    usePluginI18n: () => translateBots
+  }
+})
+
+const MEMBERS: GroupMember[] = [
+  { handle: 'alpha', name: 'alpha', title: '' },
+  { handle: 'builder', name: 'builder', title: '' }
+]
+
+/** Render the composer the way a room does: value owned by the caller (the
+ *  draft atom in production), popover scoped to the seated members. */
+async function mount(initial = '') {
+  const { GroupMentionInput } = await import('./group-chat-parts')
+  const onChange = vi.fn()
+  const onSubmitDraft = vi.fn()
+
+  function Harness() {
+    const [value, setValue] = useState(initial)
+
+    return (
+      <GroupMentionInput
+        aria-label="Message Core"
+        members={MEMBERS}
+        onChange={next => {
+          onChange(next)
+          setValue(next)
+        }}
+        onSubmitDraft={onSubmitDraft}
+        value={value}
+      />
+    )
+  }
+
+  render(<Harness />)
+
+  return { input: screen.getByLabelText('Message Core') as HTMLTextAreaElement, onChange, onSubmitDraft }
+}
+
+/** Type `text`, then park the caret at `caret` (default: end of the text).
+ *  The click is how the component re-reads the caret without a keystroke —
+ *  jsdom does not preserve a selection across React's controlled re-write. */
+function typeInto(input: HTMLTextAreaElement, text: string, caret = text.length) {
+  fireEvent.change(input, { target: { value: text } })
+  input.setSelectionRange(caret, caret)
+  fireEvent.click(input)
+}
+
+const options = () => screen.queryAllByRole('button').map(button => button.textContent || '')
+
+beforeEach(() => {
+  vi.resetModules()
+})
+
+afterEach(() => {
+  cleanup()
+  vi.clearAllMocks()
+})
+
+describe('the @-token at the caret', () => {
+  it('opens the popover on a token that begins a word', async () => {
+    const { input } = await mount()
+
+    typeInto(input, 'hey @al')
+
+    expect(options().some(label => label.startsWith('@alpha'))).toBe(true)
+  })
+
+  it('offers @everyone and @all as the room-wide broadcast quick picks', async () => {
+    const { input } = await mount()
+
+    typeInto(input, '@')
+
+    expect(options().some(label => label.startsWith('@everyone'))).toBe(true)
+    expect(options().some(label => label.startsWith('@all'))).toBe(true)
+  })
+
+  it('narrows to @everyone as the query grows', async () => {
+    const { input } = await mount()
+
+    typeInto(input, 'ping @every')
+
+    expect(options().filter(label => label.startsWith('@everyone'))).toHaveLength(1)
+    expect(options().some(label => label.startsWith('@alpha'))).toBe(false)
+  })
+
+  it('stays closed mid-word, on plain text, and with the caret before the @', async () => {
+    const { input } = await mount()
+
+    typeInto(input, 'email me a@b')
+
+    expect(options()).toHaveLength(0)
+
+    typeInto(input, 'plain text')
+
+    expect(options()).toHaveLength(0)
+
+    typeInto(input, 'hey @al', 3)
+
+    expect(options()).toHaveLength(0)
+  })
+})
+
+describe('insertion', () => {
+  it('writes exactly "@handle " — the shape parseGroupChatMentions resolves', async () => {
+    const { input, onChange } = await mount()
+
+    typeInto(input, 'hey @al')
+    const option = screen.getAllByRole('button').find(button => button.textContent?.startsWith('@alpha'))
+    fireEvent.mouseDown(option!)
+
+    expect(onChange).toHaveBeenLastCalledWith('hey @alpha ')
+  })
+
+  it('preventDefaults the mousedown so the input keeps focus', async () => {
+    const { input } = await mount()
+
+    typeInto(input, 'hey @al')
+    const option = screen.getAllByRole('button').find(button => button.textContent?.startsWith('@alpha'))
+
+    // fireEvent returns false when a handler called preventDefault.
+    expect(fireEvent.mouseDown(option!)).toBe(false)
+  })
+
+  it('replaces the whole token, not just the typed suffix', async () => {
+    const { input, onChange } = await mount()
+
+    typeInto(input, '@bui and then some', 4)
+    const option = screen.getAllByRole('button').find(button => button.textContent?.startsWith('@builder'))
+    fireEvent.mouseDown(option!)
+
+    expect(onChange).toHaveBeenLastCalledWith('@builder  and then some')
+  })
+
+  it('lists every seated member under a bare @, keyed by handle', async () => {
+    const { input } = await mount()
+
+    typeInto(input, '@')
+
+    // Handles only — a profile name that never resolved would surface as
+    // "@undefined" and route to nobody.
+    expect(options().some(label => label.startsWith('@alpha'))).toBe(true)
+    expect(options().some(label => label.startsWith('@builder'))).toBe(true)
+    expect(options().some(label => label.startsWith('@undefined'))).toBe(false)
+  })
+})
+
+// #89884: the composer used to be a single-line Input whose form submitted on
+// every Enter, so multi-line room prompts were impossible.
+describe('keyboard (#89884)', () => {
+  it('submits on Enter and leaves Shift+Enter to the textarea', async () => {
+    const { input, onSubmitDraft } = await mount('a room prompt')
+
+    fireEvent.keyDown(input, { key: 'Enter' })
+
+    expect(onSubmitDraft).toHaveBeenCalledTimes(1)
+
+    fireEvent.keyDown(input, { key: 'Enter', shiftKey: true })
+
+    expect(onSubmitDraft).toHaveBeenCalledTimes(1)
+  })
+
+  it('inserts the highlighted mention on Enter while the popover is open', async () => {
+    const { input, onChange, onSubmitDraft } = await mount()
+
+    typeInto(input, 'hey @alp')
+    fireEvent.keyDown(input, { key: 'Enter' })
+
+    expect(onChange).toHaveBeenLastCalledWith('hey @alpha ')
+    expect(onSubmitDraft).not.toHaveBeenCalled()
+  })
+
+  // #93528: Enter here confirms composed Chinese/Japanese/Korean text. It must
+  // neither insert a mention nor submit the draft. isComposing covers Chromium;
+  // keyCode 229 covers macOS Chinese IMEs that fire Enter after compositionend
+  // with isComposing already false.
+  it('swallows IME composition Enters (#93528)', async () => {
+    const { input, onSubmitDraft } = await mount('中文')
+
+    fireEvent.keyDown(input, { isComposing: true, key: 'Enter' })
+    fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
+
+    expect(onSubmitDraft).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-chat-parts.tsx b/apps/desktop/src/plugins/hermes-bots/group-chat-parts.tsx
new file mode 100644
index 000000000000..ecc13870b544
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-chat-parts.tsx
@@ -0,0 +1,557 @@
+/**
+ * The leaf components a group-chat room composes: the room picture controls,
+ * the mention-aware composer input, and the card a member's pending
+ * clarify/approval prompt renders as.
+ *
+ * None of them reaches back into the room surface, so they sit below
+ * `group-chat-view.tsx` — and the group-creation dialog can share the picture
+ * controls without either surface importing the other.
+ */
+
+import { Button, cn, Codicon, host, Input, RowButton, Textarea, useI18n, useValue } from '@hermes/plugin-sdk'
+import type { ClipboardEvent } from 'react'
+import { useRef, useState } from 'react'
+
+import { $imagenAvailable, normalizeAvatarImage, pickImageFromDevice, probeImagen } from './avatar-image'
+import { $botMeta, botHandle, botMentionTag } from './data'
+import { appendGroupChatEntry } from './group-chat'
+import { groupMemberKey } from './group-membership'
+import { answerGroupClarify } from './group-turns'
+import { useBots } from './i18n'
+import { displayName } from './labels'
+import { botRosterMeta } from './routing'
+import type { BotMeta, GroupMember, GroupPrompt } from './types'
+
+/** The `image.generate` reply. Older gateways answer `image`, newer ones
+ *  `image_data`; both are data URLs. */
+interface ImageGenerateResponse {
+  error?: string
+  image?: string
+  image_data?: string
+  success?: boolean
+}
+
+interface GroupImageControlsProps {
+  image: null | string
+  onImage: (image: null | string) => void
+  seedMembers?: string[]
+  seedName: string
+}
+
+/** Compact picture controls shared by group-chat creation and settings:
+ *  a live preview (image, else the organization glyph), Upload / Generate /
+ *  Remove. Reuses the bot-avatar pipeline (device picker, 256px normalize,
+ *  image.generate probe) so room pictures cost the same as bot avatars. */
+export function GroupImageControls({ image, onImage, seedName, seedMembers }: GroupImageControlsProps) {
+  const b = useBots()
+  const { t } = useI18n()
+  const imagen = useValue($imagenAvailable)
+  const [busy, setBusy] = useState(false)
+
+  if (imagen === null) {
+    void probeImagen()
+  }
+
+  const upload = async () => {
+    const raw = await pickImageFromDevice()
+
+    if (raw) {
+      onImage(await normalizeAvatarImage(raw))
+    }
+  }
+
+  const generate = async () => {
+    if (busy) {
+      return
+    }
+
+    setBusy(true)
+
+    try {
+      const who = [seedName, seedMembers?.length ? `a team of ${seedMembers.join(', ')}` : '']
+        .filter(Boolean)
+        .join(' — ')
+
+      const res = await host.request<ImageGenerateResponse>('image.generate', {
+        prompt:
+          `Group chat icon for an AI agent team called "${who || 'a bot team'}". ` +
+          'Friendly minimal emblem, bold flat vector style, solid color background, centered, no text.',
+        aspect_ratio: 'square'
+      })
+
+      if (!res?.success) {
+        throw new Error(res?.error || 'generation failed')
+      }
+
+      const img = res.image_data || res.image
+
+      if (img) {
+        onImage(await normalizeAvatarImage(img))
+      }
+    } catch (err) {
+      host.notifyError(err, b.group.pictureGenerationFailed)
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  return (
+    <div className="flex items-center gap-2">
+      <div className="flex size-10 shrink-0 items-center justify-center overflow-hidden rounded-full bg-(--chrome-action-hover)">
+        {image ? (
+          <img alt="" className="size-full object-cover" src={image} />
+        ) : (
+          <Codicon className="text-(--ui-text-tertiary)" name="organization" />
+        )}
+      </div>
+      <Button onClick={upload} size="sm" type="button" variant="secondary">
+        {b.avatar.upload}
+      </Button>
+      {imagen ? (
+        <Button disabled={busy} onClick={generate} size="sm" type="button" variant="secondary">
+          {busy ? b.avatar.generating : b.avatar.generate}
+        </Button>
+      ) : null}
+      {image ? (
+        <Button onClick={() => onImage(null)} size="sm" type="button" variant="ghost">
+          {t.common.remove}
+        </Button>
+      ) : null}
+    </div>
+  )
+}
+
+interface MentionToken {
+  query: string
+  /** Index of the '@' the token starts at. */
+  start: number
+}
+
+/** Merged room view for one group: shared timeline with per-member
+ *  attribution, a composer that drives the round-robin, and a working
+ *  indicator while member turns run. Renders identically in the MAIN chat
+ *  window (host.openWorkspace tile) and in the bots panel (older-desktop
+ *  fallback); `onBack` is where the Back button routes — the main tile's
+ *  closer, or clearing the in-panel workspace atom. */
+/** The active @-token at the caret: text from the nearest '@' (that begins a
+ *  word) up to the caret, or null when the caret isn't inside a mention. */
+function mentionTokenAt(text: string, caret: number): MentionToken | null {
+  const upto = String(text || '').slice(0, caret)
+  const match = /(^|\s)@([a-z0-9._-]*)$/i.exec(upto)
+
+  if (!match) {
+    return null
+  }
+
+  return {
+    query: match[2].toLowerCase(),
+    start: caret - match[2].length - 1
+  }
+}
+
+/** One row of the mention popover: the handle inserted, plus its subtitle. */
+interface MentionOption {
+  handle: string
+  meta: string
+}
+
+interface GroupMentionInputProps {
+  'aria-label'?: string
+  autoFocus?: boolean
+  className?: string
+  members: GroupMember[]
+  onChange: (value: string) => void
+  onPaste?: (event: ClipboardEvent<HTMLTextAreaElement>) => void
+  onSubmitDraft?: () => void
+  placeholder?: string
+  value: string
+}
+
+/** Mention-aware composer input for group rooms. The core composer's
+ *  @-completion area doesn't mount inside workspace tiles (#89049), so this
+ *  wraps the plain SDK Input with a member-scoped popover: @everyone/@all
+ *  quick picks plus each seated member's handle. Insertion produces exactly
+ *  the strings parseGroupChatMentions resolves. Keyboard: Up/Down navigate,
+ *  Enter/Tab insert (Enter falls through to submit when the popover is
+ *  closed), Escape dismisses. */
+export function GroupMentionInput({ members, onChange, onSubmitDraft, value, ...inputProps }: GroupMentionInputProps) {
+  const b = useBots()
+  const allMeta: Record<string, BotMeta> = useValue($botMeta)
+  const inputRef = useRef<HTMLTextAreaElement | null>(null)
+  const [token, setToken] = useState<MentionToken | null>(null)
+  const [selected, setSelected] = useState(0)
+  const options: MentionOption[] = []
+
+  if (token) {
+    for (const pick of ['everyone', 'all']) {
+      if (pick.startsWith(token.query)) {
+        options.push({
+          handle: pick,
+          meta: b.group.everyoneMeta
+        })
+      }
+    }
+
+    for (const member of members) {
+      const handle = String(member.handle || botHandle(member.name, member) || '').trim()
+      const display = displayName(member, botRosterMeta(member, allMeta))
+      // Renamed members complete on their friendly tag; parser resolves both.
+      const tag = String(botMentionTag(member) || handle).trim()
+
+      if (!tag) {
+        continue
+      }
+
+      if (
+        token.query &&
+        !tag.toLowerCase().startsWith(token.query) &&
+        !(handle && handle.toLowerCase().startsWith(token.query)) &&
+        !display.toLowerCase().startsWith(token.query)
+      ) {
+        continue
+      }
+
+      options.push({
+        handle: tag,
+        meta: display
+      })
+    }
+  }
+
+  const open = Boolean(token) && options.length > 0
+  const active = open ? Math.min(selected, options.length - 1) : 0
+
+  // The onClick below passes `event.target`, which React types as a bare
+  // EventTarget even though a click on this textarea always targets it.
+  const refreshToken = (target: HTMLTextAreaElement) => {
+    setToken(mentionTokenAt(target.value, target.selectionStart ?? target.value.length))
+    setSelected(0)
+  }
+
+  const insert = (handle: string) => {
+    if (!token) {
+      return
+    }
+
+    const caret = inputRef.current?.selectionStart ?? value.length
+    const next = `${value.slice(0, token.start)}@${handle} ${value.slice(caret)}`
+    onChange(next)
+    setToken(null)
+
+    // Restore focus with the caret after the inserted mention.
+    const pos = token.start + handle.length + 2
+    requestAnimationFrame(() => {
+      const el = inputRef.current
+
+      if (el) {
+        el.focus()
+
+        try {
+          el.setSelectionRange(pos, pos)
+        } catch {
+          /* input type without selection support */
+        }
+      }
+    })
+  }
+
+  return (
+    <div className="relative min-w-0 flex-1">
+      {open ? (
+        <div className="absolute bottom-full left-0 z-50 mb-1 max-h-48 w-64 overflow-y-auto rounded-md border border-(--ui-stroke-secondary) bg-(--ui-bg-primary) py-1 shadow-lg">
+          {options.map((option, index) => (
+            <RowButton
+              className={cn(
+                'flex w-full items-baseline gap-2 px-2 py-1 text-left text-xs',
+                index === active ? 'bg-(--ui-control-hover-background) text-foreground' : 'text-(--ui-text-secondary)'
+              )} // preventDefault on mousedown so the input keeps focus.
+              key={option.handle}
+              onMouseDown={event => {
+                event.preventDefault()
+                insert(option.handle)
+              }}
+              onMouseEnter={() => setSelected(index)}
+            >
+              <span className="font-medium">{`@${option.handle}`}</span>
+              <span className="truncate text-[0.65rem] text-(--ui-text-quaternary)">{option.meta}</span>
+            </RowButton>
+          ))}
+        </div>
+      ) : null}
+      <Textarea
+        {...inputProps}
+        // Input whose form submitted on every Enter — newlines were
+        // impossible. Enter (no Shift) still submits via onSubmitDraft;
+        // Shift+Enter falls through to the textarea's native newline.
+        className={cn('max-h-40 min-h-9 resize-none', inputProps.className)}
+        onBlur={() => setToken(null)}
+        onChange={event => {
+          onChange(event.target.value)
+          refreshToken(event.target)
+        }}
+        onClick={event => refreshToken(event.target as HTMLTextAreaElement)}
+        onKeyDown={event => {
+          // IME composition guard (same as the core composer): Enter here
+          // confirms the composed Chinese/Japanese/Korean text — it must not
+          // insert a mention nor submit the draft. nativeEvent.isComposing
+          // covers Chromium; keyCode 229 covers macOS Chinese IMEs that fire
+          // Enter after compositionend with isComposing already false.
+          if (event.nativeEvent?.isComposing || event.keyCode === 229) {
+            return
+          }
+
+          if (open) {
+            if (event.key === 'ArrowDown') {
+              event.preventDefault()
+              setSelected((active + 1) % options.length)
+
+              return
+            }
+
+            if (event.key === 'ArrowUp') {
+              event.preventDefault()
+              setSelected((active - 1 + options.length) % options.length)
+
+              return
+            }
+
+            if (event.key === 'Enter' || event.key === 'Tab') {
+              event.preventDefault()
+              insert(options[active].handle)
+
+              return
+            }
+
+            if (event.key === 'Escape') {
+              event.preventDefault()
+              setToken(null)
+
+              return
+            }
+          }
+
+          if (event.key === 'Enter' && !event.shiftKey) {
+            event.preventDefault()
+            onSubmitDraft?.()
+          }
+        }}
+        ref={inputRef}
+        rows={1} // Multi-line room prompts (#89884): the composer was a single-line
+        value={value}
+      />
+    </div>
+  )
+}
+
+/** A pending prompt as the room renders it. */
+export interface GroupRoomPrompt extends GroupPrompt {
+  /** TODO(bot-mode-types): nothing ever sets this — syncGroupClarify builds
+   *  every entry without a thread — so the answer GroupClarifyCard echoes back
+   *  into the room always lands in the 'legacy' thread instead of the thread
+   *  the member asked from. */
+  thread?: string
+}
+
+/** A sub-question normalized for rendering: one card row, one answer. */
+interface GroupClarifyQuestion {
+  choices: string[]
+  multiSelect: boolean
+  qid: string
+  question: string
+}
+
+interface GroupClarifyCardProps {
+  entry: GroupRoomPrompt
+  members: GroupMember[]
+}
+
+/** One member's pending prompt, rendered in the room (#90694).
+ *  - clarify: choices as tap buttons (multi-select stages; single-select
+ *    stages one), free text always available, batch sub-questions each get
+ *    their own input.
+ *  - approval: the command in a code row plus the server's choice set
+ *    (once/session/always/deny) as buttons — no free text; approvals are a
+ *    closed choice. Answer sends via the member's own source. */
+export function GroupClarifyCard({ entry, members }: GroupClarifyCardProps) {
+  const b = useBots()
+  const { group } = entry
+  const isApproval = entry.kind === 'approval'
+  const member = members.find(m => groupMemberKey(m) === entry.memberKey) || members.find(m => m.name === entry.member)
+  const [drafts, setDrafts] = useState<Record<string, string>>({})
+  const [picked, setPicked] = useState<Record<string, string[]>>({})
+  const [sending, setSending] = useState(false)
+
+  const questions: GroupClarifyQuestion[] =
+    entry.questions && entry.questions.length
+      ? entry.questions.map((q, i) => ({
+          qid: q?.qid ?? q?.id ?? `q${i}`,
+          question: typeof q?.question === 'string' ? q.question : '',
+          choices: Array.isArray(q?.choices) ? q.choices.filter(c => typeof c === 'string' && c) : [],
+          multiSelect: Boolean(q?.multi_select ?? q?.multiSelect)
+        }))
+      : [
+          {
+            qid: '__single__',
+            question: entry.question,
+            choices: entry.choices,
+            multiSelect: entry.multiSelect
+          }
+        ]
+
+  const answerFor = (q: GroupClarifyQuestion) => {
+    const chosen = picked[q.qid] || []
+
+    if (chosen.length) {
+      return q.multiSelect ? JSON.stringify(chosen) : chosen[0]
+    }
+
+    return isApproval ? '' : (drafts[q.qid] || '').trim()
+  }
+
+  const allAnswered = questions.every(q => answerFor(q))
+
+  const submit = async () => {
+    if (!member || sending || !allAnswered) {
+      return
+    }
+
+    setSending(true)
+
+    try {
+      if (isApproval || !(entry.questions && entry.questions.length)) {
+        await answerGroupClarify(entry, member, answerFor(questions[0]))
+      } else {
+        const answers: Record<string, string> = {}
+
+        for (const q of questions) {
+          answers[q.qid] = answerFor(q)
+        }
+
+        await answerGroupClarify(entry, member, answers)
+      }
+
+      // Echo the exchange into the room log so the thread reads complete.
+      const summary = isApproval
+        ? `${answerFor(questions[0])} — ${entry.command || entry.question || b.group.commandApproval}`
+        : questions.map(q => (questions.length > 1 ? `${q.question}: ${answerFor(q)}` : answerFor(q))).join('\n')
+
+      appendGroupChatEntry(
+        group,
+        {
+          kind: 'user',
+          name: 'You'
+        },
+        summary,
+        entry.thread || 'legacy'
+      )
+    } catch (err: any) {
+      host.notify({
+        kind: 'error',
+        message: b.group.answerFailed(botHandle(entry.member, member), String(err?.message || err))
+      })
+    } finally {
+      setSending(false)
+    }
+  }
+
+  return (
+    <div className="grid gap-1.5 rounded-md border border-(--ui-accent)/50 bg-(--ui-accent)/5 px-2.5 py-2">
+      <div className="flex items-center gap-1.5 text-xs font-medium">
+        <Codicon className="shrink-0 text-(--ui-accent)" name={isApproval ? 'shield' : 'question'} />
+        {isApproval
+          ? b.group.wantsToRunCommand(botHandle(entry.member, member))
+          : b.group.asks(botHandle(entry.member, member))}
+      </div>
+      {isApproval && entry.command ? (
+        <code className="block overflow-x-auto rounded bg-(--ui-bg-secondary,rgba(0,0,0,0.25)) px-2 py-1 font-mono text-[0.7rem] whitespace-pre-wrap break-all">
+          {entry.command}
+        </code>
+      ) : null}
+      {questions.map(q => (
+        <div className="grid gap-1" key={`q:${q.qid}`}>
+          {q.question ? <div className="text-xs whitespace-pre-wrap">{q.question}</div> : null}
+          {q.choices.length ? (
+            <div className="flex flex-wrap gap-1">
+              {q.choices.map(choice => {
+                const chosen = (picked[q.qid] || []).includes(choice)
+
+                return (
+                  <Button
+                    className={cn(
+                      'h-6 px-2 text-[0.7rem]',
+                      isApproval && choice === 'deny' && !chosen && 'text-destructive'
+                    )}
+                    key={`choice:${q.qid}:${choice}`}
+                    onClick={() => {
+                      setDrafts(prev => ({
+                        ...prev,
+                        [q.qid]: ''
+                      }))
+                      setPicked(prev => {
+                        const current = prev[q.qid] || []
+
+                        const next = q.multiSelect
+                          ? chosen
+                            ? current.filter(c => c !== choice)
+                            : [...current, choice]
+                          : chosen
+                            ? []
+                            : [choice]
+
+                        return {
+                          ...prev,
+                          [q.qid]: next
+                        }
+                      })
+                    }}
+                    size="sm"
+                    variant={chosen ? 'default' : 'secondary'}
+                  >
+                    {choice}
+                  </Button>
+                )
+              })}
+            </div>
+          ) : null}
+          {/* Approvals are a closed choice set — no free-text input. */}
+          {isApproval ? null : (
+            <Input
+              aria-label={b.group.answerTo(entry.member)}
+              className="h-7 text-xs"
+              key={`input:${q.qid}`}
+              onChange={event => {
+                const value = event.target.value
+                setPicked(prev => ({
+                  ...prev,
+                  [q.qid]: []
+                }))
+                setDrafts(prev => ({
+                  ...prev,
+                  [q.qid]: value
+                }))
+              }}
+              onKeyDown={event => {
+                // IME guard: Enter confirming a composed word must not submit.
+                if (event.nativeEvent?.isComposing || event.keyCode === 229) {
+                  return
+                }
+
+                if (event.key === 'Enter' && questions.length === 1) {
+                  event.preventDefault()
+                  void submit()
+                }
+              }}
+              placeholder={q.choices.length ? 'Or type your own answer…' : 'Type your answer…'}
+              value={drafts[q.qid] || ''}
+            />
+          )}
+        </div>
+      ))}
+      <div className="flex justify-end">
+        <Button disabled={sending || !allAnswered || !member} onClick={() => void submit()} size="sm">
+          {sending ? 'Sending…' : isApproval ? 'Respond' : 'Answer'}
+        </Button>
+      </div>
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-chat-view.test.ts b/apps/desktop/src/plugins/hermes-bots/group-chat-view.test.ts
new file mode 100644
index 000000000000..4c07972f2426
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-chat-view.test.ts
@@ -0,0 +1,291 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as data from './data'
+import type * as groupChat from './group-chat'
+import type * as groupChatView from './group-chat-view'
+import type * as groupMembership from './group-membership'
+import type * as groupPanes from './group-panes'
+import { createGroupGateway, drain, runTimersInline, scriptedStorage } from './group-test-utils'
+import type { ScriptedGateway } from './group-test-utils'
+import type { GroupChat, RosterRow } from './types'
+
+// The room surface's two lifecycle mutations — opening a room into the MAIN
+// window, and disbanding one — plus the ordering rules that keep the in-pane
+// fallback from painting a duplicate beside the main tab.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+
+  return pluginSdkMock(host)
+})
+
+interface Room {
+  chat: typeof groupChat
+  data: typeof data
+  gateway: ScriptedGateway
+  membership: typeof groupMembership
+  panes: typeof groupPanes
+  view: typeof groupChatView
+}
+
+async function loadRoom(): Promise<Room> {
+  vi.resetModules()
+  const gateway = createGroupGateway()
+
+  for (const key of Object.keys(host)) {
+    delete host[key]
+  }
+
+  Object.assign(host, gateway.host)
+
+  const [chat, data, membership, panes, view, shared] = await Promise.all([
+    import('./group-chat'),
+    import('./data'),
+    import('./group-membership'),
+    import('./group-panes'),
+    import('./group-chat-view'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx(scriptedStorage(gateway.storage))
+
+  return { chat, data, gateway, membership, panes, view }
+}
+
+const durable = (room: Room) => (room.gateway.storage.get('group-chats') || {}) as Record<string, GroupChat>
+
+beforeEach(() => {
+  runTimersInline()
+})
+
+describe('opening a room', () => {
+  it('follows the main-window tab open and close', async () => {
+    const room = await loadRoom()
+    let onClose: () => void = () => undefined
+
+    host.openWorkspace = (_id: string, options: { onClose: () => void }) => {
+      onClose = options.onClose
+
+      return () => onClose()
+    }
+
+    room.view.openGroupChat('Core')
+
+    expect(room.chat.$groupChatWorkspace.get()).toBe('Core')
+    // #89788: the main tab owns the room, so the pane keeps its roster.
+    expect(room.panes.shouldRenderGroupChatInPane('Core')).toBe(false)
+
+    onClose()
+
+    expect(room.chat.$groupChatWorkspace.get()).toBeNull()
+    expect(room.panes.shouldRenderGroupChatInPane('Core')).toBe(true)
+  })
+
+  it('keeps the in-pane fallback on older hosts and when the door throws', async () => {
+    const older = await loadRoom()
+
+    older.view.openGroupChat('Core')
+
+    expect(older.chat.$groupChatWorkspace.get()).toBe('Core')
+    expect(older.panes.shouldRenderGroupChatInPane('Core')).toBe(true)
+
+    const failed = await loadRoom()
+
+    host.openWorkspace = () => {
+      throw new Error('workspace unavailable')
+    }
+
+    failed.view.openGroupChat('Ops')
+
+    expect(failed.chat.$groupChatWorkspace.get()).toBe('Ops')
+    expect(failed.panes.shouldRenderGroupChatInPane('Ops')).toBe(true)
+  })
+
+  it('records main-tab ownership before the selection atom paints (#89788 follow-up)', async () => {
+    const room = await loadRoom()
+    // Simulate a BotsPane render racing the open: sample the gate at the
+    // moment the selection atom flips. If the tab were recorded after the atom
+    // set, this probe would observe selected-but-unowned and the in-pane
+    // duplicate would paint beside the main tab.
+    let gateAtSelection: boolean | null = null
+
+    const unsubscribe = room.chat.$groupChatWorkspace.listen(value => {
+      if (value === 'Core' && gateAtSelection === null) {
+        gateAtSelection = room.panes.shouldRenderGroupChatInPane('Core')
+      }
+    })
+
+    host.openWorkspace = () => () => undefined
+
+    room.view.openGroupChat('Core')
+    unsubscribe()
+
+    expect(gateAtSelection).toBe(false)
+  })
+
+  it('does not let an older group closing clear the newer selection', async () => {
+    const room = await loadRoom()
+    host.openWorkspace = () => () => undefined
+
+    room.view.openGroupChat('Core')
+    room.view.openGroupChat('Ops')
+    room.panes.closeGroupChatMainTab('Core')
+
+    expect(room.chat.$groupChatWorkspace.get()).toBe('Ops')
+  })
+})
+
+describe('disband', () => {
+  it('removes only this membership, room log, workspace and needs-you state', async () => {
+    const room = await loadRoom()
+    room.chat.$groupChats.set({
+      Gone: { log: [{ at: 2, from: { kind: 'user', name: 'You' }, id: 'g1', text: 'hello goners' }], watermarks: {} },
+      Keep: {
+        log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'k1', text: 'hello keepers' }],
+        members: [{ connectionId: 'remote-1', name: 'remote', remoteSource: true, sourceScoped: true }],
+        watermarks: {}
+      }
+    } as unknown as Record<string, GroupChat>)
+    room.data.$botMeta.set({
+      builder: { group: 'Gone', groups: ['Gone', 'Keep'] },
+      research: { group: 'Keep', groups: ['Keep'] }
+    })
+    room.chat.$groupChatWorkspace.set('Gone')
+    room.chat.$groupNeedsYou.set({ Gone: true, Keep: true })
+
+    await room.view.disbandGroupChat('Gone', [{ name: 'builder' }])
+
+    // Room state: gone from the atom (no running drive, so no tombstone).
+    expect(room.chat.$groupChats.get().Gone).toBeUndefined()
+    expect(room.chat.$groupChats.get().Keep).toBeTruthy()
+    // The open room view closed; needs-you cleared for the disbanded room only.
+    expect(room.chat.$groupChatWorkspace.get()).toBeNull()
+    expect(room.chat.$groupNeedsYou.get().Gone).toBeUndefined()
+    expect(room.chat.$groupNeedsYou.get().Keep).toBe(true)
+    // Disband removes only this membership; other groups survive.
+    expect(room.data.$botMeta.get().builder.groups).toEqual(['Keep'])
+    expect(room.data.$botMeta.get().builder.group).toBe('Keep')
+    expect(room.data.$botMeta.get().research.groups).toEqual(['Keep'])
+    expect('Gone' in durable(room)).toBe(false)
+    expect(durable(room).Keep.members).toHaveLength(1)
+    expect(durable(room).Keep.members?.[0].connectionId).toBe('remote-1')
+  })
+
+  it('cannot leave a metadata-only group row behind when the rendered roster is empty', async () => {
+    const room = await loadRoom()
+    room.data.$botMeta.set({ builder: { group: 'Remote', groups: ['Remote'] } })
+    room.chat.$groupChats.set({
+      Remote: { log: [], members: [], running: false, sessions: {}, watermarks: {} }
+    } as unknown as Record<string, GroupChat>)
+
+    await room.view.disbandGroupChat('Remote', [])
+
+    expect(room.chat.$groupChats.get().Remote).toBeUndefined()
+    expect(room.data.$botMeta.get().builder.groups).toEqual([])
+    expect(room.data.$botMeta.get().builder.group).toBeNull()
+    // Stale bot metadata cannot reconstruct a deleted zero-member row.
+    expect(room.membership.groupChatNames(room.data.$botMeta.get(), room.chat.$groupChats.get())).toEqual([])
+  })
+
+  it('recovers the exact source-qualified metadata owner from an empty roster', async () => {
+    const room = await loadRoom()
+
+    const remote: RosterRow = {
+      connectionId: 'remote-1',
+      connectionKind: 'remote',
+      name: 'builder',
+      remoteSource: true,
+      route: { connectionId: 'remote-1', mode: 'remote', profile: 'builder', targetProfile: 'builder' },
+      sourceScoped: true
+    }
+
+    room.data.$lastRoster.set([remote])
+    room.data.$botMeta.set({
+      builder: { group: 'Keep', groups: ['Keep'] },
+      'remote-1::builder': { group: 'Remote', groups: ['Remote'] }
+    })
+    room.chat.$groupChats.set({
+      Remote: { log: [], members: [], running: false, sessions: {}, watermarks: {} }
+    } as unknown as Record<string, GroupChat>)
+
+    await room.view.disbandGroupChat('Remote', [])
+
+    expect(room.data.$botMeta.get()['remote-1::builder'].groups).toEqual([])
+    expect(room.data.$botMeta.get()['remote-1::builder'].group).toBeNull()
+    // Same-named local metadata is untouched.
+    expect(room.data.$botMeta.get().builder.groups).toEqual(['Keep'])
+    expect(room.data.$botMeta.get().builder.group).toBe('Keep')
+  })
+
+  it('skips source-qualified remote members instead of mutating same-named local metadata', async () => {
+    const room = await loadRoom()
+    room.data.$botMeta.set({ builder: { group: 'Keep', groups: ['Keep'] } })
+
+    await room.view.disbandGroupChat('Remote', [
+      { connectionId: 'remote-1', name: 'builder', remoteSource: true, sourceScoped: true }
+    ])
+
+    expect(room.data.$botMeta.get().builder.groups).toEqual(['Keep'])
+    expect(room.data.$botMeta.get().builder.group).toBe('Keep')
+    expect(room.data.$botMeta.get()['[object Object]']).toBeUndefined()
+  })
+
+  it('leaves an epoch-bumped empty tombstone while a drive is mid-turn', async () => {
+    const room = await loadRoom()
+    room.chat.$groupChats.set({
+      Live: {
+        epoch: 3,
+        log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'l1', text: 'kick off' }],
+        running: true,
+        watermarks: {}
+      }
+    } as unknown as Record<string, GroupChat>)
+
+    await room.view.disbandGroupChat('Live', [{ name: 'research' }])
+
+    const tomb = room.chat.$groupChats.get().Live
+
+    expect(tomb).toBeTruthy()
+    expect(tomb.log).toHaveLength(0)
+    expect(tomb.running).toBe(false)
+    // Epoch bumped so the loop bails at its member boundary; flagged so
+    // persistence and name-dedup skip it.
+    expect(tomb.epoch).toBe(4)
+    expect(tomb.tombstone).toBe(true)
+    expect('Live' in durable(room)).toBe(false)
+
+    // Regression (#90028 live E2E): updateGroupChat persists the WHOLE atom
+    // map — an unrelated room write while the tombstone lingers must not
+    // smuggle it into durable storage, and the disbanded name must be
+    // immediately reusable (uniqueGroupChatName would suffix it otherwise).
+    room.chat.updateGroupChat('Other', current => {
+      current.log.push({ at: Date.now(), from: { kind: 'user', name: 'You' }, id: 'o1', text: 'x', thread: 't' })
+
+      return current
+    })
+
+    expect('Other' in durable(room)).toBe(true)
+    expect('Live' in durable(room)).toBe(false)
+    expect(room.chat.uniqueGroupChatName('Live', new Set(room.membership.liveGroupChatNames()))).toBe('Live')
+  })
+
+  it('drops the disbanded room from the gateway mirror', async () => {
+    const room = await loadRoom()
+    room.chat.$groupChats.set({
+      Gone: { log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'g1', text: 'bye' }], watermarks: {} }
+    } as unknown as Record<string, GroupChat>)
+
+    await room.view.disbandGroupChat('Gone', [])
+    await drain(() => room.gateway.rpcFor('profiles.configure').length < 1, 50)
+
+    const configure = room.gateway.rpcFor('profiles.configure').at(-1)
+
+    const envelope = (configure?.params.ui_meta as Record<string, { deleted?: Record<string, number> }>)[
+      'hermes-bots-groups'
+    ]
+
+    expect(envelope.deleted?.['name:Gone']).toBeGreaterThan(0)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-chat-view.tsx b/apps/desktop/src/plugins/hermes-bots/group-chat-view.tsx
new file mode 100644
index 000000000000..eaf10ade5303
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-chat-view.tsx
@@ -0,0 +1,1413 @@
+/**
+ * The group-chat room surface: the merged room view, its settings dialog, the
+ * MAIN-window tab it opens into, and the two room-lifecycle mutations that
+ * surface drives — disband and rename.
+ *
+ * Disband and rename live here rather than beside the pane registry because a
+ * rename re-opens the room's main tab, and that tab renders this file's
+ * workspace: settings dialog → rename → open → main view → workspace is one
+ * cycle, so it is one module. The tab registry and the composer drafts they
+ * touch stay below, in `group-panes.ts`.
+ */
+
+import * as sdk from '@hermes/plugin-sdk'
+import {
+  atom,
+  Button,
+  cn,
+  Codicon,
+  ConfirmDialog,
+  CopyButton,
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  host,
+  Input,
+  queryClient,
+  relativeTime,
+  RowButton,
+  Tip,
+  useI18n,
+  useValue
+} from '@hermes/plugin-sdk'
+import type { ClipboardEvent, DragEvent, ReactNode } from 'react'
+import { useEffect, useMemo, useRef, useState } from 'react'
+
+import { avatarColor, botAppearance, BotFace } from './avatar'
+import { isBackfilledFacePng } from './avatar-image'
+import {
+  $botMeta,
+  $lastRoster,
+  botHandle,
+  botMetaV2Active,
+  botSourceStatus,
+  noteBotMetaWrite,
+  persistBotMetaSnapshot,
+  ROSTER_KEY,
+  saveBotMeta
+} from './data'
+import {
+  $groupActivity,
+  currentGroupActivity,
+  GROUP_ACTIVITY_GLYPHS,
+  groupActivityLabel,
+  groupActivityTone
+} from './group-activity'
+import type { GroupActivityEntry } from './group-activity'
+import { filesToGroupAttachments, pickGroupAttachments } from './group-attachments'
+import {
+  $groupChats,
+  $groupChatWorkspace,
+  $groupClarify,
+  $groupNeedsYou,
+  groupSpeakerLabel,
+  groupThreadOf,
+  scheduleGroupChatServerSync,
+  setGroupChatImage,
+  updateGroupChat
+} from './group-chat'
+import type { GroupChatRoom } from './group-chat'
+import { GroupClarifyCard, GroupImageControls, GroupMentionInput } from './group-chat-parts'
+import type { GroupRoomPrompt } from './group-chat-parts'
+import {
+  botGroups,
+  groupChatMemberBots,
+  groupDisbandMetadataPlan,
+  groupWorkspaceOwnerKey,
+  liveGroupChatNames
+} from './group-membership'
+import {
+  clearGroupComposerDraft,
+  closeGroupChatMainTab,
+  dropGroupMainTab,
+  groupChatMainTabs,
+  groupComposerDraftKey,
+  groupComposerDraftSnapshot,
+  migrateGroupComposerDraft,
+  recordGroupMainTab,
+  restoreGroupComposerDraft,
+  updateGroupComposerDraft
+} from './group-panes'
+import type { GroupComposerDraft, GroupDraftSetter } from './group-panes'
+import { sendToGroupChat, stopGroupThread } from './group-rounds'
+import { clearGroupClarify } from './group-turns'
+import { botsText, useBots } from './i18n'
+import { displayName, slugify, stripPreviewMarkdown } from './labels'
+import { botRosterMeta, setBotsWorkspaceOwner } from './routing'
+import { bumpBotOpenGeneration, getPluginCtx, ID } from './shared'
+import type { Attachment, BotMeta, GroupChat, GroupMember, GroupMessage, RosterRow } from './types'
+
+const Streamdown = typeof sdk === 'undefined' ? undefined : sdk.Streamdown
+
+/** Soft-disband a group chat: remove only this group from every local member's
+ *  membership list (the metadata syncs cross-machine via ui_meta), drop the
+ *  room log from the atom + plugin storage, and close the room view if it's
+ *  open. Other group memberships and the members' per-group gateway sessions
+ *  ("Group: <roomId>", or legacy "Group: <name>") are intentionally KEPT. */
+export async function disbandGroupChat(group: string, members: RosterRow[]) {
+  // Invalidate any in-flight round-robin FIRST: bump the epoch so a running
+  // drive bails at its next member boundary instead of appending to a room
+  // the user just discarded.
+  const all = {
+    ...$groupChats.get()
+  }
+
+  const prior = all[group] || {}
+  const metaBefore = $botMeta.get()
+  const cleanup = groupDisbandMetadataPlan(group, members, prior, $lastRoster.get(), metaBefore)
+  let metadataPersistence: Promise<unknown> = Promise.resolve()
+
+  if (cleanup.patches.size) {
+    const nextMeta = {
+      ...metaBefore
+    }
+
+    for (const [key, patch] of cleanup.patches) {
+      nextMeta[key] = {
+        ...(nextMeta[key] || {}),
+        ...patch
+      }
+      noteBotMetaWrite(key)
+    }
+
+    // Paint the deletion before any remote write can stall. This also removes
+    // orphaned legacy metadata that cannot safely be routed to a source.
+    $botMeta.set(nextMeta)
+    metadataPersistence = persistBotMetaSnapshot(
+      nextMeta,
+      botMetaV2Active || Object.keys(nextMeta).some(key => key.includes('::'))
+    )
+  }
+
+  delete all[group]
+
+  // Keep a runtime-only tombstone while a drive may still be mid-turn; it
+  // carries no log and is flagged so persistence and name-dedup skip it —
+  // updateGroupChat writes the WHOLE atom map, so an unflagged tombstone
+  // would be persisted by the next unrelated room write and its name would
+  // count as taken, suffixing a same-name recreate to "<name> 2" forever.
+  if (prior.running) {
+    all[group] = {
+      log: [],
+      watermarks: {},
+      sessions: {},
+      epoch: (prior.epoch || 0) + 1,
+      running: false,
+      tombstone: true
+    }
+  }
+
+  $groupChats.set(all)
+
+  if ($groupChatWorkspace.get() === group) {
+    $groupChatWorkspace.set(null)
+  }
+
+  // Retire the room's MAIN-window tab too (host.openWorkspace path).
+  closeGroupChatMainTab(group)
+
+  const needs = {
+    ...$groupNeedsYou.get()
+  }
+
+  delete needs[group]
+  $groupNeedsYou.set(needs)
+  clearGroupClarify(group)
+
+  // Persist the room map WITHOUT the disbanded room so it can't come back
+  // on the next window load.
+  try {
+    const durable: Record<string, GroupChat> = {}
+
+    for (const [name, room] of Object.entries($groupChats.get())) {
+      if (name !== group && Array.isArray(room.log)) {
+        durable[name] = {
+          log: room.log,
+          watermarks: room.watermarks,
+          sessions: room.sessions || {},
+          sessionOwners: room.sessionOwners || {},
+          members: Array.isArray(room.members) ? room.members : [],
+          roomId: typeof room.roomId === 'string' && room.roomId ? room.roomId : null,
+          image: room.image || null,
+          syncRevision: Math.max(0, Number(room.syncRevision || 0))
+        }
+      }
+    }
+
+    await Promise.resolve(getPluginCtx()?.storage?.set?.('group-chats', durable))
+  } catch {
+    /* storage unavailable — the atom reset above still empties the room */
+  }
+
+  scheduleGroupChatServerSync($groupChats.get(), {
+    allowEmpty: true,
+    deletedRooms: [group]
+  })
+  await metadataPersistence
+
+  // Persist the cleanup to every exact owner we can prove. saveBotMeta never
+  // throws (local storage + best-effort profiles.configure per owner), so a
+  // flaky gateway cannot strand the local disband halfway.
+  for (const [key, owner] of cleanup.owners) {
+    const patch = cleanup.patches.get(key)
+
+    if (patch) {
+      await saveBotMeta(owner, patch)
+    }
+  }
+
+  // Converge on server truth: the cached roster still carries the pre-disband
+  // ui_meta (the write-fence in mergeServerMeta keeps it from resurrecting
+  // the membership, but a fresh snapshot is what makes every surface agree).
+  if (typeof queryClient !== 'undefined' && queryClient?.invalidateQueries) {
+    queryClient.invalidateQueries({
+      queryKey: ROSTER_KEY
+    })
+  }
+}
+
+/** Rename a group chat. The group's NAME is its identity everywhere — the
+ *  room-map key, each local member's ui_meta membership list, and derived
+ *  state — so a rename re-keys all of them. Member gateway sessions are kept
+ *  as-is: stored sids keep resuming, so no history is lost. The room's
+ *  immutable roomId (the member-session title) is preserved across the
+ *  rename, so even a member whose sid is later lost falls back to the same
+ *  "Group: <roomId>" title lookup instead of a fresh "Group: <new name>".
+ *  Returns the new name, or null when the target name is taken. */
+async function renameGroupChat(oldName: string, newName: string, members: GroupMember[] | null | undefined) {
+  const next = String(newName || '')
+    .trim()
+    .slice(0, 64)
+
+  if (!next || next === oldName) {
+    return oldName
+  }
+
+  // Renames are explicit user intent: reject a collision honestly instead of
+  // silently suffixing like creation does. Disband tombstones don't hold
+  // their name — the room is gone, only its epoch survives briefly.
+  const taken = new Set(liveGroupChatNames())
+
+  for (const meta of Object.values($botMeta.get() || {})) {
+    for (const existing of botGroups(meta)) {
+      taken.add(existing)
+    }
+  }
+
+  taken.delete(oldName)
+
+  if (taken.has(next)) {
+    host.notify({
+      kind: 'error',
+      message: botsText().group.nameTaken(next)
+    })
+
+    return null
+  }
+
+  // Move the room record wholesale — log, watermarks, sessions, members,
+  // picture, and runtime flags all belong to the same room under its new name.
+  const all: Record<string, GroupChat> = {
+    ...$groupChats.get()
+  }
+
+  const room = all[oldName]
+
+  if (room) {
+    migrateGroupComposerDraft(groupComposerDraftKey(oldName, room), groupComposerDraftKey(next, room))
+  }
+
+  delete all[oldName]
+
+  if (room) {
+    all[next] = room
+  }
+
+  $groupChats.set(all)
+
+  const needs: Record<string, boolean> = {
+    ...$groupNeedsYou.get()
+  }
+
+  if (oldName in needs) {
+    needs[next] = needs[oldName]
+    delete needs[oldName]
+    $groupNeedsYou.set(needs)
+  }
+
+  // Mirrored clarify cards key by group name; drop the old room's — the
+  // next poll re-mirrors any still-blocking question under the new name.
+  clearGroupClarify(oldName)
+
+  // Local memberships: swap the name inside each member's canonical groups
+  // list (syncs cross-machine via ui_meta). Remote members' seating lives in
+  // the room record we just moved.
+  for (const member of members || []) {
+    if (!member?.name) {
+      continue
+    }
+
+    const meta = botRosterMeta(member, $botMeta.get()) || {}
+    const groups = [...new Set(botGroups(meta).map(g => (g === oldName ? next : g)))]
+    await saveBotMeta(member, {
+      groups,
+      group: groups[0] || null
+    })
+  }
+
+  // Persist the re-keyed map (updateGroupChat writes the whole durable map).
+  updateGroupChat(next, (r: GroupChatRoom) => r, {
+    sync: false
+  })
+  // A rename is one revisioned state transition: the new identity is updated
+  // and the old identity is tombstoned together, so cold hydration cannot
+  // merge the pre-rename room back into the roster.
+  scheduleGroupChatServerSync($groupChats.get(), {
+    changedRooms: [next],
+    deletedRooms: [oldName]
+  })
+
+  // Follow the open views to the new identity.
+  if ($groupChatWorkspace.get() === oldName) {
+    $groupChatWorkspace.set(next)
+  }
+
+  if (groupChatMainTabs.has(oldName)) {
+    closeGroupChatMainTab(oldName)
+    openGroupChat(next)
+  }
+
+  // Same convergence as disband: drop the pre-rename roster snapshot so the
+  // old name can't linger anywhere the fence doesn't cover.
+  if (typeof queryClient !== 'undefined' && queryClient?.invalidateQueries) {
+    queryClient.invalidateQueries({
+      queryKey: ROSTER_KEY
+    })
+  }
+
+  return next
+}
+
+interface GroupChatSettingsDialogProps {
+  group: string
+  members?: GroupMember[]
+  onClose: () => void
+  onRenamed?: (group: string) => void
+  open: boolean
+}
+
+/** Edit an existing group chat's name and picture. Renames re-key the room
+ *  and every local member's membership (renameGroupChat); the picture rides
+ *  the room record. Both apply on Save so a cancelled dialog changes nothing. */
+function GroupChatSettingsDialog({ group, members, open, onClose, onRenamed }: GroupChatSettingsDialogProps) {
+  const { t } = useI18n()
+  const b = useBots()
+  const rooms: Record<string, GroupChatRoom> = useValue($groupChats)
+  const current = (rooms[group] || {}).image || null
+  const [name, setName] = useState(group)
+  const [image, setImage] = useState(current)
+  useEffect(() => {
+    if (open) {
+      setName(group)
+      setImage(current)
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open, group])
+
+  const save = async () => {
+    const finalName = await renameGroupChat(group, name, members)
+
+    if (finalName === null) {
+      return // collision — dialog stays open for a different name
+    }
+
+    if (image !== current) {
+      setGroupChatImage(finalName, image)
+    }
+
+    onClose()
+
+    if (finalName !== group) {
+      onRenamed?.(finalName)
+    }
+  }
+
+  return (
+    <Dialog
+      onOpenChange={value => {
+        if (!value) {
+          onClose()
+        }
+      }}
+      open={open}
+    >
+      <DialogContent className="max-w-sm">
+        <DialogHeader>
+          <DialogTitle>{b.group.settingsTitle}</DialogTitle>
+          <DialogDescription>{b.group.settingsDesc}</DialogDescription>
+        </DialogHeader>
+        <GroupImageControls
+          image={image}
+          onImage={setImage}
+          seedMembers={(members || []).map(member => member.name)}
+          seedName={name.trim() || group}
+        />
+        <form
+          onSubmit={event => {
+            event.preventDefault()
+            void save()
+          }}
+        >
+          <Input
+            aria-label={b.group.nameLabel}
+            autoFocus
+            maxLength={64}
+            onChange={event => setName(event.target.value)}
+            value={name}
+          />
+        </form>
+        <DialogFooter>
+          <Button onClick={onClose} variant="secondary">
+            {t.common.cancel}
+          </Button>
+          <Button disabled={!name.trim()} onClick={() => void save()}>
+            {t.common.save}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+// ── threads: the Slack/Discord shape ─────────────────────────────────────────
+// Every room entry belongs to a THREAD. Messaging the room composer starts a
+// new thread with the whole group; replying inside a thread continues that
+// work. Member turns are scoped to the thread that triggered them — deltas,
+// watermarks, and responder resolution all key on the thread id.
+
+/** One thread's slice of the room log, with each entry's index in that log. */
+interface GroupThreadBucket {
+  entries: Array<{ entry: GroupMessage; index: number }>
+  id: string
+  startIndex: number
+}
+
+interface GroupChatWorkspaceProps {
+  group: string
+  members: GroupMember[]
+  onBack?: () => void
+  visible?: boolean
+}
+
+export function GroupChatWorkspace({ group, members, onBack, visible = true }: GroupChatWorkspaceProps) {
+  const b = useBots()
+  const rooms: Record<string, GroupChatRoom> = useValue($groupChats)
+  const allMeta: Record<string, BotMeta> = useValue($botMeta)
+
+  const room: GroupChatRoom = rooms[group] || {
+    log: [],
+    running: false
+  }
+
+  const composerKey = groupComposerDraftKey(group, room)
+  const composerKeyRef = useRef(composerKey)
+  const [composerDraft, setComposerDraft] = useState(() => groupComposerDraftSnapshot(composerKey))
+
+  if (composerKeyRef.current !== composerKey) {
+    migrateGroupComposerDraft(composerKeyRef.current, composerKey)
+    composerKeyRef.current = composerKey
+  }
+
+  const updateComposerDraft = (mutate: (draft: GroupComposerDraft) => GroupComposerDraft) => {
+    const next = updateGroupComposerDraft(composerKeyRef.current, mutate)
+    setComposerDraft(next)
+
+    return next
+  }
+
+  const draft = composerDraft.main || ''
+  const replyDrafts = composerDraft.replies || {}
+  const replyThread = composerDraft.activeReplyThread || null
+  const pendingImages = composerDraft.pendingAttachments || {}
+
+  const setDraft = (value: GroupDraftSetter<string>) =>
+    updateComposerDraft(current => ({
+      ...current,
+      main: typeof value === 'function' ? value(current.main || '') : value
+    }))
+
+  const setReplyDrafts = (value: GroupDraftSetter<Record<string, string>>) =>
+    updateComposerDraft(current => ({
+      ...current,
+      replies: typeof value === 'function' ? value(current.replies || {}) : value
+    }))
+
+  const setReplyThread = (value: GroupDraftSetter<null | string>) =>
+    updateComposerDraft(current => ({
+      ...current,
+      activeReplyThread: typeof value === 'function' ? value(current.activeReplyThread || null) : value
+    }))
+
+  const setPendingImages = (value: GroupDraftSetter<Record<string, Attachment[]>>) =>
+    updateComposerDraft(current => ({
+      ...current,
+      pendingAttachments: typeof value === 'function' ? value(current.pendingAttachments || {}) : value
+    }))
+
+  const [confirmDisband, setConfirmDisband] = useState(false)
+  const [settingsOpen, setSettingsOpen] = useState(false)
+  // Click-to-disambiguate: which log entry is showing its speaker's full
+  // @handle (the roster's name-device form when names collide across
+  // connections). Naturally every speaker just shows its display name.
+  const [revealedSpeaker, setRevealedSpeaker] = useState<null | string>(null)
+  // Threads, the Slack/Discord shape: entries carry a thread id. The most
+  // recently active thread renders open; older ones collapse to summary rows.
+  // `openThreads` is the user's explicit expand/collapse overrides, and
+  // `replyThread` is the thread whose reply box currently owns the composer
+  // (null = the main composer, which STARTS a new thread).
+  const [openThreads, setOpenThreads] = useState<Record<string, boolean>>({})
+  // Pending image attachments per composer: `null` thread key = the main
+  // composer, otherwise the reply box of that thread. Data URLs, already
+  // downscaled — they ride the send into every responding member's session.
+
+  // Scroll anchoring (#89835): rooms used to open at scroll position 0 and
+  // stay there while replies streamed in. Scroll the bottom sentinel into
+  // view on mount and whenever the log grows — but only when the user is
+  // already near the bottom, so reading history is never yanked away.
+  const bottomSentinelRef = useRef<HTMLDivElement | null>(null)
+  const stickToBottomRef = useRef(true)
+  // eslint-disable-next-line no-restricted-syntax -- tracks live scroll position from a DOM listener, not an atom
+  useEffect(() => {
+    const sentinel = bottomSentinelRef.current
+
+    if (!sentinel) {
+      return
+    }
+
+    const viewport = sentinel.closest('[data-slot="scroll-area-viewport"]')
+
+    if (viewport) {
+      const onScroll = () => {
+        stickToBottomRef.current = viewport.scrollHeight - viewport.scrollTop - viewport.clientHeight < 80
+      }
+
+      viewport.addEventListener('scroll', onScroll, {
+        passive: true
+      })
+
+      return () => viewport.removeEventListener('scroll', onScroll)
+    }
+  }, [])
+  useEffect(() => {
+    if (stickToBottomRef.current) {
+      bottomSentinelRef.current?.scrollIntoView({
+        block: 'end'
+      })
+    }
+  }, [room.log.length, room.running])
+
+  // Retained-pane reopen (#89835 follow-up): a hot-mounted room pane stays
+  // mounted while another workspace tab is active, so returning to it never
+  // remounts and the mount-time anchor doesn't rerun. Re-anchor on the
+  // hidden → visible edge — an explicit reopen, so it overrides a stale
+  // read-position and mirrors what a fresh open does.
+  const wasVisibleRef = useRef(visible)
+  // eslint-disable-next-line no-restricted-syntax -- previous-value tracker for the hidden → visible edge; lagging a render IS the contract
+  useEffect(() => {
+    if (visible && !wasVisibleRef.current) {
+      stickToBottomRef.current = true
+      bottomSentinelRef.current?.scrollIntoView({
+        block: 'end'
+      })
+    }
+
+    wasVisibleRef.current = visible
+  }, [visible])
+  const imagesFor = (thread: null | string) => pendingImages[thread ?? 'main'] || []
+
+  const addImages = (thread: null | string, picked: Attachment[]) => {
+    if (!picked.length) {
+      return
+    }
+
+    const key = thread ?? 'main'
+    setPendingImages(prev => ({
+      ...prev,
+      [key]: [...(prev[key] || []), ...picked]
+    }))
+  }
+
+  const removeImage = (thread: null | string, index: number) => {
+    const key = thread ?? 'main'
+    setPendingImages(prev => ({
+      ...prev,
+      [key]: (prev[key] || []).filter((_, i) => i !== index)
+    }))
+  }
+
+  // Ctrl/⌘-V a screenshot (or any file) into any composer in this room.
+  const pasteImages = (thread: null | string, event: ClipboardEvent<HTMLTextAreaElement>) => {
+    const files = [...(event.clipboardData?.files || [])]
+
+    if (!files.length) {
+      return
+    }
+
+    event.preventDefault()
+    void filesToGroupAttachments(files).then(picked => addImages(thread, picked))
+  }
+
+  // Drag & drop anywhere on the room drops into the ACTIVE composer — the
+  // open reply box when one owns the composer, else the main (new-thread)
+  // composer. Matches the 1:1 chat's drop affordance.
+  const [dragOver, setDragOver] = useState(false)
+
+  const dropFiles = (event: DragEvent<HTMLDivElement>) => {
+    const files = [...(event.dataTransfer?.files || [])]
+    setDragOver(false)
+
+    if (!files.length) {
+      return
+    }
+
+    event.preventDefault()
+    void filesToGroupAttachments(files).then(picked => addImages(replyThread, picked))
+  }
+
+  // Collapsible Activity view: collapsed by default — opening it is always an
+  // explicit user action, it never steals focus, and it never auto-scrolls.
+  const [activityOpen, setActivityOpen] = useState(false)
+  // Subscribe: activity rows re-render as turn events land.
+  useValue($groupActivity)
+  // Pending member questions for THIS room (#90694), oldest first.
+  const clarifyAll: Record<string, GroupRoomPrompt> = useValue($groupClarify)
+
+  const roomClarifies = Object.values(clarifyAll || {})
+    .filter(entry => entry?.group === group)
+    .sort((a, b) => (a.at || 0) - (b.at || 0))
+
+  const availableMembers = members.filter(member => botSourceStatus(member).available).length
+  const availabilityLabel = `${availableMembers} of ${members.length} available`
+
+  const memberNames =
+    members.map(b => displayName(b, botRosterMeta(b, allMeta))).join(', ') || 'No bots in this group chat'
+
+  const header = (
+    <div className="flex items-center gap-2 px-2.5 pt-2.5 pb-2">
+      <Button onClick={() => (onBack ? onBack() : $groupChatWorkspace.set(null))} size="sm" variant="ghost">
+        Back
+      </Button>
+      {/* Room picture (set via Group settings) leads the title when present. */}
+      {room.image ? (
+        <img
+          alt=""
+          className="size-6 shrink-0 rounded-md object-cover ring-1 ring-(--ui-stroke-secondary)"
+          src={room.image}
+        />
+      ) : (
+        <span className="flex size-6 shrink-0 items-center justify-center rounded-md bg-(--chrome-action-hover) text-(--ui-text-tertiary)">
+          <Codicon name="organization" />
+        </span>
+      )}
+      <div className="min-w-0 flex-1 truncate text-sm font-semibold">{group}</div>
+      <Tip label={memberNames}>
+        <span
+          aria-label={availabilityLabel}
+          className={cn(
+            'shrink-0 text-[0.65rem] text-(--ui-text-quaternary)',
+            members.length > 0 && availableMembers < members.length && 'text-amber-600 dark:text-amber-300'
+          )}
+        >
+          {members.length > 0 && availableMembers < members.length
+            ? availabilityLabel
+            : b.group.memberCount(members.length)}
+        </span>
+      </Tip>
+      <Tip label={b.group.settingsHint(group)}>
+        <Button
+          aria-label={b.group.settingsLabel(group)}
+          className="shrink-0 text-(--ui-text-tertiary) hover:text-foreground"
+          onClick={() => setSettingsOpen(true)}
+          size="sm"
+          variant="ghost"
+        >
+          <Codicon name="gear" />
+        </Button>
+      </Tip>
+      <Tip label={b.group.disbandHint(group)}>
+        <Button
+          aria-label={b.group.disbandLabel(group)}
+          className="shrink-0 text-(--ui-text-tertiary) hover:text-destructive"
+          onClick={() => setConfirmDisband(true)}
+          size="sm"
+          variant="ghost"
+        >
+          <Codicon name="trash" />
+        </Button>
+      </Tip>
+    </div>
+  )
+
+  const memberDescriptors = () =>
+    members.map(b => ({
+      ...b,
+      title: (b.remoteSource ? '' : allMeta[b.name]?.title) || b.title || ''
+    }))
+
+  // Activity disclosure: quiet, collapsed by default. The collapsed row shows
+  // the latest event; expanding lists the current run's events newest-first.
+  // Events are epoch-tagged, so a superseded run's history drops out of view.
+  const activityEvents: GroupActivityEntry[] = currentGroupActivity(group)
+  const latestActivity = activityEvents.length ? activityEvents[activityEvents.length - 1] : null
+
+  // #94570 shell rewired onto the real primitive (#91868/#94569): the button
+  // must stop the ROUND, not just spray per-member interrupts — without the
+  // epoch bump + holds the loop marched on to the next member. Thread scope:
+  // the run being stopped is the one the latest activity belongs to.
+  const stopRoomRun = async () => {
+    await stopGroupThread(group, latestActivity?.thread || null, memberDescriptors())
+    host.notify({
+      kind: 'success',
+      message: b.group.stopped(group)
+    })
+  }
+
+  const activityPanel = (
+    <div className="border-b border-(--ui-stroke-secondary)">
+      <div className="flex items-center gap-1">
+        <RowButton
+          aria-controls={`group-activity:${group}`}
+          aria-expanded={activityOpen}
+          className="flex min-w-0 flex-1 items-center gap-1.5 px-2.5 py-1 text-left text-[0.7rem] text-(--ui-text-quaternary) transition-colors hover:text-foreground"
+          onClick={() => setActivityOpen(prev => !prev)}
+          title={activityOpen ? b.group.hideActivity : b.group.showActivity}
+        >
+          <Codicon className="shrink-0 text-[0.65rem]" name={activityOpen ? 'chevron-down' : 'chevron-right'} />
+          <span className="shrink-0 font-medium">{b.group.activity}</span>
+          {latestActivity ? (
+            <span className="min-w-0 flex-1 truncate">{`${groupActivityLabel(latestActivity)} · ${relativeTime(latestActivity.at)}`}</span>
+          ) : null}
+        </RowButton>
+        {room.running ? (
+          <Tip label={b.group.stopHint}>
+            <Button
+              className="shrink-0 text-(--ui-accent)"
+              onClick={() => void stopRoomRun()}
+              size="xs"
+              variant="ghost"
+            >
+              <Codicon name="debug-stop" />
+              {b.group.stop}
+            </Button>
+          </Tip>
+        ) : null}
+      </div>
+      {activityOpen ? (
+        <div className="grid gap-0.5 px-2.5 pb-1.5" id={`group-activity:${group}`}>
+          {activityEvents.length ? (
+            [...activityEvents].reverse().map((event, i) => (
+              <div className="flex items-center gap-1.5 text-[0.7rem]" key={`${event.at}:${i}`}>
+                <Codicon
+                  className={cn('shrink-0 text-[0.65rem]', groupActivityTone(event.kind))}
+                  name={GROUP_ACTIVITY_GLYPHS[event.kind] || 'circle-outline'}
+                />
+                <span className={cn('min-w-0 flex-1 truncate', groupActivityTone(event.kind))}>
+                  {groupActivityLabel(event)}
+                </span>
+                <span className="shrink-0 text-[0.625rem] text-(--ui-text-quaternary)">{relativeTime(event.at)}</span>
+                {event.kind === 'working' ? (
+                  <Tip label={b.group.stopHint}>
+                    <Button
+                      className="shrink-0 text-(--ui-accent)"
+                      onClick={() => void stopRoomRun()}
+                      size="micro"
+                      variant="ghost"
+                    >
+                      <Codicon name="debug-stop" />
+                      {b.group.stop}
+                    </Button>
+                  </Tip>
+                ) : null}
+              </div>
+            ))
+          ) : (
+            <div className="px-0.5 pb-0.5 text-[0.625rem] text-(--ui-text-quaternary)">{b.group.noActivityYet}</div>
+          )}
+        </div>
+      ) : null}
+    </div>
+  )
+
+  const submit = () => {
+    const text = draft.trim()
+    const images = imagesFor(null)
+
+    if (!text && !images.length) {
+      return
+    }
+
+    const before = groupComposerDraftSnapshot(composerKeyRef.current)
+
+    const cleared = updateComposerDraft(current => ({
+      ...current,
+      main: '',
+      pendingAttachments: {
+        ...(current.pendingAttachments || {}),
+        main: []
+      }
+    }))
+
+    // Main composer = START A NEW THREAD with the whole group (Slack shape).
+    // Full descriptors ride into the turn loop: remote members keep their
+    // connection fields so their turns route to their own machines.
+    const minted = sendToGroupChat(group, memberDescriptors(), text, null, images)
+
+    if (minted) {
+      setOpenThreads(prev => ({
+        ...prev,
+        [minted]: true
+      }))
+    } else {
+      const restored = restoreGroupComposerDraft(composerKeyRef.current, cleared.revision, before)
+
+      if (restored) {
+        setComposerDraft(restored)
+      }
+    }
+  }
+
+  const submitReply = (thread: string) => {
+    const text = (replyDrafts[thread] || '').trim()
+    const images = imagesFor(thread)
+
+    if (!text && !images.length) {
+      return
+    }
+
+    const before = groupComposerDraftSnapshot(composerKeyRef.current)
+
+    const cleared = updateComposerDraft(current => ({
+      ...current,
+      pendingAttachments: {
+        ...(current.pendingAttachments || {}),
+        [thread]: []
+      },
+      replies: {
+        ...(current.replies || {}),
+        [thread]: ''
+      }
+    }))
+
+    // Reply box = CONTINUE this thread; the member turns it triggers are
+    // scoped to it.
+    const sent = sendToGroupChat(group, memberDescriptors(), text, thread, images)
+
+    if (sent) {
+      setOpenThreads(prev => ({
+        ...prev,
+        [thread]: true
+      }))
+    } else {
+      const restored = restoreGroupComposerDraft(composerKeyRef.current, cleared.revision, before)
+
+      if (restored) {
+        setComposerDraft(restored)
+      }
+    }
+  }
+
+  /** Pending-attachment chips + the picker for one composer (thread = null →
+   *  main). Image chips preview the pixels; PDFs/files show a type icon.
+   *  X removes it. */
+  const attachmentRow = (thread: null | string) => {
+    const images = imagesFor(thread)
+
+    if (!images.length) {
+      return null
+    }
+
+    return (
+      <div className="flex flex-wrap items-center gap-1.5 px-1 pb-1">
+        {images.map((img, index) => (
+          <div
+            className="flex items-center gap-1 rounded-md border border-(--ui-stroke-secondary) bg-(--ui-bg-secondary) px-1 py-0.5"
+            key={`${img.name || 'img'}:${index}`}
+          >
+            {img.kind === 'pdf' || img.kind === 'file' ? (
+              <Codicon
+                className="text-[0.9rem] text-(--ui-text-tertiary)"
+                name={img.kind === 'pdf' ? 'file-pdf' : 'file'}
+              />
+            ) : (
+              <img alt="" className="size-6 rounded object-cover" src={img.data} />
+            )}
+            <span className="max-w-32 truncate text-[0.65rem] text-(--ui-text-tertiary)">{img.name || 'image'}</span>
+            <Tip label={b.group.removeAttachment}>
+              <Button
+                aria-label={b.group.removeAttachment}
+                onClick={() => removeImage(thread, index)}
+                size="icon-xs"
+                variant="ghost"
+              >
+                <Codicon name="close" />
+              </Button>
+            </Tip>
+          </div>
+        ))}
+      </div>
+    )
+  }
+
+  const attachButton = (thread: null | string) => (
+    <Button
+      className="shrink-0 text-(--ui-text-tertiary) hover:text-foreground"
+      onClick={() => void pickGroupAttachments().then(picked => addImages(thread, picked))}
+      size="sm"
+      title={b.group.attachHint}
+      type="button"
+      variant="ghost"
+    >
+      <Codicon name="attach" />
+    </Button>
+  )
+
+  // One log entry, rendered exactly as before conversation folding existed.
+  const renderEntry = (entry: GroupMessage, index: number) => {
+    const isUser = entry.from.kind === 'user'
+    const meta = isUser || entry.from.source ? null : allMeta[entry.from.name]
+
+    // Match this speaker back to its member descriptor so display
+    // names and disambiguating handles come from the roster (the
+    // primary "default" profile renders as Hermes, remote dupes
+    // carry their @name-device handle) instead of raw profile ids.
+    const member = isUser
+      ? null
+      : members.find(
+          b =>
+            b.name === entry.from.name &&
+            (entry.from.source ? (b.connectionLabel || b.connectionId) === entry.from.source : !b.remoteSource)
+        ) || null
+
+    const display = isUser
+      ? 'You'
+      : displayName(
+          member || {
+            name: entry.from.name
+          },
+          meta
+        )
+
+    const entryKey = `${entry.at}:${index}`
+    const revealed = !isUser && revealedSpeaker === entryKey
+
+    // Clicked: append the gateway name so same-named agents on
+    // two connections are tellable apart on demand.
+    const label = isUser
+      ? 'You'
+      : revealed
+        ? `${display}${entry.from.source ? `-${entry.from.source}` : ''} (@${botHandle(entry.from.name, member || undefined)})`
+        : display
+
+    // Speaker avatar: same appearance pipeline as the roster
+    // (custom image/pet, else deterministic shape+color face).
+    // Remote speakers have no local meta and get the
+    // deterministic face for their name — stable per bot.
+    // Non-null exactly when !isUser — the user's own lines carry no avatar.
+    const appearance = isUser ? null : botAppearance(entry.from.name, meta)
+    const image = appearance?.image ?? null
+    const photo = Boolean(image && !isBackfilledFacePng(image))
+
+    return (
+      <div
+        className={cn(
+          'group flex items-start gap-2',
+          isUser ? 'rounded-md bg-(--chrome-action-hover) px-2 py-1.5' : 'px-2 py-1'
+        )}
+        key={entryKey}
+      >
+        {appearance ? (
+          <div className="mt-0.5 shrink-0">
+            <BotFace
+              color={avatarColor(appearance.color, entry.from.name)}
+              image={photo ? image : null}
+              name={entry.from.name}
+              shape={appearance.shape}
+              size={24}
+            />
+          </div>
+        ) : null}
+        <div className="min-w-0 flex-1">
+          <div className="flex items-center gap-2">
+            {isUser ? (
+              <span className="text-[0.7rem] font-semibold text-foreground">{label}</span>
+            ) : (
+              <Button
+                className="text-left text-[0.7rem] font-semibold text-(--ui-accent)"
+                onClick={() => setRevealedSpeaker(revealed ? null : entryKey)}
+                size="inline"
+                title={revealed ? 'Hide full handle' : 'Show full handle'}
+                variant="text"
+              >
+                {label}
+              </Button>
+            )}
+            <span className="text-[0.625rem] text-(--ui-text-quaternary)">{relativeTime(entry.at)}</span>
+            {entry.text.trim() ? (
+              <div className="ml-auto shrink-0 opacity-0 pointer-events-none group-hover:pointer-events-auto group-hover:opacity-100 focus-within:pointer-events-auto focus-within:opacity-100">
+                <CopyButton appearance="icon" buttonSize="icon" stopPropagation text={entry.text} />
+              </div>
+            ) : null}
+          </div>
+          <div
+            className="text-xs text-(--ui-text-secondary) [&_p]:mb-1 [&_p:last-child]:mb-0 [&_ul]:mb-1 [&_ul]:list-disc [&_ul]:pl-4 [&_ol]:mb-1 [&_ol]:list-decimal [&_ol]:pl-4 [&_pre]:overflow-x-auto" // The app shell sets user-select: none globally; message bodies opt
+            // back in so drag-select and ⌘C work in group chat logs.
+            data-selectable-text="true"
+          >
+            {Streamdown ? <Streamdown>{entry.text}</Streamdown> : entry.text}
+          </div>
+          {/* User attachments: what every responding bot was */
+          /* shown — image previews, or a named chip for */
+          /* PDFs/files. */}
+          {Array.isArray(entry.images) && entry.images.length ? (
+            <div className="mt-1 flex flex-wrap items-center gap-1.5">
+              {entry.images.map((img, imgIndex) =>
+                img.kind === 'pdf' || img.kind === 'file' ? (
+                  <div
+                    className="flex items-center gap-1 rounded-md border border-(--ui-stroke-secondary) px-1.5 py-1 text-[0.65rem] text-(--ui-text-tertiary)"
+                    key={`${entryKey}:img:${imgIndex}`}
+                    title={img.name || 'attached file'}
+                  >
+                    <Codicon className="text-[0.8rem]" name={img.kind === 'pdf' ? 'file-pdf' : 'file'} />
+                    <span className="max-w-48 truncate">{img.name || 'attached file'}</span>
+                  </div>
+                ) : (
+                  <img
+                    alt={img.name || 'attached image'}
+                    className="max-h-40 max-w-60 rounded-md border border-(--ui-stroke-secondary) object-contain"
+                    key={`${entryKey}:img:${imgIndex}`}
+                    src={img.data}
+                    title={img.name || 'attached image'}
+                  />
+                )
+              )}
+            </div>
+          ) : null}
+        </div>
+      </div>
+    )
+  }
+
+  // Threads: group entries by thread id (hydration assigned legacy ids, but
+  // guard live pre-thread entries too), ordered by last activity — oldest
+  // first, so the busiest/newest thread sits at the bottom by the composer.
+  // The most recently ACTIVE thread renders open; older ones collapse to a
+  // Slack-style summary row unless explicitly opened. Every open thread gets
+  // its own reply box, which continues THAT thread.
+  const threadsById = new Map<string, GroupThreadBucket>()
+
+  for (let i = 0; i < room.log.length; i++) {
+    const entry = room.log[i]
+    const id = groupThreadOf(entry)
+    let bucket = threadsById.get(id)
+
+    if (!bucket) {
+      bucket = {
+        entries: [],
+        id,
+        startIndex: i
+      }
+      threadsById.set(id, bucket)
+    }
+
+    bucket.entries.push({
+      entry,
+      index: i
+    })
+  }
+
+  const threads = [...threadsById.values()].sort(
+    (a, b) => (a.entries[a.entries.length - 1].entry.at || 0) - (b.entries[b.entries.length - 1].entry.at || 0)
+  )
+
+  const newestThread = threads.length ? threads[threads.length - 1].id : null
+  const logChildren: ReactNode[] = []
+  threads.forEach(threadBucket => {
+    const { entries, id } = threadBucket
+    const head = entries.find(({ entry }) => entry.from.kind === 'user')?.entry || entries[0].entry
+    const isNewest = id === newestThread
+    const expanded = openThreads[id] ?? isNewest
+
+    if (!expanded) {
+      const replies = entries.length - 1
+      const headText = stripPreviewMarkdown(head?.text || '').slice(0, 80)
+      logChildren.push(
+        <RowButton
+          className="flex w-full items-center gap-2 rounded-md border border-(--ui-stroke-secondary) px-2 py-1.5 text-left text-xs text-(--ui-text-tertiary) transition-colors hover:bg-(--chrome-action-hover)"
+          key={`fold:${id}`}
+          onClick={() =>
+            setOpenThreads(prev => ({
+              ...prev,
+              [id]: true
+            }))
+          }
+          title={b.group.openThread}
+        >
+          <Codicon className="shrink-0 text-[0.65rem]" name="chevron-right" />
+          <span className="min-w-0 flex-1 truncate">{headText || b.group.threadFallback}</span>
+          <span className="shrink-0 text-[0.625rem] text-(--ui-text-quaternary)">{`${b.group.replyCount(replies)} · ${relativeTime(entries[entries.length - 1].entry.at)}`}</span>
+        </RowButton>
+      )
+
+      return
+    }
+
+    // Open thread: a rail-indented block — collapse affordance, its entries,
+    // and its own reply box (Slack's "reply in thread").
+    const threadRows: ReactNode[] = []
+
+    if (!isNewest || openThreads[id] !== undefined) {
+      threadRows.push(
+        <RowButton
+          className="flex w-full items-center gap-1.5 px-2 pt-1 text-left text-[0.65rem] text-(--ui-text-quaternary) transition-colors hover:text-foreground"
+          key={`unfold:${id}`}
+          onClick={() =>
+            setOpenThreads(prev => ({
+              ...prev,
+              [id]: false
+            }))
+          }
+          title={b.group.collapseThreadLabel}
+        >
+          <Codicon className="text-[0.6rem]" name="chevron-down" />
+          {b.group.collapseThread}
+        </RowButton>
+      )
+    }
+
+    for (const { entry, index } of entries) {
+      threadRows.push(renderEntry(entry, index))
+    }
+
+    // Reply-in-thread: the newest thread's continuation ALSO lives here, so
+    // the main composer below can stay "new thread" without ambiguity.
+    threadRows.push(
+      replyThread === id ? (
+        <form
+          className="grid gap-0 px-2 pb-1"
+          key={`replybox:${id}`}
+          onSubmit={event => {
+            event.preventDefault()
+            submitReply(id)
+          }}
+        >
+          {attachmentRow(id)}
+          <div className="flex items-center gap-1.5">
+            <GroupMentionInput
+              aria-label={b.group.replyInThread}
+              autoFocus
+              members={members}
+              onChange={text =>
+                setReplyDrafts(prev => ({
+                  ...prev,
+                  [id]: text
+                }))
+              }
+              onPaste={event => pasteImages(id, event)}
+              onSubmitDraft={() => submitReply(id)}
+              placeholder={b.group.replyInThreadPlaceholder}
+              value={replyDrafts[id] || ''}
+            />
+            {attachButton(id)}
+            <Button disabled={!(replyDrafts[id] || '').trim() && !imagesFor(id).length} size="sm" type="submit">
+              {b.group.reply}
+            </Button>
+          </div>
+        </form>
+      ) : (
+        <Button
+          className="w-fit px-2 pb-1 text-left text-[0.65rem] text-(--ui-accent) transition-colors"
+          key={`replylink:${id}`}
+          onClick={() => setReplyThread(id)}
+          size="inline"
+          variant="link"
+        >
+          {b.group.replyInThread}
+        </Button>
+      )
+    )
+    logChildren.push(
+      <div className="grid gap-1.5 border-l-2 border-(--ui-stroke-secondary) pl-1.5" key={`thread:${id}`}>
+        {threadRows}
+      </div>
+    )
+  })
+
+  return (
+    <div
+      className="relative flex h-full flex-col"
+      onDragLeave={event => {
+        // Only clear when leaving the room container itself, not when the
+        // cursor moves between its children. React types relatedTarget as a
+        // bare EventTarget; on a drag it is always an element or null.
+        if (!event.currentTarget.contains(event.relatedTarget as Node | null)) {
+          setDragOver(false)
+        }
+      }}
+      onDragOver={event => {
+        if ([...(event.dataTransfer?.types || [])].includes('Files')) {
+          event.preventDefault()
+          setDragOver(true)
+        }
+      }}
+      onDrop={dropFiles}
+    >
+      {dragOver ? (
+        <div
+          className="pointer-events-none absolute inset-0 z-40 flex items-center justify-center border-2 border-dashed border-(--ui-accent) text-sm font-medium text-(--ui-accent)"
+          key={'dropzone'}
+        >
+          {replyThread ? b.group.dropToThread : b.group.dropToRoom}
+        </div>
+      ) : null}
+      {header}
+      {activityPanel}
+      <div className="min-h-0 flex-1 overflow-y-auto overscroll-contain">
+        <div className="grid gap-1.5 px-2.5 pb-2">
+          {room.log.length
+            ? logChildren
+            : [
+                <div className="px-2 py-4 text-center text-xs text-(--ui-text-tertiary)" key={'empty'}>
+                  {b.group.composerPlaceholder}
+                </div>
+              ]}
+          {roomClarifies.map(entry => (
+            <GroupClarifyCard entry={entry} key={`clarify:${entry.memberKey}:${entry.requestId}`} members={members} />
+          ))}
+          {room.running ? (
+            <div className="px-2 py-1 text-[0.7rem] italic text-(--ui-text-quaternary)" key={'working'}>
+              {roomClarifies.length
+                ? b.group.waitingForAnswer
+                : room.turn
+                  ? b.group.memberThinking(groupSpeakerLabel(room.turn))
+                  : b.group.roomWorking}
+            </div>
+          ) : null}
+          {/* Scroll anchor (#89835): rooms opened at scroll position 0, mid- */
+          /* history. The effect below scrolls this sentinel into view on */
+          /* mount and on log growth — unless the user has scrolled up. */}
+          <div aria-hidden key={'bottom-sentinel'} ref={bottomSentinelRef} />
+        </div>
+      </div>
+      <div className="border-t border-(--ui-stroke-secondary) p-2">
+        <form
+          className="grid gap-0"
+          onSubmit={event => {
+            event.preventDefault()
+            submit()
+          }}
+        >
+          {attachmentRow(null)}
+          <div className="flex items-center gap-1.5">
+            <GroupMentionInput
+              aria-label={b.group.messageRoom(group)}
+              members={members}
+              onChange={setDraft}
+              onPaste={event => pasteImages(null, event)}
+              onSubmitDraft={submit}
+              placeholder={b.group.newThreadPlaceholder(group)}
+              value={draft}
+            />
+            {attachButton(null)}
+            <Button disabled={!draft.trim() && !imagesFor(null).length} size="sm" type="submit">
+              {b.group.newThread}
+            </Button>
+          </div>
+        </form>
+      </div>
+      <GroupChatSettingsDialog
+        group={group}
+        members={members}
+        onClose={() => setSettingsOpen(false)}
+        open={settingsOpen}
+      />
+      <ConfirmDialog
+        busyLabel={b.group.disbanding}
+        confirmLabel={b.group.disbandAction}
+        description={
+          /* New rooms title member sessions by roomId, legacy rooms by name — */
+          /* so the copy names the concept, not a literal session title. The */
+          /* name is bolded mid-sentence, so the copy splits around it and the */
+          /* prefix goes empty where the name leads (core's deleteDesc* shape). */
+          <span>
+            {b.group.disbandDescPrefix}
+            <span className="font-medium text-foreground">{group}</span>
+            {b.group.disbandDescSuffix(members.length)}
+          </span>
+        }
+        destructive
+        doneLabel={b.group.disbandDone}
+        onClose={() => setConfirmDisband(false)}
+        onConfirm={async () => {
+          clearGroupComposerDraft(composerKeyRef.current)
+          await disbandGroupChat(group, members)
+          host.notify({
+            kind: 'success',
+            message: b.group.disbanded(group)
+          })
+        }}
+        open={confirmDisband}
+        title={b.group.disbandTitle}
+      />
+    </div>
+  )
+}
+
+/** Main-window wrapper: seats the member roster reactively (live roster +
+ *  bot meta + the room's stored cross-connection descriptors) so the room
+ *  keeps working as members change while the tab is open. Also subscribes to
+ *  this pane's visibility (feature-detected host.paneVisibility): retained
+ *  panes stay mounted while hidden, so the workspace needs the hidden →
+ *  visible edge to re-anchor its log to the bottom (#89835 follow-up). */
+interface GroupChatMainViewProps {
+  group: string
+}
+
+function GroupChatMainView({ group }: GroupChatMainViewProps) {
+  const allMeta = useValue($botMeta)
+  // Subscribe: membership changes ride bot meta AND the room record.
+  useValue($groupChats)
+  const roster = useValue($lastRoster)
+  const members = groupChatMemberBots(group, roster, allMeta)
+
+  // Older SDKs have no paneVisibility: fall back to an always-visible atom so
+  // the hook order stays stable and behavior matches the previous build.
+  const $visible = useMemo(
+    () =>
+      typeof host.paneVisibility === 'function'
+        ? host.paneVisibility(`plugin-workspace:${ID}:group:${slugify(group)}`)
+        : atom(true),
+    [group]
+  )
+
+  const visible = useValue($visible)
+
+  return (
+    <GroupChatWorkspace group={group} members={members} onBack={() => closeGroupChatMainTab(group)} visible={visible} />
+  )
+}
+
+/** Open a group chat the Discord way: a tab taking over the MAIN chat window
+ *  (host.openWorkspace, newer desktops), falling back to the in-panel room
+ *  view on desktops whose SDK predates the main-area door.
+ *
+ *  Ordering matters (#89788 follow-up): the main tab must be RECORDED before
+ *  the selection atom is set. Setting the atom first opened a window where
+ *  BotsPane rendered with a selected group and an empty tab map — the
+ *  in-pane fallback painted alongside the main tab, and because the map
+ *  write itself repaints nothing, the duplicate stuck until an unrelated
+ *  re-render. */
+export function openGroupChat(group: string): void {
+  // A room selection supersedes any bot-open transition still hydrating.
+  // The in-flight host navigation may complete underneath this workspace,
+  // but it may not later close or visually steal the room the user chose.
+  bumpBotOpenGeneration()
+  $groupNeedsYou.set({
+    ...$groupNeedsYou.get(),
+    [group]: false
+  })
+  const ownerKey = groupWorkspaceOwnerKey(group)
+  setBotsWorkspaceOwner(ownerKey, null, 'New group conversations start in the group composer.')
+
+  if (typeof host.openWorkspace === 'function') {
+    try {
+      const close = host.openWorkspace(`${ID}:group:${slugify(group)}`, {
+        title: group,
+        minWidth: '24rem',
+        render: () => <GroupChatMainView group={group} />,
+        onClose: () => {
+          dropGroupMainTab(group)
+
+          if ($groupChatWorkspace.get() === group) {
+            $groupChatWorkspace.set(null)
+          }
+        }
+      })
+
+      recordGroupMainTab(group, close)
+      // Tab ownership is on record — the atom now only drives the roster
+      // highlight; shouldRenderGroupChatInPane stays false throughout.
+      $groupChatWorkspace.set(group)
+
+      return
+    } catch {
+      // Fall through to the in-panel room below.
+    }
+  }
+
+  // No main-window door (older desktop) or it threw: select the group so
+  // the in-panel room renders as the fallback surface.
+  $groupChatWorkspace.set(group)
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-chat.test.ts b/apps/desktop/src/plugins/hermes-bots/group-chat.test.ts
new file mode 100644
index 000000000000..b88c7056d17f
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-chat.test.ts
@@ -0,0 +1,984 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as groupChat from './group-chat'
+import type * as groupRounds from './group-rounds'
+import { createGroupGateway, deferTimers, drain, runTimersInline, scriptedStorage } from './group-test-utils'
+import type { GatewayOptions, ScriptedGateway } from './group-test-utils'
+import type { GroupChat, GroupMessage } from './types'
+
+// The room store: the atom every group surface reads, the durable projection
+// written to plugin storage, and the bounded mirror published to the gateway's
+// profile ui_meta so mobile sees the same rooms. Identity is the load-bearing
+// part — a room is a roomId, not a display name, and every merge has to agree
+// about that across devices that were offline for different windows.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+
+  return pluginSdkMock(host)
+})
+
+interface Room {
+  chat: typeof groupChat
+  gateway: ScriptedGateway
+  rounds: typeof groupRounds
+}
+
+/** The sync envelope, borrowed from the merge entry point — the interface
+ *  itself is private to group-chat.ts. */
+type SyncSnapshot = Parameters<typeof groupChat.mergeGroupChatSyncSnapshots>[0]
+
+async function loadRoom(options: GatewayOptions = {}): Promise<Room> {
+  vi.resetModules()
+  const gateway = createGroupGateway(options)
+
+  for (const key of Object.keys(host)) {
+    delete host[key]
+  }
+
+  Object.assign(host, gateway.host)
+
+  const [chat, rounds, shared] = await Promise.all([
+    import('./group-chat'),
+    import('./group-rounds'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx(scriptedStorage(gateway.storage))
+
+  return { chat, gateway, rounds }
+}
+
+const durable = (room: Room) => (room.gateway.storage.get('group-chats') || {}) as Record<string, GroupChat>
+
+/** The last mirror the sync worker published to the default profile. */
+function published(room: Room) {
+  const configure = room.gateway.rpcFor('profiles.configure').at(-1)
+
+  return (configure?.params.ui_meta as Record<string, Record<string, unknown>>)?.['hermes-bots-groups']
+}
+
+beforeEach(() => {
+  runTimersInline()
+})
+
+describe('log window', () => {
+  it('trimming keeps watermarks consistent with the trimmed array', async () => {
+    const { chat } = await loadRoom()
+
+    const log = Array.from({ length: 200 }, (_, i) => ({
+      at: i,
+      from: { kind: 'user', name: 'You' },
+      text: `m${i}`
+    })) as GroupMessage[]
+
+    const trimmed = chat.trimGroupChatLog(log, { builder: 10, research: 150 }, 96)
+
+    expect(trimmed.log).toHaveLength(96)
+    expect(trimmed.watermarks.research).toBe(150 - 104)
+    expect(trimmed.watermarks.builder).toBe(0)
+  })
+})
+
+describe('room naming', () => {
+  it('same-name dedup reserves suffix length at the 64-char cap', async () => {
+    const { chat } = await loadRoom()
+
+    expect(chat.uniqueGroupChatName('Team', new Set(['Other']))).toBe('Team')
+
+    // Slicing the joined string would chop the " 2"/" 3" suffix off a
+    // max-length base and collide with the original forever.
+    const base = 'x'.repeat(64)
+    const next = chat.uniqueGroupChatName(base, new Set([base, `${base.slice(0, 62)} 2`]))
+
+    expect(next).not.toBe(base)
+    expect(next).toHaveLength(64)
+    expect(next).toBe(`${base.slice(0, 62)} 3`)
+  })
+})
+
+describe('speaker labels', () => {
+  it('the default profile speaks as Hermes in transcripts, not @default', async () => {
+    const { rounds } = await loadRoom()
+
+    const line = rounds.formatGroupChatLine(
+      { from: { kind: 'member', name: 'default' }, text: 'hello room' } as GroupMessage,
+      'builder'
+    )
+
+    expect(line).toBe('Hermes: hello room')
+
+    // Other members keep their profile name; the (you) suffix survives.
+    expect(
+      rounds.formatGroupChatLine({ from: { kind: 'member', name: 'default' }, text: 'hi' } as GroupMessage, 'default')
+    ).toBe('Hermes (you): hi')
+    expect(
+      rounds.formatGroupChatLine({ from: { kind: 'member', name: 'builder' }, text: 'yo' } as GroupMessage, 'research')
+    ).toBe('builder: yo')
+  })
+
+  it('honor friendly identity: Bot Mode title, then display_name, never a stale Hermes', async () => {
+    const { chat, rounds } = await loadRoom()
+    const data = await import('./data')
+
+    // A renamed default (core display_name via `hermes profile rename`) must
+    // read as its new name — the community report was "Lucy" still showing
+    // "Hermes is thinking…" in group rooms.
+    data.$lastRoster.set([{ display_name: 'Lucy', name: 'default' }])
+
+    expect(chat.groupSpeakerLabel('default')).toBe('Lucy')
+    expect(
+      rounds.formatGroupChatLine({ from: { kind: 'member', name: 'default' }, text: 'hi' } as GroupMessage, 'builder')
+    ).toBe('Lucy: hi')
+
+    // A Bot Mode title outranks display_name (same precedence as displayName).
+    data.$botMeta.set({ default: { title: 'Moxie' } })
+
+    expect(chat.groupSpeakerLabel('default')).toBe('Moxie')
+
+    // Secondary profiles get their title too — the thinking line names the
+    // renamed bot, not the raw profile slug.
+    data.$botMeta.set({ research: { title: 'Radar' } })
+    data.$lastRoster.set([])
+
+    expect(chat.groupSpeakerLabel('research')).toBe('Radar')
+
+    // Untitled rows keep today's behavior: default → Hermes, others verbatim.
+    data.$botMeta.set({})
+
+    expect(chat.groupSpeakerLabel('default')).toBe('Hermes')
+    expect(chat.groupSpeakerLabel('builder')).toBe('builder')
+  })
+
+  it("never borrow a remote row's display_name for a local speaker", async () => {
+    const { chat } = await loadRoom()
+    const data = await import('./data')
+    // Only a remote/thin row named default exists — its display_name belongs
+    // to that connection, not to the active gateway's default.
+    data.$lastRoster.set([{ display_name: 'HomelabBot', name: 'default', remoteSource: true }])
+
+    expect(chat.groupSpeakerLabel('default')).toBe('Hermes')
+  })
+})
+
+// #93127: duplicate room delivery. Two raceable paths existed: a member turn
+// mid-flight when the room epoch bumps still committed its reply + watermark
+// (the stale loop only noticed supersession at the NEXT member boundary), and
+// the stale loop and the fresh loop could both append the same reply.
+describe('turn commit gate (#93127)', () => {
+  it('discards a superseded turn — the epoch moved on while the turn ran', async () => {
+    const { chat } = await loadRoom()
+
+    expect(chat.shouldCommitMemberTurn(3, 4)).toBe(false)
+    expect(chat.shouldCommitMemberTurn(3, 7)).toBe(false)
+    // Explicit same-thread supersession.
+    expect(chat.shouldCommitMemberTurn(3, 4, true)).toBe(false)
+  })
+
+  it('commits a current turn — the epoch is unchanged since dispatch', async () => {
+    const { chat } = await loadRoom()
+
+    expect(chat.shouldCommitMemberTurn(3, 3)).toBe(true)
+    expect(chat.shouldCommitMemberTurn(0, 0)).toBe(true)
+  })
+
+  it('does NOT discard finished work on a cross-thread epoch bump', async () => {
+    const { chat } = await loadRoom()
+
+    // Epoch moved, but no newer user entry landed in THIS thread: the
+    // superseding send lives in another thread whose loop filters this one
+    // out — dropping the reply would lose completed work forever.
+    expect(chat.shouldCommitMemberTurn(3, 4, false)).toBe(true)
+  })
+})
+
+describe('duplicate append guard (#93127)', () => {
+  const seed = (chat: typeof groupChat, entry: GroupMessage) => {
+    chat.$groupChats.set({ Room: { log: [entry], watermarks: {} } })
+  }
+
+  const lastEntry = (name: string, text: string, thread = 't1', at = Date.now(), source?: string): GroupMessage =>
+    ({
+      at,
+      from: { kind: 'member', name, ...(source ? { source } : {}) },
+      id: 'x',
+      text,
+      thread
+    }) as GroupMessage
+
+  it('drops an adjacent identical member reply', async () => {
+    const { chat } = await loadRoom()
+    seed(chat, lastEntry('impl', 'Stopped. Standing by.'))
+
+    chat.appendGroupChatEntry('Room', { kind: 'member', name: 'impl' }, 'Stopped. Standing by.', 't1')
+
+    expect(chat.$groupChats.get().Room.log).toHaveLength(1)
+  })
+
+  it('keeps identical text from a DIFFERENT member', async () => {
+    const { chat } = await loadRoom()
+    seed(chat, lastEntry('impl', 'Confirmed.'))
+
+    chat.appendGroupChatEntry('Room', { kind: 'member', name: 'reviewer' }, 'Confirmed.', 't1')
+
+    expect(chat.$groupChats.get().Room.log).toHaveLength(2)
+  })
+
+  it('keeps identical text from the same member on another SOURCE', async () => {
+    const { chat } = await loadRoom()
+    seed(chat, lastEntry('impl', 'Confirmed.', 't1', Date.now(), 'laptop'))
+
+    chat.appendGroupChatEntry('Room', { kind: 'member', name: 'impl' }, 'Confirmed.', 't1')
+
+    expect(chat.$groupChats.get().Room.log).toHaveLength(2)
+  })
+
+  it('keeps the same text after an intervening entry — only the LAST entry is checked', async () => {
+    const { chat } = await loadRoom()
+    seed(chat, lastEntry('reviewer', 'ack'))
+
+    chat.appendGroupChatEntry('Room', { kind: 'member', name: 'impl' }, 'Confirmed.', 't1')
+
+    expect(chat.$groupChats.get().Room.log).toHaveLength(2)
+  })
+
+  it('keeps identical text in a DIFFERENT thread', async () => {
+    const { chat } = await loadRoom()
+    seed(chat, lastEntry('impl', 'Confirmed.', 'thread-a'))
+
+    chat.appendGroupChatEntry('Room', { kind: 'member', name: 'impl' }, 'Confirmed.', 'thread-b')
+
+    expect(chat.$groupChats.get().Room.log).toHaveLength(2)
+  })
+
+  it('keeps identical text outside the recency window', async () => {
+    const { chat } = await loadRoom()
+    seed(chat, lastEntry('impl', 'Done.', 't1', Date.now() - 60 * 60 * 1000))
+
+    chat.appendGroupChatEntry('Room', { kind: 'member', name: 'impl' }, 'Done.', 't1')
+
+    expect(chat.$groupChats.get().Room.log).toHaveLength(2)
+  })
+
+  it('never dedupes user entries', async () => {
+    const { chat } = await loadRoom()
+    seed(chat, { at: Date.now(), from: { kind: 'user', name: 'You' }, id: 'x', text: 'stop', thread: 't1' })
+
+    chat.appendGroupChatEntry('Room', { kind: 'user', name: 'You' }, 'stop', 't1')
+
+    expect(chat.$groupChats.get().Room.log).toHaveLength(2)
+  })
+})
+
+describe('threads', () => {
+  it('hydration assigns legacy thread ids — a lull splits, follow-ups stay together', async () => {
+    const { chat } = await loadRoom()
+    const minute = 60000
+    const user = (text: string, at: number) => ({ at, from: { kind: 'user', name: 'You' }, text }) as GroupMessage
+
+    const member = (name: string, text: string, at: number) =>
+      ({ at, from: { kind: 'member', name }, text }) as GroupMessage
+
+    const log = chat.assignLegacyThreads([
+      user('task one', 0),
+      member('a', 'r1', 1 * minute),
+      user('quick follow-up', 3 * minute), // inside the 15-min window: SAME thread
+      member('a', 'r2', 4 * minute),
+      user('new topic much later', 60 * minute), // after the lull: new thread
+      member('a', 'r3', 61 * minute)
+    ])
+
+    expect(log[0].thread).toBe(log[2].thread)
+    expect(log[2].thread).toBe(log[3].thread)
+    expect(log[0].thread).not.toBe(log[4].thread)
+    expect(log[4].thread).toBe(log[5].thread)
+  })
+})
+
+describe('durable projection', () => {
+  it('excludes tombstoned rooms', async () => {
+    const { chat } = await loadRoom()
+
+    const rooms = chat.durableGroupChatRooms({
+      Keep: { log: [{ at: 1, from: { kind: 'user' }, text: 'hi' }], members: [], watermarks: {} },
+      Live: { epoch: 4, log: [], running: false, tombstone: true, watermarks: {} }
+    } as unknown as Record<string, GroupChat>)
+
+    expect('Live' in rooms).toBe(false)
+    expect('Keep' in rooms).toBe(true)
+  })
+
+  it('carries roomId — omitting it would drop the durable id on the next cold hydrate', async () => {
+    const { chat } = await loadRoom()
+
+    const rooms = chat.durableGroupChatRooms({
+      Legacy: { log: [{ at: 1, from: { kind: 'user' }, text: 'hi' }], members: [], watermarks: {} },
+      Team: { log: [{ at: 1, from: { kind: 'user' }, text: 'hi' }], members: [], roomId: 'room-abc123', watermarks: {} }
+    } as unknown as Record<string, GroupChat>)
+
+    expect(rooms.Team.roomId).toBe('room-abc123')
+    // An explicit null, not undefined — the key has to survive JSON.
+    expect(rooms.Legacy.roomId).toBeNull()
+  })
+
+  it('never persists a tombstone that a remote merge forwarded', async () => {
+    const room = await loadRoom()
+    // A drive still mid-turn at disband time leaves a live tombstone.
+    room.chat.$groupChats.set({
+      Live: { epoch: 4, log: [], running: false, tombstone: true, watermarks: {} }
+    } as unknown as Record<string, GroupChat>)
+
+    // The remote gateway has NOT yet received the delete (plausible now that
+    // sync fans out to every reachable default-profile gateway independently)
+    // — its snapshot still carries a live copy under the same display name.
+    const merged = room.chat.mergeRemoteGroupChatSnapshotIntoRooms(
+      {
+        rooms: {
+          Live: {
+            log: [{ at: 1, from: { kind: 'member', name: 'research' }, text: 'still going' }],
+            members: [{ name: 'research' }]
+          }
+        },
+        version: 3
+      },
+      room.chat.$groupChats.get()
+    )
+
+    // The merge spreads `...existing` before its explicit field overrides,
+    // none of which touch `tombstone` — so the flag survives into the merged
+    // room. Without that reachability step durableGroupChatRooms would never
+    // see a tombstoned room from this path at all.
+    expect(merged.Live.tombstone).toBe(true)
+
+    await room.chat.persistGroupChatRooms(merged)
+
+    expect('Live' in durable(room)).toBe(false)
+  })
+
+  it('stranded markers ride the durable map so late replies survive a reload', async () => {
+    const room = await loadRoom()
+
+    room.chat.updateGroupChat('Persist', current => {
+      current.stranded = { research: 3 }
+
+      return current
+    })
+
+    expect(durable(room).Persist.stranded?.research).toBe(3)
+  })
+})
+
+describe('gateway mirror', () => {
+  it('mirrors room messages and members through bounded profile metadata', async () => {
+    const room = await loadRoom()
+
+    room.rounds.sendToGroupChat(
+      'Research',
+      [
+        { handle: 'research', name: 'research' },
+        { handle: 'builder', name: 'builder' }
+      ],
+      'What changed?'
+    )
+    await drain(() => Boolean(room.chat.$groupChats.get().Research?.running))
+
+    const envelope = published(room)
+    const rooms = envelope.rooms as Record<string, Record<string, unknown>>
+    const key = Object.keys(rooms).find(name => rooms[name].name === 'Research')
+
+    expect(envelope.version).toBe(3)
+    expect(key).toBeDefined()
+    expect((rooms[key!].log as GroupMessage[])[0].text).toBe('What changed?')
+    expect((rooms[key!].members as { name: string }[]).map(member => member.name)).toEqual(['research', 'builder'])
+    expect(room.chat.groupChatGatewayJsonSize(envelope)).toBeLessThanOrEqual(48000)
+  })
+
+  it('is size bounded and favors recent messages', async () => {
+    const { chat } = await loadRoom()
+    const long = 'x'.repeat(5000)
+
+    const snapshot = chat.groupChatSyncSnapshot({
+      Large: {
+        log: Array.from({ length: 100 }, (_, index) => ({
+          at: index,
+          from: { kind: index % 2 ? 'member' : 'user', name: index % 2 ? 'research' : 'You' },
+          text: `${index}:${long}`
+        }))
+      }
+    } as unknown as Record<string, GroupChat>)
+
+    const log = snapshot.rooms['name:Large'].log
+
+    expect(chat.groupChatGatewayJsonSize(snapshot)).toBeLessThanOrEqual(48000)
+    expect(log.length).toBeLessThanOrEqual(16)
+    expect(log.at(-1)?.text).toMatch(/^99:/)
+    expect(log.at(-1)?.text.length).toBeLessThanOrEqual(1200)
+  })
+
+  it('preserves threads and budgets escaped Unicode', async () => {
+    const { chat } = await loadRoom()
+
+    const snapshot = chat.groupChatSyncSnapshot({
+      Unicode: {
+        log: Array.from({ length: 16 }, (_, index) => ({
+          at: index,
+          from: { kind: 'member', name: 'research' },
+          text: `message ${index} ${'🧠'.repeat(1200)}`,
+          thread: `thread-${index}`
+        }))
+      }
+    } as unknown as Record<string, GroupChat>)
+
+    expect(chat.groupChatGatewayJsonSize(snapshot)).toBeLessThanOrEqual(48000)
+    expect(snapshot.rooms['name:Unicode'].log.at(-1)?.thread).toBe('thread-15')
+  })
+
+  it('omits empty runtime rooms', async () => {
+    const { chat } = await loadRoom()
+
+    const snapshot = chat.groupChatSyncSnapshot({
+      Disbanded: { log: [], members: [{ name: 'research' }] }
+    } as unknown as Record<string, GroupChat>)
+
+    expect(Object.keys(snapshot.rooms)).toEqual([])
+  })
+
+  it('an empty hydrate cannot erase a shared room mirror', async () => {
+    const room = await loadRoom()
+    const before = room.gateway.rpc.length
+
+    room.chat.scheduleGroupChatServerSync({})
+
+    expect(room.gateway.rpc).toHaveLength(before)
+  })
+
+  it('an explicit final-room disband may clear the mirror', async () => {
+    const room = await loadRoom()
+
+    room.chat.scheduleGroupChatServerSync({}, { allowEmpty: true, deletedRooms: ['Research'] })
+    await drain(() => room.gateway.rpcFor('profiles.configure').length < 1, 50)
+
+    const envelope = published(room)
+
+    expect(Object.keys(envelope.rooms as object)).toEqual([])
+    expect((envelope.deleted as Record<string, number>)['name:Research']).toBeGreaterThan(0)
+  })
+})
+
+describe('snapshot merge', () => {
+  it('pull-before-push preserves disjoint rooms, messages and members', async () => {
+    const { chat } = await loadRoom()
+
+    const merged = chat.mergeGroupChatSyncSnapshots(
+      {
+        rooms: {
+          RemoteOnly: {
+            log: [{ at: 2, from: { kind: 'member', name: 'ops' }, text: 'kept' }],
+            members: [{ name: 'ops' }]
+          },
+          Shared: {
+            log: [{ at: 1, from: { kind: 'user', name: 'You' }, text: 'remote', thread: 'one' }],
+            members: [{ handle: 'research', name: 'research' }]
+          }
+        },
+        version: 1
+      },
+      {
+        rooms: {
+          Shared: {
+            log: [{ at: 3, from: { kind: 'member', name: 'builder' }, text: 'local', thread: 'one' }],
+            members: [{ handle: 'builder', name: 'builder' }]
+          }
+        },
+        version: 1
+      }
+    )
+
+    expect(merged.rooms['name:Shared'].log.map(entry => entry.text)).toEqual(['remote', 'local'])
+    expect(merged.rooms['name:Shared'].members?.map(member => member.name)).toEqual(['research', 'builder'])
+    expect(merged.rooms['name:RemoteOnly'].log[0].text).toBe('kept')
+  })
+
+  it('a deletion tombstone wins over stale history but not a later recreation', async () => {
+    const { chat } = await loadRoom()
+
+    const stale = chat.mergeGroupChatSyncSnapshots(
+      {
+        rooms: {
+          Research: { log: [{ at: 10, from: { kind: 'user', name: 'You' }, id: 'old', text: 'old' }], revision: 1 }
+        },
+        version: 2
+      },
+      { deleted: { Research: 2 }, rooms: {}, version: 2 }
+    )
+
+    expect(stale.rooms['name:Research']).toBeUndefined()
+    expect(stale.deleted?.['name:Research']).toBe(2)
+
+    const recreated = chat.mergeGroupChatSyncSnapshots(stale, {
+      rooms: {
+        Research: { log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'new', text: 'new' }], revision: 3 }
+      },
+      version: 2
+    })
+
+    expect(recreated.rooms['name:Research'].log[0].text).toBe('new')
+    expect(recreated.deleted).toBeUndefined()
+  })
+
+  it('orders deletion and recreation by gateway revision, not device clocks', async () => {
+    const { chat } = await loadRoom()
+
+    const merged = chat.mergeGroupChatSyncSnapshots(
+      {
+        rooms: {
+          ClockSkewed: {
+            log: [{ at: 9999999999999, from: { kind: 'user', name: 'You' }, id: 'future-clock', text: 'old' }],
+            revision: 8
+          }
+        },
+        version: 2
+      },
+      { deleted: { ClockSkewed: 9 }, rooms: {}, version: 2 }
+    )
+
+    expect(merged.rooms['name:ClockSkewed']).toBeUndefined()
+    expect(merged.deleted?.['name:ClockSkewed']).toBe(9)
+  })
+
+  it('lets a conflicting writer merge the winner and preserve both stable message ids', async () => {
+    const { chat } = await loadRoom()
+
+    const winner: SyncSnapshot = {
+      rooms: {
+        Shared: {
+          log: [{ at: 100, from: { kind: 'user', name: 'You' }, id: 'writer-a:1', text: 'alpha' }],
+          members: [{ name: 'alpha' }],
+          revision: 1
+        }
+      },
+      version: 2
+    }
+
+    const loserRetry = chat.mergeGroupChatSyncSnapshots(
+      winner,
+      {
+        rooms: {
+          Shared: {
+            log: [{ at: 1, from: { kind: 'member', name: 'beta' }, id: 'writer-b:1', text: 'beta' }],
+            members: [{ name: 'beta' }],
+            revision: 0
+          }
+        },
+        version: 2
+      },
+      { changedRooms: ['Shared'], writeRevision: 2 }
+    )
+
+    expect(loserRetry.rooms['name:Shared'].log.map(entry => entry.id).sort()).toEqual(['writer-a:1', 'writer-b:1'])
+    expect(loserRetry.rooms['name:Shared'].revision).toBe(2)
+  })
+})
+
+describe('cold hydrate', () => {
+  it('projects gateway rooms without dropping local runtime fields', async () => {
+    const { chat } = await loadRoom()
+
+    const merged = chat.mergeRemoteGroupChatSnapshotIntoRooms(
+      {
+        rooms: {
+          Shared: {
+            log: [
+              { at: 10, from: { kind: 'user', name: 'You' }, text: 'remote question', thread: 'thread-1' },
+              { at: 20, from: { kind: 'member', name: 'research' }, text: 'remote answer', thread: 'thread-1' }
+            ],
+            members: [{ connectionId: 'mini', name: 'research', sourceScoped: true }]
+          }
+        },
+        version: 3
+      },
+      {
+        Local: {
+          epoch: 7,
+          log: [{ at: 5, from: { kind: 'user', name: 'You' }, text: 'local', thread: 'thread-local' }],
+          members: [{ name: 'builder' }],
+          running: true,
+          sessions: { builder: 'session-1' },
+          watermarks: { builder: 1 }
+        }
+      } as unknown as Record<string, GroupChat>
+    )
+
+    expect(merged.Shared.log.map(entry => entry.text)).toEqual(['remote question', 'remote answer'])
+    expect(merged.Shared.members?.[0].remoteSource).toBe(true)
+    expect(merged.Local.sessions?.builder).toBe('session-1')
+    expect(merged.Local.epoch).toBe(7)
+    expect(merged.Local.running).toBe(true)
+  })
+
+  it('read-back does not clobber a newer local edit queued during an in-flight write', async () => {
+    const { chat } = await loadRoom()
+
+    const merged = chat.mergeRemoteGroupChatSnapshotIntoRooms(
+      {
+        rooms: {
+          Shared: {
+            image: 'data:image/png;base64,old',
+            log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'remote', text: 'remote message' }],
+            members: [{ name: 'old-member' }],
+            revision: 5
+          }
+        },
+        version: 2
+      },
+      {
+        Shared: {
+          image: 'data:image/png;base64,new',
+          log: [{ at: 2, from: { kind: 'user', name: 'You' }, id: 'local', text: 'local message' }],
+          members: [{ name: 'new-member' }],
+          syncRevision: 4
+        }
+      } as unknown as Record<string, GroupChat>,
+      { preserveRooms: ['Shared'] }
+    )
+
+    expect(merged.Shared.members?.map(member => member.name)).toEqual(['new-member'])
+    expect(merged.Shared.image).toBe('data:image/png;base64,new')
+    expect(merged.Shared.syncRevision).toBe(4)
+    expect(merged.Shared.log.map(entry => entry.id).sort()).toEqual(['local', 'remote'])
+  })
+
+  it('seats a member once when the projection re-derived its label and handle', async () => {
+    const { chat } = await loadRoom()
+
+    const merged = chat.mergeRemoteGroupChatSnapshotIntoRooms(
+      {
+        rooms: {
+          Shared: {
+            log: [],
+            members: [{ connectionId: 'mini', connectionLabel: 'Home lab', name: 'research', sourceScoped: true }],
+            revision: 1
+          }
+        },
+        version: 3
+      },
+      {
+        Shared: {
+          log: [],
+          members: [
+            {
+              connectionId: 'mini',
+              connectionLabel: 'Homelab',
+              handle: 'research',
+              name: 'research',
+              sourceScoped: true
+            }
+          ],
+          syncRevision: 1,
+          watermarks: {}
+        }
+      } as unknown as Record<string, GroupChat>
+    )
+
+    // Both copies answer to one groupMemberKey, so a second seat would take a
+    // second turn every round off a single watermark.
+    expect(merged.Shared.members?.map(member => member.name)).toEqual(['research'])
+  })
+})
+
+// A room's identity is its roomId. Display names are labels: renaming one is a
+// field update on the same key, and a name-keyed tombstone must never be able
+// to kill an id-keyed room (or vice versa).
+describe('room identity', () => {
+  it('rename publishes a new room plus an old-name tombstone that cold hydrate cannot resurrect', async () => {
+    const { chat } = await loadRoom()
+
+    const before: SyncSnapshot = {
+      rooms: {
+        Old: {
+          image: 'data:image/png;base64,room',
+          log: [{ at: 10, from: { kind: 'user', name: 'You' }, id: 'turn-1', text: 'history' }],
+          members: [{ name: 'research' }],
+          revision: 4
+        }
+      },
+      version: 2
+    }
+
+    const after = chat.mergeGroupChatSyncSnapshots(
+      before,
+      {
+        rooms: {
+          New: {
+            image: before.rooms.Old.image,
+            log: before.rooms.Old.log,
+            members: before.rooms.Old.members,
+            revision: 4
+          }
+        },
+        version: 2
+      },
+      { changedRooms: ['New'], deletedRooms: ['Old'], writeRevision: 5 }
+    )
+
+    const hydrated = chat.mergeRemoteGroupChatSnapshotIntoRooms(after, {})
+
+    expect(after.rooms['name:Old']).toBeUndefined()
+    expect(after.deleted?.['name:Old']).toBe(5)
+    expect(after.rooms['name:New'].revision).toBe(5)
+    expect(after.rooms['name:New'].image).toBe('data:image/png;base64,room')
+    expect(hydrated.Old).toBeUndefined()
+    expect(hydrated.New.log[0].text).toBe('history')
+    expect(hydrated.New.image).toBe('data:image/png;base64,room')
+  })
+
+  it('a rename with a roomId is a same-key field update, never delete+create', async () => {
+    const { chat } = await loadRoom()
+
+    const before: SyncSnapshot = {
+      rooms: {
+        'id:room-42': {
+          log: [{ at: 10, from: { kind: 'user', name: 'You' }, id: 'turn-1', text: 'history' }],
+          members: [{ name: 'research' }],
+          name: 'Old',
+          revision: 4,
+          roomId: 'room-42'
+        }
+      },
+      version: 3
+    }
+
+    const after = chat.mergeGroupChatSyncSnapshots(
+      before,
+      { rooms: { 'id:room-42': { ...before.rooms['id:room-42'], name: 'New' } }, version: 3 },
+      { changedRooms: ['id:room-42'], writeRevision: 5 }
+    )
+
+    // Same durable key, new display name, no tombstone needed at all.
+    expect(Object.keys(after.rooms)).toHaveLength(1)
+    expect(after.rooms['id:room-42'].name).toBe('New')
+    expect(after.rooms['id:room-42'].revision).toBe(5)
+    expect(after.deleted).toBeUndefined()
+
+    // A lagging gateway still holding the OLD name under the same id cannot
+    // resurrect it: same key, lower revision, identity follows the winner.
+    expect(chat.mergeGroupChatSyncSnapshots(before, after).rooms['id:room-42'].name).toBe('New')
+  })
+
+  it('id tombstones are final even against a higher-revision lagging copy', async () => {
+    const { chat } = await loadRoom()
+
+    const merged = chat.mergeGroupChatSyncSnapshots(
+      {
+        // A gateway that was OFFLINE during the disband still carries the room
+        // with a high revision from busy pre-disband traffic.
+        rooms: {
+          'id:room-9': {
+            log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'stale', text: 'stale' }],
+            name: 'Zombie',
+            revision: 40,
+            roomId: 'room-9'
+          }
+        },
+        version: 3
+      },
+      { deleted: { 'id:room-9': 3 }, rooms: {}, version: 3 }
+    )
+
+    expect(merged.rooms['id:room-9']).toBeUndefined()
+    expect(merged.deleted?.['id:room-9']).toBe(3)
+
+    // Same-name RECREATION is unaffected: the new room minted a fresh id.
+    const recreated = chat.mergeGroupChatSyncSnapshots(merged, {
+      rooms: {
+        'id:room-10': {
+          log: [{ at: 2, from: { kind: 'user', name: 'You' }, id: 'fresh', text: 'fresh' }],
+          name: 'Zombie',
+          revision: 1,
+          roomId: 'room-10'
+        }
+      },
+      version: 3
+    })
+
+    expect(recreated.rooms['id:room-10'].log[0].text).toBe('fresh')
+    expect(recreated.rooms['id:room-9']).toBeUndefined()
+  })
+
+  it('cold hydrate follows a remote rename via roomId instead of duplicating', async () => {
+    const { chat } = await loadRoom()
+
+    const merged = chat.mergeRemoteGroupChatSnapshotIntoRooms(
+      {
+        rooms: {
+          'id:room-7': {
+            log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'm1', text: 'hello' }],
+            members: [{ name: 'research' }],
+            name: 'Renamed',
+            revision: 6,
+            roomId: 'room-7'
+          }
+        },
+        version: 3
+      },
+      {
+        // Local copy still under the pre-rename display name, same roomId.
+        Original: {
+          log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'm1', text: 'hello' }],
+          members: [{ name: 'research' }],
+          roomId: 'room-7',
+          sessions: { research: 'sid-1' },
+          syncRevision: 5,
+          watermarks: {}
+        }
+      } as unknown as Record<string, GroupChat>
+    )
+
+    expect(merged.Original).toBeUndefined()
+    expect(merged.Renamed.roomId).toBe('room-7')
+    expect(merged.Renamed.sessions?.research).toBe('sid-1')
+  })
+
+  it('renaming an id-keyed room via the rename job shape never tombstones it', async () => {
+    const { chat } = await loadRoom()
+
+    const remote: SyncSnapshot = {
+      rooms: {
+        'id:room-3': {
+          log: [{ at: 5, from: { kind: 'user', name: 'You' }, id: 'h1', text: 'history' }],
+          members: [{ name: 'research' }],
+          name: 'Old',
+          revision: 2,
+          roomId: 'room-3'
+        }
+      },
+      version: 3
+    }
+
+    // Exactly what renameGroupChat schedules: changed [new], deleted [old].
+    const after = chat.mergeGroupChatSyncSnapshots(
+      remote,
+      { rooms: { 'id:room-3': { ...remote.rooms['id:room-3'], name: 'New' } }, version: 3 },
+      { changedRooms: ['New'], deletedRooms: ['Old'], writeRevision: 3 }
+    )
+
+    expect(after.rooms['id:room-3']).toBeDefined()
+    expect(after.rooms['id:room-3'].name).toBe('New')
+    expect(after.deleted?.['id:room-3']).toBeUndefined()
+    // A residual name:Old tombstone is correct — it retires stale v2/legacy
+    // copies of this room that older clients published under the name key.
+    expect(after.deleted?.['name:Old']).toBe(3)
+
+    // Hydrate path: the pull that races the rename write must not delete the
+    // locally re-keyed record just because the remote copy still says Old.
+    const merged = chat.mergeRemoteGroupChatSnapshotIntoRooms(
+      remote,
+      {
+        New: {
+          log: remote.rooms['id:room-3'].log,
+          members: [{ name: 'research' }],
+          roomId: 'room-3',
+          sessions: { research: 'sid-9' },
+          syncRevision: 2,
+          watermarks: {}
+        }
+      } as unknown as Record<string, GroupChat>,
+      { deletedRooms: ['Old'], preserveRooms: ['New'] }
+    )
+
+    expect(merged.New).toBeDefined()
+    expect(merged.New.sessions?.research).toBe('sid-9')
+    expect(merged.Old).toBeUndefined()
+  })
+})
+
+describe('sync worker', () => {
+  it('retries a gateway CAS conflict and publishes the merged room', async () => {
+    deferTimers()
+
+    // A concurrent writer lands between our read and our write: the gateway
+    // rejects the CAS, and the retry has to merge rather than overwrite.
+    const room = await loadRoom({
+      conflictOnce: {
+        key: 'hermes-bots-groups',
+        value: {
+          rooms: {
+            'name:Shared': {
+              log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'writer-a:1', text: 'alpha' }],
+              members: [{ name: 'alpha' }],
+              revision: 1
+            }
+          },
+          version: 3
+        }
+      }
+    })
+
+    room.chat.$groupChats.set({
+      Shared: {
+        log: [{ at: 2, from: { kind: 'member', name: 'beta' }, id: 'writer-b:1', text: 'beta' }],
+        members: [{ name: 'beta' }],
+        sessions: {},
+        syncRevision: 0,
+        watermarks: {}
+      }
+    } as unknown as Record<string, GroupChat>)
+
+    room.chat.scheduleGroupChatServerSync(room.chat.$groupChats.get(), { changedRooms: ['Shared'] })
+    await drain(() => (room.gateway.uiMetaRevisions['hermes-bots-groups'] || 0) < 2, 60)
+
+    const stored = room.gateway.uiMeta['hermes-bots-groups'] as {
+      rooms: Record<string, { log: GroupMessage[] }>
+    }
+
+    expect(room.gateway.uiMetaRevisions['hermes-bots-groups']).toBe(2)
+    expect(stored.rooms['name:Shared'].log.map(entry => entry.id).sort()).toEqual(['writer-a:1', 'writer-b:1'])
+    expect(room.gateway.rpcFor('profiles.configure')).toHaveLength(2)
+  })
+
+  it('fans a room write out to every reachable default-profile gateway', async () => {
+    const room = await loadRoom()
+    const remote: { connectionId: string; method: string }[] = []
+    host.profileRoutes = async () => [
+      { connectionId: 'gw-a', profile: 'default' },
+      { connectionId: 'gw-b', profile: 'default' },
+      { connectionId: 'gw-b', profile: 'other' }
+    ]
+
+    host.requestProfile = async (route: { connectionId: string }, method: string) => {
+      remote.push({ connectionId: route.connectionId, method })
+
+      if (method === 'profiles.list') {
+        return { profiles: [{ name: 'default', ui_meta: {}, ui_meta_revisions: {} }] }
+      }
+
+      if (method === 'profiles.configure') {
+        return { applied: { ui_meta: true, ui_meta_revisions: { 'hermes-bots-groups': 1 } } }
+      }
+
+      return {}
+    }
+
+    room.chat.$groupChats.set({
+      Shared: {
+        log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'w1', text: 'hi' }],
+        members: [{ name: 'research' }],
+        sessions: {},
+        syncRevision: 0,
+        watermarks: {}
+      }
+    } as unknown as Record<string, GroupChat>)
+
+    room.chat.scheduleGroupChatServerSync(room.chat.$groupChats.get(), { changedRooms: ['Shared'] })
+    await drain(() => remote.filter(entry => entry.method === 'profiles.configure').length < 2, 80)
+
+    const configured = new Set(
+      remote.filter(entry => entry.method === 'profiles.configure').map(entry => entry.connectionId)
+    )
+
+    expect(configured.has('gw-a')).toBe(true)
+    expect(configured.has('gw-b')).toBe(true)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-chat.ts b/apps/desktop/src/plugins/hermes-bots/group-chat.ts
new file mode 100644
index 000000000000..9949c57824b1
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-chat.ts
@@ -0,0 +1,1591 @@
+/**
+ * The group-chat room store: the room atoms, the durable record in plugin
+ * storage, the bounded cross-client projection that rides the default
+ * profile's ui_meta, and the small pure helpers every room surface shares
+ * (identity, thread ids, entry append, the #93127 decision predicates).
+ *
+ * The sync projection lives here rather than in its own module because
+ * updateGroupChat schedules it and the scheduler reads the same atom — one
+ * store, one writer.
+ */
+
+import { atom, host } from '@hermes/plugin-sdk'
+
+import { $botMeta, $lastRoster, botRosterKey } from './data'
+import { groupMemberReferencesConnection, markOrphanedGroupMemberDescriptor } from './hygiene'
+import { getPluginCtx } from './shared'
+import type {
+  Attachment,
+  GroupChat,
+  GroupHold,
+  GroupMember,
+  GroupMessage,
+  GroupMessageAuthor,
+  GroupPrompt,
+  RosterRow
+} from './types'
+
+/** Optional secondary navigation inside the Bots pane (group-chat rooms). */
+
+/** Group-chat rooms: { [group]: { log: [{from:{kind,name},text,at}], watermarks:{[member]:idx}, epoch, running } }.
+ *  Log + watermarks persist via plugin storage; epoch/running are runtime-only. */
+export const $groupChats = atom<Record<string, GroupChatRoom>>({})
+/** Group whose room view is open in the Bots pane (secondary navigation
+ *  inside the pane; a normal row click returns to the roster). */
+export const $groupChatWorkspace = atom<null | string>(null)
+/** Groups whose latest room activity mentions @user — the needs-you badge. */
+export const $groupNeedsYou = atom<Record<string, boolean>>({})
+// Pending prompts (clarify questions AND command approvals) raised inside
+// hidden group-member sessions, keyed `${group}::${memberKey}` (#90694).
+// Members run in invisible plumbing sessions, so a member's blocking prompt
+// used to park server-side with no surface to answer it — the user saw
+// "is thinking…" until the prompt timeout. The turn poll mirrors each
+// member's `pending_clarify` / `pending_approval` resume fields in here;
+// the room renders answer cards from it.
+export const $groupClarify = atom<Record<string, GroupPrompt>>({})
+
+const GROUP_CHAT_SYNC_META_KEY = 'hermes-bots-groups'
+// Gateway ui_meta is capped after Python JSON serialization. Keep a healthy
+// margin below that limit because Python escapes Unicode while JS does not.
+const GROUP_CHAT_SYNC_MAX_BYTES = 48000
+const GROUP_CHAT_SYNC_MESSAGES = 16
+const GROUP_CHAT_SYNC_TEXT_CHARS = 1200
+const GROUP_CHAT_SYNC_IMAGE_CHARS = 24000
+let groupChatSyncTimer: ReturnType<typeof setTimeout> | null = null
+
+/** One room inside the bounded ui_meta projection: a compacted log plus the
+ *  identity fields, without any of `GroupChat`'s runtime/orchestration state. */
+interface GroupChatSyncRoom {
+  image?: null | string
+  log: GroupMessage[]
+  members?: GroupMember[]
+  name?: string
+  revision?: number
+  roomId?: string
+}
+
+/** The v3 envelope stored under the default profile's `hermes-bots-groups`
+ *  ui_meta key. `deleted` maps a room key to its tombstone revision. */
+interface GroupChatSyncSnapshot {
+  deleted?: Record<string, number>
+  rooms: Record<string, GroupChatSyncRoom>
+  updatedAt?: number
+  version: number
+}
+
+/** A queued publish for one gateway, coalesced while the debounce runs. */
+interface GroupChatSyncJob {
+  allowEmpty?: boolean
+  changedRooms?: string[]
+  connectionId: string
+  deletedRooms?: string[]
+}
+// Fan-out scheduler state, keyed by gateway connectionId ('' = active/local).
+// Every connected gateway carries the full projection so a room survives any
+// single gateway being removed and surfaces on every remote backend.
+const groupChatSyncPendingByConnection = new Map<string, GroupChatSyncJob>()
+const groupChatSyncInFlightConnections = new Set<string>()
+const groupChatSyncRetryTimers = new Map<string, ReturnType<typeof setTimeout>>()
+const groupChatSyncRetryCounts = new Map<string, number>()
+export let groupChatSyncDisposed = false
+
+/** Conservative byte count for the gateway's ensure_ascii JSON encoding.
+ *  Python also inserts separator spaces, so reserve one extra byte per JS
+ *  structural separator on top of escaped Unicode code-point widths. */
+export function groupChatGatewayJsonSize(value: unknown) {
+  const json = JSON.stringify(value)
+  let bytes = 0
+
+  for (const character of json) {
+    // Non-null: string iteration yields whole code points, never an empty string.
+    const codePoint = character.codePointAt(0)!
+
+    if (codePoint <= 0x7f) {
+      bytes += 1
+
+      if (character === ',' || character === ':') {
+        bytes += 1
+      }
+    } else {
+      bytes += codePoint <= 0xffff ? 6 : 12
+    }
+  }
+
+  return bytes
+}
+
+/** Durable room identity for the sync projection. Rooms minted on current
+ *  builds carry an immutable roomId; the projection keys rooms by
+ *  `id:<roomId>` so rename is a display-name edit, not a distributed
+ *  delete+create, and disband tombstones follow the room itself. Legacy
+ *  rooms (no roomId) fall back to `name:<name>` keys with the older
+ *  revision-gated tombstone semantics. */
+export function groupChatRoomKey(name: string, room: GroupChat) {
+  return typeof room?.roomId === 'string' && room.roomId ? `id:${room.roomId}` : `name:${String(name)}`
+}
+
+/** Lift any historical projection shape (v1 wall-clock, v2 name-keyed) to
+ *  the v3 room-key shape so one merge path serves mixed-version fleets. */
+function normalizeGroupChatSyncSnapshot(snapshot: GroupChatSyncSnapshot | null | undefined): GroupChatSyncSnapshot {
+  if (!snapshot || typeof snapshot !== 'object') {
+    return {
+      version: 3,
+      rooms: {},
+      deleted: {}
+    }
+  }
+
+  if (Number(snapshot.version || 0) >= 3) {
+    return {
+      version: 3,
+      updatedAt: Number(snapshot.updatedAt || 0),
+      rooms: snapshot.rooms && typeof snapshot.rooms === 'object' ? snapshot.rooms : {},
+      deleted: snapshot.deleted && typeof snapshot.deleted === 'object' ? snapshot.deleted : {}
+    }
+  }
+
+  const rooms: Record<string, GroupChatSyncRoom> = {}
+
+  for (const [name, room] of Object.entries(snapshot.rooms || {})) {
+    if (!room || !Array.isArray(room.log)) {
+      continue
+    }
+
+    rooms[`name:${name}`] = {
+      ...room,
+      name
+    }
+  }
+
+  const deleted: Record<string, number> = {}
+
+  for (const [name, at] of Object.entries(snapshot.deleted || {})) {
+    // v1 tombstones carried wall-clock ms, not gateway revisions — they must
+    // not outrank real revisions.
+    deleted[`name:${name}`] = Number(snapshot.version || 0) >= 2 ? Math.max(0, Number(at || 0)) : 0
+  }
+
+  return {
+    version: 3,
+    updatedAt: Number(snapshot.updatedAt || 0),
+    rooms,
+    deleted
+  }
+}
+
+/** Compact, display-oriented copy of Desktop's room log for gateway clients.
+ *  The live orchestration state stays in plugin storage; this bounded mirror
+ *  rides the default profile's ui_meta so mobile can show the same messages.
+ *  Newest rooms/messages win when the profile metadata size cap is reached. */
+export function groupChatSyncSnapshot(
+  // `revision` is the pre-`syncRevision` field name, still read below as a
+  // fallback for rooms hydrated from an older plugin-storage record.
+  all: Record<string, GroupChat & { revision?: number }> = $groupChats.get(),
+  deleted: Record<string, number> = {}
+): GroupChatSyncSnapshot {
+  const ranked = Object.entries(all || {})
+    // Empty runtime tombstones are used to stop an in-flight room after
+    // disband. They are not real rooms and must never reappear on mobile.
+    .filter(([, room]) => room && Array.isArray(room.log) && room.log.length > 0)
+    .sort(([, left], [, right]) => {
+      const leftAt = Number(left.log[left.log.length - 1]?.at || 0)
+      const rightAt = Number(right.log[right.log.length - 1]?.at || 0)
+
+      return rightAt - leftAt
+    })
+
+  const rooms: Record<string, GroupChatSyncRoom> = {}
+
+  const boundedDeleted = Object.fromEntries(
+    Object.entries(deleted)
+      .sort(([, left], [, right]) => Number(right || 0) - Number(left || 0))
+      .slice(0, 64)
+  )
+
+  const envelope: GroupChatSyncSnapshot = {
+    version: 3,
+    updatedAt: Date.now(),
+    rooms,
+    ...(Object.keys(boundedDeleted).length
+      ? {
+          deleted: boundedDeleted
+        }
+      : {})
+  }
+
+  for (const [name, room] of ranked) {
+    const log: GroupMessage[] = room.log.slice(-GROUP_CHAT_SYNC_MESSAGES).map(entry => ({
+      ...(entry?.id
+        ? {
+            id: String(entry.id).slice(0, 160)
+          }
+        : {}),
+      from: {
+        kind: entry?.from?.kind === 'member' ? 'member' : 'user',
+        name: String(entry?.from?.name || (entry?.from?.kind === 'member' ? 'Bot' : 'You')).slice(0, 128),
+        ...(entry?.from?.source
+          ? {
+              source: String(entry.from.source).slice(0, 128)
+            }
+          : {})
+      },
+      text: String(entry?.text || '').slice(0, GROUP_CHAT_SYNC_TEXT_CHARS),
+      at: Number(entry?.at || 0),
+      ...(entry?.thread
+        ? {
+            thread: String(entry.thread).slice(0, 128)
+          }
+        : {})
+    }))
+
+    const compact: GroupChatSyncRoom = {
+      name: String(name).slice(0, 64),
+      ...(typeof room?.roomId === 'string' && room.roomId
+        ? {
+            roomId: String(room.roomId).slice(0, 128)
+          }
+        : {}),
+      log,
+      revision: Math.max(0, Number(room?.syncRevision ?? room?.revision ?? 0)),
+      members: (Array.isArray(room.members) ? room.members : []).slice(0, GROUP_CHAT_MAX_MEMBERS).map(member => ({
+        name: String(member?.name || '').slice(0, 128),
+        ...(member?.handle
+          ? {
+              handle: String(member.handle).slice(0, 128)
+            }
+          : {}),
+        ...(member?.connectionId
+          ? {
+              connectionId: String(member.connectionId).slice(0, 128)
+            }
+          : {}),
+        ...(member?.connectionKind
+          ? {
+              connectionKind: String(member.connectionKind).slice(0, 64)
+            }
+          : {}),
+        ...(member?.connectionLabel
+          ? {
+              connectionLabel: String(member.connectionLabel).slice(0, 128)
+            }
+          : {}),
+        ...(member?.sourceScoped
+          ? {
+              sourceScoped: true
+            }
+          : {})
+      })),
+      ...(typeof room?.image === 'string' && room.image.length <= GROUP_CHAT_SYNC_IMAGE_CHARS
+        ? {
+            image: room.image
+          }
+        : {})
+    }
+
+    const key = groupChatRoomKey(name, room)
+    rooms[key] = compact
+
+    while (compact.log.length > 1 && groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
+      compact.log.shift()
+    }
+
+    if (compact.image && groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
+      delete compact.image
+    }
+
+    if (groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
+      delete rooms[key]
+    }
+  }
+
+  return envelope
+}
+
+function groupChatSyncEntryKey(entry: GroupMessage) {
+  if (entry?.id) {
+    return `id:${String(entry.id)}`
+  }
+
+  return JSON.stringify([
+    Number(entry?.at || 0),
+    String(entry?.from?.kind || ''),
+    String(entry?.from?.name || ''),
+    String(entry?.from?.source || ''),
+    // Threadless entries (pre-thread rooms, older Desktop builds) get
+    // SYNTHETIC `legacy-N` ids from assignLegacyThreads. Those ids are
+    // position-derived — not stable across a gateway round-trip (the
+    // projection copy may be threadless or numbered differently). Collapse
+    // the whole synthetic family to one bucket, or the merge duplicates
+    // every id-less entry — shifting watermarks and manufacturing phantom
+    // member turns that re-submit into busy sessions.
+    String(entry?.thread || 'legacy').replace(/^legacy-\d+$/, 'legacy'),
+    String(entry?.text || '')
+  ])
+}
+
+/** Members dedupe on durable identity — the same (connectionId, name) pair
+ *  botRosterKey seats them by everywhere else. `connectionLabel` and `handle`
+ *  are display strings each machine re-derives (a connection rename, an older
+ *  build with no handle), so keying on them seats one bot twice; both copies
+ *  then answer to a single groupMemberKey in watermarks/sessions/stranded and
+ *  the round engine gives that bot two turns. Deliberately unconditional,
+ *  unlike groupMemberKey: the projection stamps `remoteSource` onto members it
+ *  merges in, so a scoped/unscoped branch would fork a member from its own
+ *  previously-merged copy. */
+function groupChatSyncMemberKey(member: GroupMember) {
+  return botRosterKey(member)
+}
+
+/** Merge two bounded projections without treating an absent room/message as
+ *  deletion. Rooms are identified by durable room keys (id:<roomId> when the
+ *  room carries one), so a rename is a same-key field update — never a
+ *  distributed delete+create — and a disband tombstone follows the room
+ *  itself. Gateway revisions order identity/membership/picture and
+ *  tombstones; stable message ids make concurrent log union idempotent.
+ *  `changedRooms`/`deletedRooms` accept display names or room keys. */
+export function mergeGroupChatSyncSnapshots(
+  remote: GroupChatSyncSnapshot | null | undefined,
+  local: GroupChatSyncSnapshot | null | undefined,
+  {
+    changedRooms = [],
+    deletedRooms = [],
+    writeRevision = 0
+  }: { changedRooms?: string[]; deletedRooms?: string[]; writeRevision?: number } = {}
+) {
+  const remoteNorm = normalizeGroupChatSyncSnapshot(remote)
+  const localNorm = normalizeGroupChatSyncSnapshot(local)
+
+  const keysFor = (label: string, norm: GroupChatSyncSnapshot) => {
+    const keys = new Set<string>()
+
+    for (const [key, room] of Object.entries(norm.rooms || {})) {
+      if (key === label || String(room?.name || '') === label || key === `name:${label}`) {
+        keys.add(key)
+      }
+    }
+
+    if (String(label).startsWith('id:') || String(label).startsWith('name:')) {
+      keys.add(label)
+    } else if (!keys.size) {
+      keys.add(`name:${label}`)
+    }
+
+    return keys
+  }
+
+  const changed = new Set<string>()
+
+  for (const label of changedRooms) {
+    for (const key of keysFor(label, localNorm)) {
+      changed.add(key)
+    }
+  }
+
+  const deleted: Record<string, number> = {}
+
+  for (const source of [remoteNorm, localNorm]) {
+    for (const [key, at] of Object.entries(source.deleted || {})) {
+      deleted[key] = Math.max(Number(deleted[key] || 0), Math.max(0, Number(at || 0)))
+    }
+  }
+
+  for (const label of deletedRooms) {
+    for (const key of new Set([...keysFor(label, remoteNorm), ...keysFor(label, localNorm)])) {
+      // Rename passes changedRooms:[newName] + deletedRooms:[oldName]. For an
+      // id-keyed room both labels resolve to the SAME durable key (the remote
+      // copy still carries the old display name), and id tombstones are
+      // final — so tombstoning here would kill the room being renamed. A key
+      // that is being written this cycle is a rename target, not a disband.
+      if (changed.has(key)) {
+        continue
+      }
+
+      deleted[key] = Math.max(Number(deleted[key] || 0), Number(writeRevision || 0))
+    }
+  }
+
+  const rooms: Record<string, GroupChatSyncRoom> = {}
+  const roomKeys = new Set([...Object.keys(remoteNorm.rooms || {}), ...Object.keys(localNorm.rooms || {})])
+
+  for (const key of roomKeys) {
+    const remoteRoom = remoteNorm.rooms?.[key]
+    const localRoom = localNorm.rooms?.[key]
+
+    if ((!remoteRoom || !Array.isArray(remoteRoom.log)) && (!localRoom || !Array.isArray(localRoom.log))) {
+      continue
+    }
+
+    const remoteRevision = Math.max(0, Number(remoteRoom?.revision || 0))
+
+    const localRevision = changed.has(key)
+      ? Math.max(0, Number(writeRevision || 0))
+      : Math.max(0, Number(localRoom?.revision || 0))
+
+    const entries = new Map<string, GroupMessage>()
+
+    for (const entry of [...(remoteRoom?.log || []), ...(localRoom?.log || [])]) {
+      entries.set(groupChatSyncEntryKey(entry), entry)
+    }
+
+    // Identity fields (display name, membership, picture) follow the higher
+    // revision; a tie unions members and prefers the local writer's fields.
+    let identity: GroupChatSyncRoom | undefined
+    let members: GroupMember[]
+    let image: null | string | undefined
+
+    if (localRevision > remoteRevision) {
+      identity = localRoom
+      members = [...(localRoom?.members || [])]
+      image = localRoom?.image
+    } else if (remoteRevision > localRevision) {
+      identity = remoteRoom
+      members = [...(remoteRoom?.members || [])]
+      image = remoteRoom?.image
+    } else {
+      identity = localRoom || remoteRoom
+      const byId = new Map<string, GroupMember>()
+
+      for (const member of [...(remoteRoom?.members || []), ...(localRoom?.members || [])]) {
+        byId.set(groupChatSyncMemberKey(member), member)
+      }
+
+      members = [...byId.values()]
+      image = Object.prototype.hasOwnProperty.call(localRoom || {}, 'image') ? localRoom.image : remoteRoom?.image
+    }
+
+    rooms[key] = {
+      ...(identity?.name
+        ? {
+            name: identity.name
+          }
+        : {}),
+      ...(identity?.roomId || (key.startsWith('id:') ? key.slice(3) : '')
+        ? {
+            roomId: identity?.roomId || key.slice(3)
+          }
+        : {}),
+      log: [...entries.values()].sort((left, right) => {
+        const byTime = Number(left?.at || 0) - Number(right?.at || 0)
+
+        return byTime || groupChatSyncEntryKey(left).localeCompare(groupChatSyncEntryKey(right))
+      }),
+      members,
+      revision: Math.max(remoteRevision, localRevision),
+      ...(typeof image === 'string' && image
+        ? {
+            image
+          }
+        : {})
+    }
+  }
+
+  for (const [key, deletedRevision] of Object.entries(deleted)) {
+    if (key.startsWith('id:')) {
+      // Tombstones for id-keyed rooms are FINAL: the roomId is minted once
+      // and never reused (same-name recreation mints a fresh id), so a
+      // resurrect-by-revision race is structurally impossible. Keep the
+      // tombstone even when a lagging gateway's copy carries a higher
+      // revision — that copy is the resurrection this exists to prevent.
+      delete rooms[key]
+    } else if (Number(deletedRevision || 0) >= Number(rooms[key]?.revision || 0)) {
+      delete rooms[key]
+    } else {
+      delete deleted[key]
+    }
+  }
+
+  return groupChatSyncEnvelope(rooms, deleted)
+}
+
+/** Assemble + size-bound a v3 envelope from already-compacted rooms. */
+function groupChatSyncEnvelope(
+  rooms: Record<string, GroupChatSyncRoom>,
+  deleted: Record<string, number> = {}
+): GroupChatSyncSnapshot {
+  const boundedDeleted = Object.fromEntries(
+    Object.entries(deleted)
+      .sort(([, left], [, right]) => Number(right || 0) - Number(left || 0))
+      .slice(0, 64)
+  )
+
+  const envelope: GroupChatSyncSnapshot = {
+    version: 3,
+    updatedAt: Date.now(),
+    rooms,
+    ...(Object.keys(boundedDeleted).length
+      ? {
+          deleted: boundedDeleted
+        }
+      : {})
+  }
+
+  const ranked = Object.entries(rooms).sort(([, left], [, right]) => {
+    const leftAt = Number(left?.log?.[left.log.length - 1]?.at || 0)
+    const rightAt = Number(right?.log?.[right.log.length - 1]?.at || 0)
+
+    return leftAt - rightAt
+  })
+
+  for (const [key, room] of ranked) {
+    while ((room.log?.length || 0) > 1 && groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
+      room.log.shift()
+    }
+
+    if (room.image && groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
+      delete room.image
+    }
+
+    if (groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
+      delete rooms[key]
+    }
+  }
+
+  return envelope
+}
+
+/** Merge the gateway's bounded display projection into Desktop's richer room
+ *  state without discarding local session/watermark/runtime fields. Missing
+ *  remote rooms/messages are not deletions; only explicit tombstones remove a
+ *  room, and a genuinely newer local message wins over a stale tombstone. */
+export function mergeRemoteGroupChatSnapshotIntoRooms(
+  remote: GroupChatSyncSnapshot | null | undefined,
+  current: Record<string, GroupChat> = $groupChats.get(),
+  { preserveRooms = [], deletedRooms = [] }: { deletedRooms?: string[]; preserveRooms?: string[] } = {}
+) {
+  const remoteNorm = normalizeGroupChatSyncSnapshot(remote)
+
+  const rooms: Record<string, GroupChat> = {
+    ...(current || {})
+  }
+
+  const preserved = new Set(preserveRooms)
+  const locallyDeleted = new Set(deletedRooms)
+
+  // Local rooms indexed by durable identity so an id-keyed projection room
+  // finds its local twin even when the display name changed remotely.
+  const localByRoomId = new Map<string, string>()
+
+  for (const [name, room] of Object.entries(rooms)) {
+    if (typeof room?.roomId === 'string' && room.roomId) {
+      localByRoomId.set(room.roomId, name)
+    }
+  }
+
+  for (const [key, projected] of Object.entries(remoteNorm.rooms || {})) {
+    if (!projected || !Array.isArray(projected.log)) {
+      continue
+    }
+
+    const projectedRoomId = projected.roomId || (key.startsWith('id:') ? key.slice(3) : null)
+
+    const localName =
+      projectedRoomId && localByRoomId.has(projectedRoomId)
+        ? localByRoomId.get(projectedRoomId)
+        : projected.name && rooms[projected.name]
+          ? projected.name
+          : null
+
+    const displayName = String(projected.name || localName || (key.startsWith('name:') ? key.slice(5) : key))
+
+    if (locallyDeleted.has(displayName) || (localName && locallyDeleted.has(localName))) {
+      // Mid-rename guard: the remote copy may still be under the OLD display
+      // name while the local record was already re-keyed (same roomId, new
+      // name). That old name sits in deletedRooms, but the local record is
+      // the rename in flight — deleting it here would kill the renamed room.
+      if (localName && localName !== displayName && !locallyDeleted.has(localName)) {
+        continue
+      }
+
+      delete rooms[displayName]
+
+      if (localName) {
+        delete rooms[localName]
+      }
+
+      continue
+    }
+
+    const existing = (localName ? rooms[localName] : rooms[displayName]) || {}
+    const remoteRevision = Math.max(0, Number(projected.revision || 0))
+    const localRevision = Math.max(0, Number(existing.syncRevision || 0))
+
+    const entries = new Map<string, GroupMessage>(
+      (Array.isArray(existing.log) ? existing.log : []).map(entry => [groupChatSyncEntryKey(entry), entry])
+    )
+
+    const members = new Map<string, GroupMember>(
+      (Array.isArray(existing.members) ? existing.members : []).map(member => [groupChatSyncMemberKey(member), member])
+    )
+
+    for (const entry of projected.log) {
+      const entryKey = groupChatSyncEntryKey(entry)
+
+      // The projection is COMPACT (truncated text, no images). When the same
+      // entry exists locally, the local rich copy is authoritative — merging
+      // the compact twin over it would strip attachments and retrigger
+      // watermark deltas for members that already saw it (phantom rounds).
+      if (!entries.has(entryKey)) {
+        entries.set(entryKey, entry)
+      }
+    }
+
+    const isPreserved = preserved.has(displayName) || (localName && preserved.has(localName))
+
+    if (!isPreserved) {
+      if (remoteRevision > localRevision) {
+        members.clear()
+      }
+
+      for (const member of Array.isArray(projected.members) ? projected.members : []) {
+        members.set(groupChatSyncMemberKey(member), {
+          ...member,
+          remoteSource: true
+        })
+      }
+    }
+
+    const log = assignLegacyThreads(
+      [...entries.values()].sort((left, right) => {
+        const byTime = Number(left?.at || 0) - Number(right?.at || 0)
+
+        return byTime || groupChatSyncEntryKey(left).localeCompare(groupChatSyncEntryKey(right))
+      })
+    )
+
+    const bounded = trimGroupChatLog(log, existing.watermarks || {})
+
+    // A remote rename with a higher revision moves the local record to the
+    // new display name; local views keyed by the old name follow on the
+    // next repaint (roster derives from $groupChats keys).
+    const targetName = !isPreserved && remoteRevision > localRevision ? displayName : localName || displayName
+
+    if (localName && targetName !== localName) {
+      delete rooms[localName]
+    }
+
+    rooms[targetName] = {
+      ...existing,
+      log: bounded.log,
+      watermarks: bounded.watermarks,
+      sessions: existing.sessions && typeof existing.sessions === 'object' ? existing.sessions : {},
+      stranded: existing.stranded && typeof existing.stranded === 'object' ? existing.stranded : {},
+      members: [...members.values()],
+      ...(projectedRoomId || existing.roomId
+        ? {
+            roomId: existing.roomId || projectedRoomId
+          }
+        : {}),
+      image: isPreserved
+        ? existing.image || null
+        : remoteRevision >= localRevision && Object.prototype.hasOwnProperty.call(projected, 'image')
+          ? projected.image || null
+          : existing.image || null,
+      syncRevision: isPreserved ? localRevision : Math.max(remoteRevision, localRevision),
+      epoch: Number(existing.epoch || 0),
+      running: Boolean(existing.running)
+    }
+  }
+
+  for (const [key, deletedAt] of Object.entries(remoteNorm.deleted || {})) {
+    const deletedRoomId = key.startsWith('id:') ? key.slice(3) : null
+
+    const targetName =
+      deletedRoomId && localByRoomId.has(deletedRoomId)
+        ? localByRoomId.get(deletedRoomId)
+        : key.startsWith('name:')
+          ? key.slice(5)
+          : null
+
+    if (!targetName || preserved.has(targetName)) {
+      continue
+    }
+
+    if (deletedRoomId) {
+      // Id tombstones are final — the id is never reused, so there is no
+      // legitimate higher-revision recreation to protect.
+      delete rooms[targetName]
+    } else {
+      const deletedRevision = Math.max(0, Number(deletedAt || 0))
+
+      if (deletedRevision >= Number(rooms[targetName]?.syncRevision || 0)) {
+        delete rooms[targetName]
+      }
+    }
+  }
+
+  for (const name of locallyDeleted) {
+    delete rooms[name]
+  }
+
+  return rooms
+}
+
+export function durableGroupChatRooms(all: Record<string, GroupChat> = $groupChats.get()) {
+  const durable: Record<string, GroupChat> = {}
+
+  for (const [name, room] of Object.entries(all || {})) {
+    if (!room || !Array.isArray(room.log)) {
+      continue
+    }
+
+    // Disband tombstones are runtime-only coordination state (they hold the
+    // epoch bump for an in-flight drive). Persisting one would resurrect the
+    // room as an empty record on the next load AND keep its name "taken" for
+    // same-name recreates. Mirrors updateGroupChat's inline durable map.
+    if (room.tombstone) {
+      continue
+    }
+
+    durable[name] = {
+      log: room.log,
+      watermarks: room.watermarks || {},
+      sessions: room.sessions || {},
+      stranded: room.stranded || {},
+      members: Array.isArray(room.members) ? room.members : [],
+      // Immutable room identity: without this, a room merged in via the
+      // remote-sync path (the only caller of this function) loses its
+      // roomId on the next cold hydrate and falls back to legacy
+      // name-keyed identity — same field updateGroupChat's inline map
+      // already carries.
+      roomId: typeof room.roomId === 'string' && room.roomId ? room.roomId : null,
+      image: room.image || null,
+      syncRevision: Math.max(0, Number(room.syncRevision || 0))
+    }
+  }
+
+  return durable
+}
+
+export function persistGroupChatRooms(all: Record<string, GroupChat> = $groupChats.get()) {
+  try {
+    return Promise.resolve(getPluginCtx()?.storage?.set?.('group-chats', durableGroupChatRooms(all))).catch(
+      () => undefined
+    )
+  } catch {
+    return Promise.resolve()
+  }
+}
+
+/** Register-removed sweep: annotate (not delete) every persisted group-chat
+ *  member owned by the deleted connection, in the atom AND plugin storage.
+ *  Writes ride updateGroupChat so the durable record keeps its full shape
+ *  (sessionOwners, holds — durableGroupChatRooms would drop them).
+ *  Returns whether anything changed. */
+export function sweepGroupChatMembersForRemovedConnection(connectionId: string) {
+  const id = String(connectionId || '').trim()
+
+  if (!id) {
+    return false
+  }
+
+  let changed = false
+
+  for (const [name, room] of Object.entries($groupChats.get())) {
+    const members = Array.isArray(room?.members) ? room.members : []
+
+    if (!members.some(member => groupMemberReferencesConnection(member, id) && !member?.sourceMissing)) {
+      continue
+    }
+
+    changed = true
+    updateGroupChat(name, (current: GroupChat) => ({
+      ...current,
+      members: (Array.isArray(current.members) ? current.members : []).map(member =>
+        groupMemberReferencesConnection(member, id) ? markOrphanedGroupMemberDescriptor(member) : member
+      )
+    }))
+  }
+
+  return changed
+}
+
+function groupChatSyncConnectionId() {
+  return String(host.state.connectionId?.get?.() || host.activeConnectionId?.() || '')
+}
+
+/** Route a sync job back to the gateway that was active when it was queued.
+ *  A foreground switch during debounce must not write the old snapshot into
+ *  the newly active gateway. */
+async function groupChatSyncRequest<T>(
+  job: GroupChatSyncJob,
+  method: string,
+  params: Record<string, unknown>
+): Promise<T> {
+  if (job.connectionId && typeof host.profileRoutes === 'function' && typeof host.requestProfile === 'function') {
+    const routes = await host.profileRoutes()
+
+    const route = (Array.isArray(routes) ? routes : []).find(candidate => {
+      const profile = String(candidate?.targetProfile || candidate?.profile || '')
+
+      return String(candidate?.connectionId || '') === job.connectionId && profile === 'default'
+    })
+
+    if (route) {
+      return host.requestProfile(route, method, params)
+    }
+  }
+
+  const currentConnectionId = groupChatSyncConnectionId()
+
+  if (job.connectionId && currentConnectionId && job.connectionId !== currentConnectionId) {
+    throw new Error('Group chat gateway changed before sync')
+  }
+
+  return host.request(method, params)
+}
+
+async function groupChatRemoteSnapshot(job: GroupChatSyncJob) {
+  const result = await groupChatSyncRequest<{ profiles?: RosterRow[] }>(job, 'profiles.list', {
+    include_sessions: false
+  })
+
+  const profile = (Array.isArray(result?.profiles) ? result.profiles : []).find(row => row?.name === 'default')
+  const snapshot = profile?.ui_meta?.[GROUP_CHAT_SYNC_META_KEY] as GroupChatSyncSnapshot | undefined
+  const supportsCas = Boolean(profile && Object.prototype.hasOwnProperty.call(profile, 'ui_meta_revisions'))
+
+  return {
+    snapshot: snapshot && typeof snapshot === 'object' && !Array.isArray(snapshot) ? snapshot : null,
+    revision: Math.max(0, Number(profile?.ui_meta_revisions?.[GROUP_CHAT_SYNC_META_KEY] || 0)),
+    supportsCas
+  }
+}
+
+/** Pull the shared room projection into this Desktop before it publishes any
+ *  local state. This is the receive half of the client-only sync contract. */
+export async function pullGroupChatServerState(connectionId: string = groupChatSyncConnectionId()) {
+  const { snapshot: remote } = await groupChatRemoteSnapshot({
+    connectionId
+  })
+
+  if (!remote) {
+    return false
+  }
+
+  const pending = groupChatSyncPendingByConnection.get(String(connectionId || ''))
+
+  const merged = mergeRemoteGroupChatSnapshotIntoRooms(remote, $groupChats.get(), {
+    preserveRooms: pending?.changedRooms || [],
+    deletedRooms: pending?.deletedRooms || []
+  })
+
+  $groupChats.set(merged)
+  await persistGroupChatRooms(merged)
+
+  return true
+}
+
+function groupChatSyncBackoff(connectionId: string) {
+  const count = Number(groupChatSyncRetryCounts.get(connectionId) || 0)
+
+  return Math.min(30000, 1000 * 2 ** Math.min(count, 5))
+}
+
+function mergeGroupChatSyncJobs(existing: GroupChatSyncJob | undefined, incoming: GroupChatSyncJob): GroupChatSyncJob {
+  if (!existing || existing.connectionId !== incoming.connectionId) {
+    return incoming
+  }
+
+  return {
+    connectionId: incoming.connectionId,
+    allowEmpty: Boolean(existing.allowEmpty || incoming.allowEmpty),
+    changedRooms: [...new Set([...(existing.changedRooms || []), ...(incoming.changedRooms || [])])],
+    deletedRooms: [...new Set([...(existing.deletedRooms || []), ...(incoming.deletedRooms || [])])]
+  }
+}
+
+function groupChatSyncPayloadEqual(
+  left: GroupChatSyncSnapshot | null | undefined,
+  right: GroupChatSyncSnapshot | null | undefined
+) {
+  return (
+    JSON.stringify(left?.rooms || {}) === JSON.stringify(right?.rooms || {}) &&
+    JSON.stringify(left?.deleted || {}) === JSON.stringify(right?.deleted || {})
+  )
+}
+
+/** Every default-profile gateway route this Desktop can currently reach.
+ *  The projection fans out to ALL of them, so any single gateway can die or
+ *  be removed without losing the shared room state, and gateway-only
+ *  clients (Hermes Go, headless backends) see rooms regardless of which
+ *  gateway a Desktop was foregrounding when the room was used. */
+async function groupChatSyncTargetConnections() {
+  const targets = new Set<string>()
+  const active = groupChatSyncConnectionId()
+  targets.add(String(active || ''))
+
+  if (typeof host.profileRoutes === 'function' && typeof host.requestProfile === 'function') {
+    try {
+      const routes = await host.profileRoutes()
+
+      for (const route of Array.isArray(routes) ? routes : []) {
+        const profile = String(route?.targetProfile || route?.profile || '')
+        const connectionId = String(route?.connectionId || '')
+
+        if (profile === 'default' && connectionId) {
+          targets.add(connectionId)
+        }
+      }
+    } catch {
+      // Route inventory unavailable — the active gateway alone still syncs.
+    }
+  }
+
+  return [...targets]
+}
+
+async function flushGroupChatServerSync(connectionId?: string) {
+  if (connectionId === undefined) {
+    // Drain every connection with pending work.
+    for (const pendingId of [...groupChatSyncPendingByConnection.keys()]) {
+      void flushGroupChatServerSync(pendingId)
+    }
+
+    return
+  }
+
+  const id = String(connectionId || '')
+
+  if (groupChatSyncDisposed || groupChatSyncInFlightConnections.has(id) || !groupChatSyncPendingByConnection.has(id)) {
+    return
+  }
+
+  // Non-null: the `has(id)` guard directly above is the entry condition.
+  const job = groupChatSyncPendingByConnection.get(id)!
+  groupChatSyncPendingByConnection.delete(id)
+  groupChatSyncInFlightConnections.add(id)
+
+  try {
+    const remoteState = await groupChatRemoteSnapshot(job)
+    const local = groupChatSyncSnapshot($groupChats.get())
+    const writeRevision = remoteState.revision + 1
+
+    const snapshot = mergeGroupChatSyncSnapshots(remoteState.snapshot, local, {
+      changedRooms: job.changedRooms,
+      deletedRooms: job.deletedRooms,
+      writeRevision
+    })
+
+    // Reconnect/startup reconciliation often discovers that the gateway
+    // already holds the exact merged projection. Avoid advancing a revision
+    // merely because a view reopened.
+    if (
+      !(job.changedRooms || []).length &&
+      !(job.deletedRooms || []).length &&
+      groupChatSyncPayloadEqual(snapshot, remoteState.snapshot)
+    ) {
+      if (remoteState.snapshot) {
+        const pending = groupChatSyncPendingByConnection.get(id)
+
+        const mergedRooms = mergeRemoteGroupChatSnapshotIntoRooms(remoteState.snapshot, $groupChats.get(), {
+          preserveRooms: pending?.changedRooms || [],
+          deletedRooms: pending?.deletedRooms || []
+        })
+
+        $groupChats.set(mergedRooms)
+        await persistGroupChatRooms(mergedRooms)
+      }
+
+      groupChatSyncRetryCounts.delete(id)
+
+      return
+    }
+
+    const configureParams: {
+      name: string
+      ui_meta: Record<string, GroupChatSyncSnapshot>
+      ui_meta_expected_revisions?: Record<string, number>
+    } = {
+      name: 'default',
+      ui_meta: {
+        [GROUP_CHAT_SYNC_META_KEY]: snapshot
+      }
+    }
+
+    if (remoteState.supportsCas) {
+      configureParams.ui_meta_expected_revisions = {
+        [GROUP_CHAT_SYNC_META_KEY]: remoteState.revision
+      }
+    }
+
+    const result = await groupChatSyncRequest<{
+      applied?: { ui_meta?: boolean; ui_meta_revisions?: Record<string, number> }
+    }>(job, 'profiles.configure', configureParams)
+
+    if (result?.applied?.ui_meta !== true) {
+      throw new Error('Gateway rejected group chat ui_meta')
+    }
+
+    if (
+      remoteState.supportsCas &&
+      Number(result?.applied?.ui_meta_revisions?.[GROUP_CHAT_SYNC_META_KEY] || 0) !== writeRevision
+    ) {
+      throw new Error('Gateway did not advance group chat ui_meta revision')
+    }
+
+    const confirmedState = await groupChatRemoteSnapshot(job)
+
+    if (remoteState.supportsCas && confirmedState.revision < writeRevision) {
+      throw new Error('Group chat ui_meta revision missing after read-back')
+    }
+
+    if (confirmedState.snapshot) {
+      const pending = groupChatSyncPendingByConnection.get(id)
+
+      const mergedRooms = mergeRemoteGroupChatSnapshotIntoRooms(confirmedState.snapshot, $groupChats.get(), {
+        preserveRooms: pending?.changedRooms || [],
+        deletedRooms: pending?.deletedRooms || []
+      })
+
+      $groupChats.set(mergedRooms)
+      await persistGroupChatRooms(mergedRooms)
+    }
+
+    groupChatSyncRetryCounts.delete(id)
+  } catch {
+    if (!groupChatSyncDisposed) {
+      const retries = Number(groupChatSyncRetryCounts.get(id) || 0) + 1
+
+      // A gateway that was REMOVED (not just flaky) has no route anymore and
+      // would otherwise retry forever. Give up after the backoff ladder tops
+      // out; local storage remains authoritative and a future reconnect of
+      // that gateway re-seeds it via the gateway-transition pull/publish.
+      if (retries > 8) {
+        groupChatSyncRetryCounts.delete(id)
+
+        return
+      }
+
+      groupChatSyncPendingByConnection.set(id, mergeGroupChatSyncJobs(groupChatSyncPendingByConnection.get(id), job))
+      groupChatSyncRetryCounts.set(id, retries)
+
+      if (typeof setTimeout === 'function' && !groupChatSyncRetryTimers.has(id)) {
+        groupChatSyncRetryTimers.set(
+          id,
+          setTimeout(() => {
+            groupChatSyncRetryTimers.delete(id)
+            void flushGroupChatServerSync(id)
+          }, groupChatSyncBackoff(id))
+        )
+      }
+    }
+  } finally {
+    groupChatSyncInFlightConnections.delete(id)
+
+    if (groupChatSyncPendingByConnection.has(id) && !groupChatSyncRetryTimers.has(id) && !groupChatSyncDisposed) {
+      void flushGroupChatServerSync(id)
+    }
+  }
+}
+
+export function stopGroupChatServerSync() {
+  groupChatSyncDisposed = true
+  groupChatSyncPendingByConnection.clear()
+
+  if (groupChatSyncTimer !== null) {
+    clearTimeout(groupChatSyncTimer)
+    groupChatSyncTimer = null
+  }
+
+  for (const timer of groupChatSyncRetryTimers.values()) {
+    clearTimeout(timer)
+  }
+
+  groupChatSyncRetryTimers.clear()
+  groupChatSyncRetryCounts.clear()
+}
+
+/** Debounced, pull-merge-write server mirror, fanned out to every reachable
+ *  default-profile gateway. Local storage keeps the complete orchestration
+ *  log; ui_meta is a bounded cross-client projection per gateway, each with
+ *  its own CAS revision stream. */
+export function scheduleGroupChatServerSync(
+  all: Record<string, GroupChat> = $groupChats.get(),
+  {
+    allowEmpty = false,
+    changedRooms = [],
+    deletedRooms = []
+  }: { allowEmpty?: boolean; changedRooms?: string[]; deletedRooms?: string[] } = {}
+) {
+  // Browser shells provide timers; source-level VM tests and older embedded
+  // hosts may not. Room persistence must never break the surrounding gateway
+  // lifecycle when the optional mirror cannot be scheduled.
+  if (typeof setTimeout !== 'function') {
+    return
+  }
+
+  const snapshot = groupChatSyncSnapshot(all)
+
+  // A newly installed Desktop has no local room cache. Publishing that empty
+  // state on hydrate/reconnect would erase a valid mirror produced elsewhere.
+  // Only an explicit final-room disband is allowed to clear the projection.
+  if (Object.keys(snapshot.rooms).length === 0 && !allowEmpty) {
+    return
+  }
+
+  if (groupChatSyncTimer !== null) {
+    clearTimeout(groupChatSyncTimer)
+  }
+
+  // Queue on the ACTIVE gateway synchronously (tests and older hosts have no
+  // async route inventory), then widen to every reachable gateway before the
+  // debounce fires.
+  const activeId = String(groupChatSyncConnectionId() || '')
+
+  const queueFor = (connectionId: string) => {
+    const id = String(connectionId || '')
+    const retryTimer = groupChatSyncRetryTimers.get(id)
+
+    if (retryTimer !== undefined) {
+      clearTimeout(retryTimer)
+      groupChatSyncRetryTimers.delete(id)
+    }
+
+    groupChatSyncPendingByConnection.set(
+      id,
+      mergeGroupChatSyncJobs(groupChatSyncPendingByConnection.get(id), {
+        connectionId: id,
+        allowEmpty,
+        changedRooms,
+        deletedRooms
+      })
+    )
+  }
+
+  queueFor(activeId)
+  groupChatSyncTimer = setTimeout(() => {
+    groupChatSyncTimer = null
+    void groupChatSyncTargetConnections()
+      .then(targets => {
+        for (const target of targets) {
+          if (String(target || '') !== activeId) {
+            queueFor(target)
+          }
+        }
+      })
+      .catch(() => undefined)
+      .then(() => flushGroupChatServerSync())
+  }, 350)
+}
+
+export function handleSessionsGatewayTransition() {
+  // A gateway swap invalidates any in-flight room drive: bump every room's
+  // epoch so running loops bail at their next member boundary.
+  const rooms = {
+    ...$groupChats.get()
+  }
+
+  for (const name of Object.keys(rooms)) {
+    rooms[name] = {
+      ...rooms[name],
+      epoch: (rooms[name].epoch || 0) + 1,
+      running: false
+    }
+  }
+
+  $groupChats.set(rooms)
+  // Pull before re-publishing so a reconnect or source swap never lets this
+  // client's stale cache hide a room written by another Desktop/mobile client.
+  void pullGroupChatServerState()
+    .catch(() => false)
+    .then(() => scheduleGroupChatServerSync($groupChats.get()))
+}
+
+/** Re-arm the mirror after a dispose. `register()` owns this door: an
+ *  imported binding cannot be assigned, so the flag's reset crosses the
+ *  module edge as an accessor (same pattern as shared.ts's plugin context). */
+export function setGroupChatSyncDisposed(disposed: boolean) {
+  groupChatSyncDisposed = disposed
+}
+
+// ── one room's budget ────────────────────────────────────────────────────────
+// Every ceiling a single user send can spend, in one block on purpose: making
+// them configurable (per room, or model-aware from config.yaml) is live
+// contributor work — #92213 (per-room limits) and #96842 (config + token
+// budget) — and both need exactly one seam to hook. Carried over at the same
+// values the old plugin.js shipped so neither rebase inherits a behavior
+// change on top of a rewrite; deciding the shape of the override belongs to
+// those PRs, not to a design-system pass.
+export const GROUP_CHAT_MAX_ROUNDS = 3
+
+// #94478 review: continuation rounds are bounded independently of the message cap so a pathological mention chain can't consume the room's whole budget on handoffs.
+export const GROUP_CHAT_MAX_MESSAGES = 10
+export const GROUP_CHAT_MAX_CONTINUATIONS = 2
+export const GROUP_CHAT_HISTORY_LIMIT = 24
+export const GROUP_CHAT_MAX_MEMBERS = 6
+
+/** Transcript form of a room speaker's profile name. Friendly identity wins:
+ *  a Bot Mode title or a core profile display_name (e.g. default renamed to
+ *  "Lucy") labels the speaker everywhere this helper feeds — the "X is
+ *  thinking…" working line, the activity feed, and transcript lines — so a
+ *  renamed bot never shows up as its raw profile id or a stale "Hermes"
+ *  (community report, Aug 21 2026: renamed default still read "Hermes is
+ *  thinking…" in group rooms). The untitled primary profile is literally
+ *  named "default" — render it as Hermes (matching displayName and the
+ *  @hermes handle) so the main agent never loses its name in rooms. */
+export function groupSpeakerLabel(name?: null | string) {
+  const trimmed = (name || '').trim()
+
+  if (!trimmed) {
+    return trimmed
+  }
+
+  // Bot Mode title (edit dialog) — same first rung as displayName().
+  const title = String($botMeta.get()?.[trimmed]?.title || '').trim()
+
+  if (title) {
+    return title
+  }
+
+  // Core profile display_name (`hermes profile rename …` / dashboard) from
+  // the ACTIVE gateway's roster row. Source-scoped remote speakers carry
+  // their device suffix separately and keep their raw name here.
+  const roster = $lastRoster.get()
+
+  const row = Array.isArray(roster)
+    ? roster.find(bot => bot?.name === trimmed && !bot?.remoteSource && !bot?.sourceScoped)
+    : null
+
+  const renamed = typeof row?.display_name === 'string' ? row.display_name.trim() : ''
+
+  if (renamed) {
+    return renamed
+  }
+
+  return trimmed.toLowerCase() === 'default' ? 'Hermes' : trimmed
+}
+
+/** Trim a room log + its watermarks to the retained window, keeping
+ *  watermark indices consistent with the trimmed array. */
+export function trimGroupChatLog(
+  log: GroupMessage[],
+  watermarks: Record<string, number>,
+  limit = GROUP_CHAT_HISTORY_LIMIT * 4
+) {
+  if (log.length <= limit) {
+    return {
+      log,
+      watermarks
+    }
+  }
+
+  const drop = log.length - limit
+  const trimmed: Record<string, number> = {}
+
+  for (const [name, index] of Object.entries(watermarks || {})) {
+    trimmed[name] = Math.max(0, index - drop)
+  }
+
+  return {
+    log: log.slice(drop),
+    watermarks: trimmed
+  }
+}
+
+interface UpdateGroupChatOptions {
+  sync?: boolean
+}
+
+/** Mutate one group's room state through the atom + persist the durable part. */
+export function updateGroupChat(
+  group: string,
+  mutate: (room: GroupChat) => GroupChat,
+  { sync = true }: UpdateGroupChatOptions = {}
+) {
+  const all = {
+    ...$groupChats.get()
+  }
+
+  const current = all[group] || {
+    log: [],
+    watermarks: {},
+    epoch: 0,
+    running: false
+  }
+
+  const next = mutate({
+    ...current,
+    log: [...current.log],
+    watermarks: {
+      ...current.watermarks
+    }
+  })
+
+  const bounded = trimGroupChatLog(next.log, next.watermarks)
+  next.log = bounded.log
+  next.watermarks = bounded.watermarks
+  all[group] = next
+  $groupChats.set(all)
+
+  try {
+    const durable: Record<string, GroupChat> = {}
+
+    for (const [name, room] of Object.entries(all)) {
+      // Disband tombstones are runtime-only coordination state (they hold the
+      // epoch bump for an in-flight drive). Persisting one would resurrect
+      // the room as an empty record on the next load AND keep its name
+      // "taken" for same-name recreates.
+      if (room.tombstone) {
+        continue
+      }
+
+      durable[name] = {
+        log: room.log,
+        watermarks: room.watermarks,
+        sessions: room.sessions || {},
+        sessionOwners: room.sessionOwners || {},
+        // Timed-out turns awaiting a late reply — keyed by member, valued
+        // with the pre-turn message baseline. Survives reloads so finished
+        // work is still harvested after a window restart.
+        stranded: room.stranded || {},
+        // #93129: sticky per-member stop holds. Watermarks persist, so holds
+        // must too — otherwise a window restart silently releases a bot the
+        // user explicitly stopped.
+        holds: room.holds || {},
+        // Source-qualified member descriptors keep the room whole when the
+        // active connection changes and today's local members become remote.
+        members: Array.isArray(room.members) ? room.members : [],
+        // Immutable room identity: the member-session title for new rooms.
+        roomId: typeof room.roomId === 'string' && room.roomId ? room.roomId : null,
+        // Room picture (small data URL, same normalization as bot avatars).
+        image: room.image || null,
+        syncRevision: Math.max(0, Number(room.syncRevision || 0))
+      }
+    }
+
+    Promise.resolve(getPluginCtx()?.storage?.set?.('group-chats', durable)).catch(() => undefined)
+  } catch {
+    /* storage unavailable — room survives for this window only */
+  }
+
+  if (sync) {
+    scheduleGroupChatServerSync(all, {
+      changedRooms: [group]
+    })
+  }
+
+  return next
+}
+
+/** A #93129 member hold as this file mints it. `GroupHold` models only the
+ *  two fields that survive a reload; the live stamp also records WHICH user
+ *  message, in which thread, put the member on hold. */
+export interface GroupHoldStamp extends GroupHold {
+  byMessageId?: null | string
+  thread?: null | string
+}
+
+/** The room record as the coordination engine handles it: `GroupChat` plus
+ *  `turn`, the runtime-only name of the member currently mid-turn. Like
+ *  `running`/`epoch` it never persists, so it has no place in the durable
+ *  shape. Holds carry the fuller live stamp. */
+export interface GroupChatRoom extends GroupChat {
+  holds?: Record<string, GroupHoldStamp>
+  turn?: null | string
+}
+
+/** Set or clear a group chat's room picture (small data URL, normalized by
+ *  the same pipeline as bot avatars). Persists with the room record. */
+export function setGroupChatImage(group: string, image: null | string | undefined) {
+  updateGroupChat(group, (room: GroupChatRoom) => {
+    room.image = image || null
+
+    return room
+  })
+}
+
+function groupChatEntryId(): string {
+  if (globalThis.crypto && typeof globalThis.crypto.randomUUID === 'function') {
+    return globalThis.crypto.randomUUID()
+  }
+
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`
+}
+
+/** The agent loop's "(empty)" terminal sentinel (empty_response_exhausted) is
+ *  a FAILURE marker, never bot text. Mirror gateway/run.py's user-friendly
+ *  substitution so the room log never shows the raw sentinel. */
+const GROUP_EMPTY_SENTINEL = '(empty)'
+
+const GROUP_EMPTY_FRIENDLY =
+  '⚠️ The model returned no response after processing tool results. ' +
+  'This can happen with some models — try again or rephrase your question.'
+
+function normalizeGroupChatText(text: string): string {
+  const trimmed = String(text || '').trim()
+
+  return trimmed === GROUP_EMPTY_SENTINEL ? GROUP_EMPTY_FRIENDLY : trimmed
+}
+
+export function appendGroupChatEntry(
+  group: string,
+  from: GroupMessageAuthor,
+  text: string,
+  thread?: null | string,
+  images?: Attachment[]
+): GroupMessage {
+  const entry: GroupMessage = {
+    id: groupChatEntryId(),
+    at: Date.now(),
+    from,
+    text: normalizeGroupChatText(text),
+    thread: thread || 'legacy'
+  }
+
+  if (Array.isArray(images) && images.length) {
+    // [{ name, data }] — data URLs. Persisted with the room log so reloads
+    // keep showing what the members were shown.
+    entry.images = images
+  }
+
+  // #93127 insurance: a residual double-append path (stale loop + fresh
+  // loop both committing the same member reply) lands back-to-back and
+  // byte-identical. Drop the echo instead of flooding the room. User
+  // entries and non-adjacent repeats are never touched.
+  const priorLog = ($groupChats.get()[group] || {}).log || []
+  const lastEntry = priorLog[priorLog.length - 1]
+
+  if (isDuplicateGroupAppend(lastEntry, from, entry.text, entry.thread)) {
+    return lastEntry
+  }
+
+  updateGroupChat(group, (room: GroupChatRoom) => {
+    room.log.push(entry)
+
+    return room
+  })
+
+  // Needs-you: a member addressing @user badges the group header.
+  if (from.kind === 'member' && /@user\b/i.test(entry.text)) {
+    $groupNeedsYou.set({
+      ...$groupNeedsYou.get(),
+      [group]: true
+    })
+  }
+
+  return entry
+}
+
+/** Fresh room identity for a group. Independent of the editable display
+ *  name: a disbanded-and-recreated group mints a new roomId even when the
+ *  display name is identical, so member sessions never resume by title. */
+export function mintGroupRoomId(): string {
+  return `r${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`
+}
+
+/** Unique display name for a NEW group. Collisions get a " 2", " 3", …
+ *  suffix; the BASE is truncated (never the joined string), so a 64-char
+ *  base keeps its suffix instead of colliding with the original. */
+export function uniqueGroupChatName(base: string, taken: Set<string>): string {
+  if (!taken.has(base)) {
+    return base
+  }
+
+  for (let n = 2; n < 100; n++) {
+    const suffix = ` ${n}`
+    const candidate = base.slice(0, 64 - suffix.length) + suffix
+
+    if (!taken.has(candidate)) {
+      return candidate
+    }
+  }
+
+  throw new Error('No free name for the group.')
+}
+
+// --- room-turn decision helpers (#93127) — pure, unit-tested ---
+
+/** #93127: whether a finished member turn may still commit (append its reply
+ *  and advance its watermark). A turn dispatched under an older epoch was
+ *  superseded mid-flight by a newer user send — its late result must be
+ *  dropped, because the new send's own loop re-drives this member with the
+ *  full delta and committing both is exactly the double-delivery bug.
+ *
+ *  The re-drive premise is only true for a send in the SAME thread (delta
+ *  filters are thread-scoped): a cross-thread epoch bump must NOT discard
+ *  finished work no fresh loop will regenerate. Callers pass whether a newer
+ *  USER entry landed in this thread since dispatch; the default (true)
+ *  preserves the conservative drop when the caller can't tell. */
+export function shouldCommitMemberTurn(epochAtDispatch: number, currentEpoch: number, newerUserEntryInThread = true) {
+  if (epochAtDispatch === currentEpoch) {
+    return true
+  }
+
+  return !newerUserEntryInThread
+}
+
+/** #93127 insurance: byte-identical member echo detection. TRUE only when
+ *  the immediately-preceding log entry has the same author (kind + name +
+ *  source), same thread, and identical text, within a short recency window —
+ *  a residual double-append fires back-to-back; two legitimately identical
+ *  replies hours apart (or with anything in between) are never dropped. */
+const GROUP_DUPLICATE_APPEND_WINDOW_MS = 10 * 60 * 1000
+
+function isDuplicateGroupAppend(
+  lastEntry: GroupMessage | undefined,
+  from: GroupMessageAuthor,
+  text: string,
+  thread: null | string | undefined,
+  now = Date.now()
+): boolean {
+  if (!lastEntry || !from || from.kind !== 'member' || lastEntry.from?.kind !== 'member') {
+    return false
+  }
+
+  if (String(lastEntry.from?.name || '') !== String(from.name || '')) {
+    return false
+  }
+
+  if (String(lastEntry.from?.source || '') !== String(from.source || '')) {
+    return false
+  }
+
+  if (String(lastEntry.thread || 'legacy') !== String(thread || 'legacy')) {
+    return false
+  }
+
+  if (now - (lastEntry.at || 0) > GROUP_DUPLICATE_APPEND_WINDOW_MS) {
+    return false
+  }
+
+  return String(lastEntry.text || '') === String(text || '').trim()
+}
+
+// --- end room-turn decision helpers ---
+
+export function groupThreadOf(entry: GroupMessage): string {
+  return entry?.thread || 'legacy'
+}
+
+export function mintGroupThreadId(): string {
+  return `t${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`
+}
+
+// Pre-thread logs (hydrated from storage) get synthetic thread ids: a user
+// entry after a real lull starts one, so multi-turn tasks stay whole instead
+// of splitting on every follow-up.
+const GROUP_THREAD_GAP_MS = 15 * 60000
+
+export function assignLegacyThreads(log: GroupMessage[]): GroupMessage[] {
+  let current: null | string = null
+  let n = 0
+
+  return (log || []).map((entry, i) => {
+    if (entry?.thread) {
+      current = null
+
+      return entry
+    }
+
+    const prev = log[i - 1]
+    const lull = !prev || (entry.at || 0) - (prev.at || 0) > GROUP_THREAD_GAP_MS
+
+    if (!current || (entry.from?.kind === 'user' && lull)) {
+      current = `legacy-${n++}`
+    }
+
+    return {
+      ...entry,
+      thread: current
+    }
+  })
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-membership.test.ts b/apps/desktop/src/plugins/hermes-bots/group-membership.test.ts
new file mode 100644
index 000000000000..8c3476e551c6
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-membership.test.ts
@@ -0,0 +1,372 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as data from './data'
+import type * as groupChat from './group-chat'
+import type * as groupMembership from './group-membership'
+import { createGroupGateway, scriptedStorage } from './group-test-utils'
+import type * as labels from './labels'
+import type { BotMeta, GroupChat, GroupMember, RosterRow } from './types'
+
+// Who is seated in a room, and how a room's membership is written down.
+// Membership lives in two places on purpose: local bots carry it in bot-meta
+// (`groups`, syncable via ui_meta), while remote members can only be described
+// by the room record itself — so seating is a union, and the two halves have
+// to agree about identity.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+
+  return pluginSdkMock(host)
+})
+
+interface Modules {
+  chat: typeof groupChat
+  data: typeof data
+  labels: typeof labels
+  membership: typeof groupMembership
+}
+
+async function load(): Promise<Modules> {
+  vi.resetModules()
+  const gateway = createGroupGateway()
+
+  for (const key of Object.keys(host)) {
+    delete host[key]
+  }
+
+  Object.assign(host, gateway.host)
+
+  const [chat, data, labels, membership, shared] = await Promise.all([
+    import('./group-chat'),
+    import('./data'),
+    import('./labels'),
+    import('./group-membership'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx(scriptedStorage(gateway.storage))
+
+  return { chat, data, labels, membership }
+}
+
+let modules: Modules
+
+/** Room records as the store holds them, built from the handful of fields a
+ *  case actually cares about. */
+function rooms(map: Record<string, Partial<GroupChat>>): Record<string, GroupChat> {
+  return Object.fromEntries(Object.entries(map).map(([name, room]) => [name, { log: [], watermarks: {}, ...room }]))
+}
+
+beforeEach(async () => {
+  modules = await load()
+})
+
+describe('membership metadata', () => {
+  it('botGroups normalizes canonical and legacy membership without duplicates', () => {
+    const { botGroups } = modules.membership
+
+    expect(
+      botGroups({
+        group: 'Operations',
+        groups: [' Engineering ', '', 'Research', 'Engineering', null, 7, { name: 'Nope' }]
+      } as BotMeta)
+    ).toEqual(['Engineering', 'Research'])
+    expect(botGroups({ group: 'Legacy' })).toEqual(['Legacy'])
+    expect(botGroups({ groups: [] })).toEqual([])
+  })
+
+  it('groupMembershipPatch toggles one membership and keeps the legacy projection compatible', () => {
+    const { groupMembershipPatch } = modules.membership
+    const meta: BotMeta = { group: 'Engineering', groups: ['Engineering', 'Research'] }
+
+    expect(groupMembershipPatch(meta, 'Engineering', true)).toEqual({
+      group: 'Engineering',
+      groups: ['Engineering', 'Research']
+    })
+    expect(groupMembershipPatch(meta, 'Operations', true)).toEqual({
+      group: 'Engineering',
+      groups: ['Engineering', 'Research', 'Operations']
+    })
+    expect(groupMembershipPatch(meta, 'Engineering', false)).toEqual({ group: 'Research', groups: ['Research'] })
+    expect(groupMembershipPatch({ group: 'Legacy' }, 'Legacy', false)).toEqual({ group: null, groups: [] })
+  })
+
+  it('knownGroups is unique, trimmed and alphabetical', () => {
+    expect(
+      modules.membership.knownGroups({
+        a: { group: 'research' },
+        b: { group: 'Ops', groups: ['Ops', 'research'] },
+        c: { groups: ['Design'] },
+        d: { group: '' },
+        e: {}
+      })
+    ).toEqual(['Design', 'Ops', 'research'])
+  })
+})
+
+describe('room listing', () => {
+  it('groupChatNames unions bot-meta groups with room records that carry members or a log', () => {
+    const meta: Record<string, BotMeta> = {
+      pm: { group: 'Ops', groups: ['Ops', 'Research'] },
+      researcher: { group: 'Research' },
+      scout: { group: 'Stale', groups: ['External'] }
+    }
+
+    const known = rooms({
+      Chatty: { log: [{ at: 5, from: { kind: 'user', name: 'You' }, id: '1', text: 'hi' }] },
+      Empty: { members: [] }, // nothing behind it — no row
+      Remote: { members: [{ name: 'spark', remoteSource: true }] },
+      Research: { members: [] } // already known via meta
+    })
+
+    expect([...modules.membership.groupChatNames(meta, known)].sort()).toEqual([
+      'Chatty',
+      'External',
+      'Ops',
+      'Remote',
+      'Research'
+    ])
+  })
+
+  it('groupLastActivity is the newest room-log timestamp, 0 for silence', () => {
+    const { groupLastActivity } = modules.membership
+
+    expect(groupLastActivity({ log: [{ at: 3 }, { at: 9 }] } as GroupChat)).toBe(9)
+    expect(groupLastActivity({ log: [], watermarks: {} })).toBe(0)
+    expect(groupLastActivity(undefined)).toBe(0)
+  })
+
+  it('stripPreviewMarkdown flattens bold, quotes, code and links out of row previews', () => {
+    const { stripPreviewMarkdown } = modules.labels
+
+    expect(stripPreviewMarkdown('**Plan**: ship the `thing`')).toBe('Plan: ship the thing')
+    expect(stripPreviewMarkdown('> quoted wisdom')).toBe('quoted wisdom')
+    expect(stripPreviewMarkdown('see [the doc](https://x.y/z) now')).toBe('see the doc now')
+    expect(stripPreviewMarkdown('## Heading\nbody')).toBe('Heading body')
+    expect(stripPreviewMarkdown('')).toBe('')
+  })
+})
+
+describe('seating a room', () => {
+  it('seats local meta members plus stored remote descriptors, preferring live rows', () => {
+    const roster: RosterRow[] = [
+      { name: 'researcher' },
+      { name: 'builder' },
+      { connectionId: 'c1', name: 'spark', remoteSource: true, sourceScoped: true }
+    ]
+
+    modules.chat.$groupChats.set(
+      rooms({
+        Research: {
+          log: [],
+          members: [{ connectionId: 'c1', name: 'spark', remoteSource: true, sourceScoped: true }]
+        }
+      })
+    )
+
+    const members = modules.membership.groupChatMemberBots('Research', roster, {
+      builder: { group: 'Ops', groups: ['Ops', 'Research'] },
+      researcher: { group: 'Research' }
+    })
+
+    expect(members.map(row => row.name)).toEqual(['researcher', 'builder', 'spark'])
+    // The LIVE roster row was preferred over the stored descriptor.
+    expect(members[2]).toBe(roster[2])
+  })
+
+  it('keeps a persisted unreachable source member seated next to a live same-name twin', () => {
+    const live: RosterRow = {
+      connectionId: 'local',
+      connectionKind: 'local',
+      connectionLabel: 'This device',
+      handle: 'profile-a-this-device',
+      name: 'profile-a',
+      sourceReachable: true
+    }
+
+    const stored: RosterRow = {
+      connectionId: 'loopback-19119',
+      connectionKind: 'remote',
+      connectionLabel: '127.0.0.1:19119',
+      handle: 'profile-a-127-0-0-1-19119',
+      name: 'profile-a',
+      remoteSource: true,
+      sourceReachable: false,
+      sourceScoped: true
+    }
+
+    modules.chat.$groupChats.set(rooms({ Research: { log: [], members: [stored] } }))
+
+    const members = modules.membership.groupChatMemberBots('Research', [live, stored], {
+      'profile-a': { group: 'Research' }
+    })
+
+    expect(members).toHaveLength(2)
+    expect(members[0]).toBe(live)
+    expect(members[1]).toBe(stored)
+    expect(members[1].handle).toBe('profile-a-127-0-0-1-19119')
+  })
+
+  it('lets a stored descriptor beat a presentation-only ghost', () => {
+    // A selected-but-offline ghost carries only enough identity to paint the
+    // roster; the durable descriptor owns the handle mentions resolve against.
+    const ghost: RosterRow = {
+      connectionId: 'c1',
+      connectionLabel: 'Workshop',
+      ghost: true,
+      name: 'spark',
+      remoteSource: true,
+      sourceScoped: true
+    }
+
+    const stored: RosterRow = {
+      connectionId: 'c1',
+      connectionLabel: 'Workshop',
+      handle: 'spark-work',
+      name: 'spark',
+      remoteSource: true,
+      sourceScoped: true,
+      title: 'Spark'
+    }
+
+    modules.chat.$groupChats.set(rooms({ Research: { log: [], members: [stored] } }))
+
+    const members = modules.membership.groupChatMemberBots('Research', [ghost], {})
+
+    expect(members).toHaveLength(1)
+    expect(members[0]).toBe(stored)
+    expect(members[0].handle).toBe('spark-work')
+  })
+
+  it('durableGroupChatMembers retains active and remote source identities', () => {
+    const members = modules.membership.durableGroupChatMembers([
+      {
+        connectionId: 'noah',
+        connectionKind: 'remote',
+        connectionLabel: 'Noah',
+        handle: 'noah',
+        name: 'default',
+        sourceScoped: true
+      },
+      {
+        connectionId: 'maya',
+        connectionKind: 'remote',
+        connectionLabel: 'Maya',
+        handle: 'maya',
+        name: 'default',
+        remoteSource: true,
+        sourceScoped: true
+      }
+    ])
+
+    expect(members).toEqual([
+      {
+        connectionId: 'noah',
+        connectionKind: 'remote',
+        connectionLabel: 'Noah',
+        handle: 'noah',
+        name: 'default',
+        remoteSource: true,
+        route: { connectionId: 'noah', mode: 'remote', profile: 'default', targetProfile: 'default' },
+        sourceScoped: true,
+        targetProfile: 'default'
+      },
+      {
+        connectionId: 'maya',
+        connectionKind: 'remote',
+        connectionLabel: 'Maya',
+        handle: 'maya',
+        name: 'default',
+        remoteSource: true,
+        route: { connectionId: 'maya', mode: 'remote', profile: 'default', targetProfile: 'default' },
+        sourceScoped: true,
+        targetProfile: 'default'
+      }
+    ])
+  })
+})
+
+// #92794: older builds persisted group members with a FRIENDLY name as `name`
+// (e.g. `name: '大司命'` for the profile slug `taiyi`). Key matching alone
+// seats such a descriptor as a ghost NEXT TO its own live roster row ("4 bots"
+// in a 2-bot room — reproduced live), and any path that passes the ghost's
+// identity onward targets a profile that does not exist on disk. Seating
+// re-tries an unmatched descriptor by friendly name against same-connection
+// roster rows first.
+describe('legacy display-name descriptors', () => {
+  const TAIYI: RosterRow = { connectionId: 'local', display_name: '大司命', name: 'taiyi', remoteSource: false }
+  const TESTBOT: RosterRow = { connectionId: 'local', display_name: '', name: 'testbot', remoteSource: false }
+
+  it('seat their live row once, not as extra ghosts', () => {
+    modules.chat.$groupChats.set(
+      rooms({
+        room: {
+          log: [],
+          // The legacy shape: friendly names persisted as `name`.
+          members: [
+            { connectionId: 'local', handle: '大司命', name: '大司命' },
+            { connectionId: 'local', handle: 'Testbot', name: 'Testbot' }
+          ]
+        }
+      })
+    )
+    modules.data.$botMeta.set({ taiyi: { groups: ['room'] }, testbot: { groups: ['room'], title: 'Testbot' } })
+
+    const seated = modules.membership.groupChatMemberBots('room', [TAIYI, TESTBOT], {
+      taiyi: { groups: ['room'] },
+      testbot: { groups: ['room'], title: 'Testbot' }
+    })
+
+    // Two members, not four: each legacy descriptor resolved to its live row.
+    expect(seated.map(row => row.name).sort()).toEqual(['taiyi', 'testbot'])
+  })
+
+  it('still seat a genuinely unknown descriptor as a degraded ghost', () => {
+    modules.chat.$groupChats.set(rooms({ room: { log: [], members: [{ connectionId: 'gone', name: 'vanished' }] } }))
+
+    const seated = modules.membership.groupChatMemberBots('room', [TAIYI], { taiyi: { groups: ['room'] } })
+
+    expect(seated).toHaveLength(2)
+    expect(seated.some(row => row.name === 'vanished')).toBe(true)
+  })
+
+  it('resolve a connectionless pre-scoping descriptor against local rows', () => {
+    // The oldest legacy shape: no connectionId at all (pre-connection-scoping
+    // rooms only ever held this machine's bots). Reproduced live: such ghosts
+    // keyed as legacy::<display-name> and doubled the seated roster.
+    modules.chat.$groupChats.set(rooms({ room: { log: [], members: [{ name: '大司命' }] } }))
+
+    expect(modules.membership.groupChatMemberBots('room', [TAIYI], {}).map(row => row.name)).toEqual(['taiyi'])
+  })
+
+  it('never match a friendly name across connections', () => {
+    const remoteTwin: RosterRow = {
+      connectionId: 'other-box',
+      display_name: '大司命',
+      name: 'shadow',
+      remoteSource: true
+    }
+
+    modules.chat.$groupChats.set(rooms({ room: { log: [], members: [{ connectionId: 'local', name: '大司命' }] } }))
+
+    const seated = modules.membership.groupChatMemberBots('room', [remoteTwin], {})
+
+    // Same friendly name on ANOTHER connection must not capture the member.
+    expect(seated.map(row => row.name)).toEqual(['大司命'])
+    expect(seated[0].connectionId).toBe('local')
+  })
+
+  it('pass an exact slug descriptor through untouched', () => {
+    const descriptor = {
+      connectionId: 'local',
+      name: 'taiyi',
+      route: { connectionId: 'local', mode: 'local', profile: 'taiyi', targetProfile: 'taiyi' }
+    } as GroupMember
+
+    modules.chat.$groupChats.set(rooms({ room: { log: [], members: [descriptor] } }))
+
+    expect(modules.membership.groupChatMemberBots('room', [TAIYI], {})[0]).toBe(TAIYI)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-membership.ts b/apps/desktop/src/plugins/hermes-bots/group-membership.ts
new file mode 100644
index 000000000000..8d8e8a00e493
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-membership.ts
@@ -0,0 +1,368 @@
+/**
+ * Who is in a room: the membership keys, the ui_meta group lists each bot
+ * carries, and the roster→member descriptor derivation the room engine and
+ * the roster UI both read.
+ */
+
+import { $botMeta, botFriendlyNames, botMetaKey, botRosterKey } from './data'
+import { $groupChats, groupChatRoomKey } from './group-chat'
+import { botConnectionRoute, botRosterMeta, resolveBotConnectionRoute } from './routing'
+import type { BotMeta, GroupChat, GroupMember, RosterRow } from './types'
+
+export function groupWorkspaceOwnerKey(group: string) {
+  return `group:${groupChatRoomKey(group, $groupChats.get()[group])}`
+}
+
+/** Stable per-member identity inside a group room. Local members keep their
+ *  bare name (compat with rooms persisted before cross-connection groups);
+ *  remote members get the source-qualified key so `dixie` on the Mini and a
+ *  local `dixie` never share watermarks or sessions. */
+export function groupMemberKey(member: GroupMember): string {
+  return member?.sourceScoped || member?.remoteSource ? botRosterKey(member) : member?.name
+}
+
+/** Serializable immutable owner captured beside every group plumbing session. */
+export function groupSessionOwner(member: RosterRow) {
+  const route = botConnectionRoute(member)
+  const name = String(route?.profile || member?.name || '').trim() || 'default'
+
+  if (!route) {
+    return {
+      name
+    }
+  }
+
+  return {
+    connectionId: route.connectionId,
+    name,
+    sourceScoped: true,
+    remoteSource: route.mode !== 'local',
+    route: {
+      ...route
+    }
+  }
+}
+
+/** Canonical multi-group read with legacy scalar compatibility. Profiles that
+ *  predate `groups` still fall back to `group`; once the canonical array exists,
+ *  it is authoritative. Writes keep `group` as a first-membership projection so
+ *  older desktops can still display one room without corrupting the array. */
+export function botGroups(meta?: BotMeta | null) {
+  const groups: string[] = []
+  const seen = new Set<string>()
+  const values = Array.isArray(meta?.groups) ? meta.groups : [meta?.group]
+
+  for (const value of values) {
+    if (typeof value !== 'string') {
+      continue
+    }
+
+    const group = value.trim()
+
+    if (group && !seen.has(group)) {
+      seen.add(group)
+      groups.push(group)
+    }
+  }
+
+  return groups
+}
+
+interface GroupMembershipPatch {
+  /** Legacy single-group scalar, kept as a first-membership projection. */
+  group: null | string
+  groups: string[]
+}
+
+export function groupMembershipPatch(
+  meta: BotMeta | null | undefined,
+  group: string,
+  enabled: boolean
+): GroupMembershipPatch {
+  const name = String(group || '').trim()
+  let groups = botGroups(meta)
+
+  if (enabled) {
+    if (name && !groups.includes(name)) {
+      groups = [...groups, name]
+    }
+  } else {
+    groups = groups.filter(existing => existing !== name)
+  }
+
+  return {
+    groups,
+    group: groups[0] || null
+  }
+}
+
+/** Build the exact metadata cleanup for a room disband. The rendered member
+ *  list is only a presentation snapshot and can already be empty on a remote
+ *  connection while bot metadata still names the room. Durable room members
+ *  and the full roster recover source-qualified owners; every remaining
+ *  metadata record is still cleared locally, but an unresolved scoped key is
+ *  never guessed into a server route. */
+export function groupDisbandMetadataPlan(
+  group: string,
+  members: RosterRow[],
+  room: GroupChat,
+  roster: RosterRow[],
+  metaByName: Record<string, BotMeta>
+) {
+  const owners = new Map<string, RosterRow>()
+  const patches = new Map<string, GroupMembershipPatch>()
+
+  const rememberOwner = (owner: RosterRow, required = false) => {
+    if (!owner?.name) {
+      return
+    }
+
+    let key: string
+
+    try {
+      key = botMetaKey(owner)
+    } catch {
+      return
+    }
+
+    const meta = metaByName?.[key] || botRosterMeta(owner, metaByName) || {}
+
+    if (!required && !botGroups(meta).includes(group)) {
+      return
+    }
+
+    if (!owners.has(key)) {
+      owners.set(key, owner)
+    }
+
+    patches.set(key, groupMembershipPatch(meta, group, false))
+  }
+
+  for (const owner of members || []) {
+    rememberOwner(owner, true)
+  }
+
+  for (const owner of room?.members || []) {
+    rememberOwner(owner, true)
+  }
+
+  for (const owner of roster || []) {
+    rememberOwner(owner)
+  }
+
+  // Metadata itself is the final source of a metadata-only `0 bots` row.
+  // Clear every record that names the room even when its exact server owner is
+  // temporarily absent from the roster. Known owners still get a routed
+  // profiles.configure write below; unknown scoped records remain local-only.
+  for (const [key, meta] of Object.entries(metaByName || {})) {
+    if (botGroups(meta).includes(group)) {
+      patches.set(key, groupMembershipPatch(meta, group, false))
+    }
+  }
+
+  return {
+    owners,
+    patches
+  }
+}
+
+/** Group chats that should hold a roster row: every group named in bot meta
+ *  (local members) plus every room record that still has stored members or
+ *  log — cross-connection rooms whose members can't ride bot-meta. */
+export function groupChatNames(metaByName: Record<string, BotMeta>, rooms: Record<string, GroupChat>) {
+  const names = new Set(knownGroups(metaByName))
+
+  for (const [name, room] of Object.entries(rooms || {})) {
+    if (room?.tombstone) {
+      continue
+    }
+
+    if ((Array.isArray(room?.members) && room.members.length) || (Array.isArray(room?.log) && room.log.length)) {
+      names.add(name)
+    }
+  }
+
+  return [...names]
+}
+
+/** Names of REAL rooms in the atom — disband tombstones excluded. Feeds the
+ *  create/rename collision sets so a just-disbanded name is immediately
+ *  reusable even while an in-flight drive's tombstone still holds its key. */
+export function liveGroupChatNames() {
+  return Object.entries($groupChats.get())
+    .filter(([, room]) => !room?.tombstone)
+    .map(([name]) => name)
+}
+
+/** Millisecond timestamp of a room's newest log entry (0 for a silent room) —
+ *  the group's recency key, competing in the same ordering as bot rows. */
+export function groupLastActivity(room?: GroupChat | null) {
+  const log = Array.isArray(room?.log) ? room.log : []
+
+  return log.length ? log[log.length - 1].at || 0 : 0
+}
+
+/** Seat a group's member roster: local bots whose meta names the group, plus
+ *  the room record's stored descriptors (remote members can't ride bot-meta).
+ *  Prefers the LIVE roster row for a stored descriptor when present. */
+export function groupChatMemberBots(
+  group: string,
+  roster: RosterRow[],
+  metaByName: Record<string, BotMeta>
+): RosterRow[] {
+  const local = (roster || []).filter(bot => botGroups(botRosterMeta(bot, metaByName)).includes(group))
+  const stored = ($groupChats.get()[group] || {}).members || []
+  const seated = new Set(local.map(botRosterKey))
+  const remote: RosterRow[] = []
+
+  for (const descriptor of stored) {
+    // Legacy descriptors can carry a FRIENDLY name as `name` (older builds
+    // persisted display names — #92794: `name: '大司命'` for slug `taiyi`).
+    // Key-matching alone then seats the descriptor as a ghost NEXT TO its own
+    // live row ("4 bots" in a 2-bot room), and anything that passes ghost
+    // identity onward targets a profile that does not exist on disk.
+    // Normalize first: a same-connection roster row whose friendly names
+    // include the descriptor's name IS this member. The next persistence
+    // pass (durableGroupChatMembers writes from the seated roster) rewrites
+    // the stored descriptor to the slug, so the repair is self-healing.
+    const resolved = resolveLegacyMemberDescriptor(descriptor, roster)
+    const key = botRosterKey(resolved)
+
+    if (seated.has(key)) {
+      continue
+    }
+
+    seated.add(key)
+    // A selected-but-offline ghost intentionally carries only enough identity
+    // to paint the roster. Never let it replace the room's durable descriptor,
+    // which owns the full handle/title used by mentions and remote sync.
+    remote.push((roster || []).find(bot => !bot?.ghost && botRosterKey(bot) === key) || resolved)
+  }
+
+  return [...local, ...remote]
+}
+
+/** A stored member descriptor, resolved against the live roster when its
+ *  `name` is not a real slug (#92794). Exact key matches pass through
+ *  untouched; only a descriptor whose key matches NO roster row is re-tried
+ *  by friendly name against rows on the same connection. Unresolvable
+ *  descriptors return as-is — they stay visible-but-degraded ghosts and must
+ *  never be used as a `profile:` target. */
+function resolveLegacyMemberDescriptor(descriptor: RosterRow, roster: RosterRow[]): RosterRow {
+  const rows = roster || []
+
+  if (rows.some(bot => botRosterKey(bot) === botRosterKey(descriptor))) {
+    return descriptor
+  }
+
+  const wanted = String(descriptor?.name || '')
+    .trim()
+    .toLowerCase()
+
+  if (!wanted) {
+    return descriptor
+  }
+
+  // Connection scope: a descriptor WITH a connectionId only matches rows on
+  // that connection (two `default`s on different machines must never merge).
+  // A descriptor WITHOUT one predates connection scoping entirely — those
+  // rooms only ever contained this machine's bots, so local (non-remote)
+  // rows are the legal candidate set.
+  const descriptorConnection = String(descriptor?.connectionId || '')
+
+  const candidates = rows.filter(bot => {
+    if (bot?.ghost) {
+      return false
+    }
+
+    return descriptorConnection ? String(bot?.connectionId || '') === descriptorConnection : !bot?.remoteSource
+  })
+
+  const match = candidates.find(
+    bot =>
+      // Case-drifted slug ('Testbot' persisted for profile 'testbot') …
+      String(bot?.name || '')
+        .trim()
+        .toLowerCase() === wanted ||
+      // … or a friendly name persisted as `name` ('大司命' for 'taiyi').
+      botFriendlyNames(bot).some(
+        name =>
+          String(name || '')
+            .trim()
+            .toLowerCase() === wanted
+      )
+  )
+
+  return match || descriptor
+}
+
+/** Persist source-qualified identities for every selected member. The active
+ *  source's row may become remote after a connection switch, so retaining it
+ *  here is what keeps the same room intact across machines. */
+export function durableGroupChatMembers(bots: RosterRow[]): GroupMember[] {
+  return (bots || []).map(bot => {
+    // Persistence pass over the whole seated roster: an orphaned member
+    // (connection deleted) keeps its identity and simply persists with no
+    // route — the same degraded shape the hydrate annotate produces. The
+    // strict throw here would lose the entire room update over one row.
+    const route = resolveBotConnectionRoute(bot).route
+
+    // Keep the friendly identity on the stored descriptor: after a
+    // connection switch the live roster row may be gone, and renamed-tag
+    // mentions must still resolve against the persisted member.
+    const title = String(
+      botRosterMeta(bot, $botMeta.get())?.title || bot.ui_meta?.['hermes-bots']?.title || bot.title || ''
+    ).trim()
+
+    return {
+      name: bot.name,
+      handle: bot.handle || bot.name,
+      ...(title
+        ? {
+            title
+          }
+        : {}),
+      ...(bot.display_name
+        ? {
+            display_name: bot.display_name
+          }
+        : {}),
+      connectionId: bot.connectionId,
+      connectionKind: bot.connectionKind,
+      connectionLabel: bot.connectionLabel,
+      ...(route
+        ? {
+            route,
+            targetProfile: route.targetProfile
+          }
+        : {}),
+      // A swept/annotated member keeps its degraded mark across the rebuild —
+      // otherwise the next room send would silently un-mark an orphaned row.
+      ...(bot.sourceMissing
+        ? {
+            sourceMissing: true,
+            sourceReachable: false
+          }
+        : {}),
+      remoteSource: true,
+      sourceScoped: Boolean(route)
+    }
+  })
+}
+
+/** Existing group names, alphabetical — feeds the Manage-groups dialog. */
+export function knownGroups(metaByName: Record<string, BotMeta>) {
+  const names = new Set<string>()
+
+  for (const meta of Object.values(metaByName || {})) {
+    for (const group of botGroups(meta)) {
+      names.add(group)
+    }
+  }
+
+  return [...names].sort((a, b) =>
+    a.localeCompare(b, undefined, {
+      sensitivity: 'base'
+    })
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-panes.test.ts b/apps/desktop/src/plugins/hermes-bots/group-panes.test.ts
new file mode 100644
index 000000000000..4ad669dfd781
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-panes.test.ts
@@ -0,0 +1,140 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { GroupChatRoom } from './group-chat'
+import type { Attachment } from './types'
+
+// group-panes is a leaf over the room store, and the room store reaches the
+// gateway through `host`. Nothing here talks to a gateway, so the mock only
+// has to satisfy the import graph.
+const { host } = vi.hoisted(() => ({
+  host: {
+    request: vi.fn(async () => ({})),
+    requestProfile: vi.fn(async () => ({})),
+    state: { connectionId: { get: () => 'local', listen: () => () => undefined } }
+  }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const nanostores = await import('nanostores')
+
+  return {
+    atom: nanostores.atom,
+    computed: nanostores.computed,
+    host,
+    queryClient: { invalidateQueries: vi.fn() },
+    useQuery: () => ({ data: [], isLoading: false }),
+    useValue: <T>(store: { get: () => T }) => store.get()
+  }
+})
+
+// The draft map is module-scope, which is the whole point of it (it has to
+// outlive a pane), so every test needs a fresh module.
+async function loadDrafts() {
+  vi.resetModules()
+
+  return import('./group-panes')
+}
+
+/** A room record from just the field a draft key is derived from. */
+const room = (partial: Partial<GroupChatRoom>): GroupChatRoom => ({ log: [], watermarks: {}, ...partial })
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('group composer drafts', () => {
+  it('workspace retirement and re-registration restore the exact room draft', async () => {
+    const drafts = await loadDrafts()
+    const key = drafts.groupComposerDraftKey('Launch room', room({ roomId: 'room-1' }))
+    const attachment: Attachment = { data: 'data:image/png;base64,abc', kind: 'image', name: 'plan.png' }
+
+    drafts.updateGroupComposerDraft(key, state => ({
+      ...state,
+      activeReplyThread: 'thread-1',
+      main: 'main draft',
+      pendingAttachments: { main: [attachment], 'thread-1': [attachment] },
+      replies: { 'thread-1': 'reply draft' }
+    }))
+
+    // Dropping the component reference simulates pane retirement. A fresh
+    // registration reads the same module-scope, roomId-qualified snapshot.
+    const remounted = drafts.groupComposerDraftSnapshot(key)
+
+    expect(remounted.main).toBe('main draft')
+    expect(remounted.replies['thread-1']).toBe('reply draft')
+    expect(remounted.activeReplyThread).toBe('thread-1')
+    expect(remounted.pendingAttachments.main[0].name).toBe('plan.png')
+  })
+
+  it('legacy name-keyed drafts migrate when an immutable room id appears', async () => {
+    const drafts = await loadDrafts()
+    const legacy = drafts.groupComposerDraftKey('Launch room', room({}))
+    const current = drafts.groupComposerDraftKey('Renamed room', room({ roomId: 'room-1' }))
+
+    drafts.updateGroupComposerDraft(legacy, state => ({ ...state, main: 'keep me' }))
+    drafts.migrateGroupComposerDraft(legacy, current)
+
+    expect(drafts.groupComposerDraftSnapshot(current).main).toBe('keep me')
+    expect(drafts.groupComposerDraftSnapshot(legacy).main).toBe('')
+  })
+
+  it('a failed send cannot overwrite text entered after the optimistic clear', async () => {
+    const drafts = await loadDrafts()
+    const key = 'id:room-1'
+
+    drafts.updateGroupComposerDraft(key, state => ({ ...state, main: 'send this' }))
+    const before = drafts.groupComposerDraftSnapshot(key)
+    const cleared = drafts.updateGroupComposerDraft(key, state => ({ ...state, main: '' }))
+
+    drafts.updateGroupComposerDraft(key, state => ({ ...state, main: 'newer typing' }))
+
+    expect(drafts.restoreGroupComposerDraft(key, cleared.revision, before)).toBeNull()
+    expect(drafts.groupComposerDraftSnapshot(key).main).toBe('newer typing')
+  })
+
+  it('disband removes only that room draft', async () => {
+    const drafts = await loadDrafts()
+
+    drafts.updateGroupComposerDraft('id:a', state => ({ ...state, main: 'a' }))
+    drafts.updateGroupComposerDraft('id:b', state => ({ ...state, main: 'b' }))
+    drafts.clearGroupComposerDraft('id:a')
+
+    expect(drafts.groupComposerDraftSnapshot('id:a').main).toBe('')
+    expect(drafts.groupComposerDraftSnapshot('id:b').main).toBe('b')
+  })
+})
+
+describe('main-window tab registry', () => {
+  // #89788: the in-panel room is a FALLBACK surface. The Map alone can't
+  // notify React, so ownership has to move the rev atom too — the first fix
+  // read the Map non-reactively and left two live panes driving one engine.
+  it('the in-pane room yields to a main tab, and the gate is reactive', async () => {
+    const panes = await loadDrafts()
+
+    expect(panes.shouldRenderGroupChatInPane('Launch room')).toBe(true)
+
+    const rev = panes.$groupMainTabsRev.get()
+    panes.recordGroupMainTab('Launch room', () => undefined)
+
+    expect(panes.shouldRenderGroupChatInPane('Launch room')).toBe(false)
+    expect(panes.$groupMainTabsRev.get()).toBeGreaterThan(rev)
+
+    panes.dropGroupMainTab('Launch room')
+
+    expect(panes.shouldRenderGroupChatInPane('Launch room')).toBe(true)
+  })
+
+  it('closing the tab runs its closer and releases the workspace', async () => {
+    vi.resetModules()
+    const [panes, chat] = await Promise.all([import('./group-panes'), import('./group-chat')])
+    const close = vi.fn()
+
+    chat.$groupChatWorkspace.set('Launch room')
+    panes.recordGroupMainTab('Launch room', close)
+    panes.closeGroupChatMainTab('Launch room')
+
+    expect(close).toHaveBeenCalledOnce()
+    expect(chat.$groupChatWorkspace.get()).toBeNull()
+    expect(panes.groupChatMainTabs.has('Launch room')).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-panes.ts b/apps/desktop/src/plugins/hermes-bots/group-panes.ts
new file mode 100644
index 000000000000..48ca27a936ab
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-panes.ts
@@ -0,0 +1,166 @@
+/**
+ * The window-local state a group-chat room needs but never renders: the
+ * per-composer drafts, and the registry of MAIN-window tabs a room is open in.
+ *
+ * A leaf by design. The room surface and the roster pane both read it and it
+ * reads neither, so a disband, a rename or a Back button can retire a room's
+ * tab without any of those paths importing a view.
+ */
+
+import { atom } from '@hermes/plugin-sdk'
+
+import { $groupChatWorkspace, groupChatRoomKey } from './group-chat'
+import type { GroupChatRoom } from './group-chat'
+import type { Attachment } from './types'
+
+// Group composer drafts are window-local UI state. They must survive pane
+// parking/re-registration and owner switches, but must never enter shared room
+// metadata (where another Desktop would see half-typed text or attachment
+// bytes). Current rooms key by immutable roomId; legacy rooms fall back to the
+// display name until they are upgraded.
+export interface GroupComposerDraft {
+  activeReplyThread: null | string
+  main: string
+  /** Keyed by thread id; the main composer parks under 'main'. */
+  pendingAttachments: Record<string, Attachment[]>
+  replies: Record<string, string>
+  revision: number
+}
+const groupComposerDrafts = new Map<string, GroupComposerDraft | undefined>()
+
+function emptyGroupComposerDraft(): GroupComposerDraft {
+  return {
+    activeReplyThread: null,
+    main: '',
+    pendingAttachments: {},
+    replies: {},
+    revision: 0
+  }
+}
+
+export function groupComposerDraftKey(group: string, room: GroupChatRoom): string {
+  return groupChatRoomKey(group, room)
+}
+
+export function groupComposerDraftSnapshot(key: string): GroupComposerDraft {
+  return groupComposerDrafts.get(key) || emptyGroupComposerDraft()
+}
+
+export function updateGroupComposerDraft(key: string, mutate: (draft: GroupComposerDraft) => GroupComposerDraft) {
+  const current = groupComposerDraftSnapshot(key)
+
+  const next = mutate({
+    ...current,
+    pendingAttachments: Object.fromEntries(
+      Object.entries(current.pendingAttachments || {}).map(([thread, attachments]) => [
+        thread,
+        [...(attachments || [])]
+      ])
+    ),
+    replies: {
+      ...(current.replies || {})
+    }
+  })
+
+  next.revision = current.revision + 1
+  groupComposerDrafts.delete(key)
+  groupComposerDrafts.set(key, next)
+
+  return next
+}
+
+export function restoreGroupComposerDraft(key: string, expectedRevision: number, snapshot: GroupComposerDraft) {
+  const current = groupComposerDraftSnapshot(key)
+
+  if (current.revision !== expectedRevision) {
+    return null
+  }
+
+  const restored = {
+    ...snapshot,
+    pendingAttachments: Object.fromEntries(
+      Object.entries(snapshot.pendingAttachments || {}).map(([thread, attachments]) => [
+        thread,
+        [...(attachments || [])]
+      ])
+    ),
+    replies: {
+      ...(snapshot.replies || {})
+    },
+    revision: current.revision + 1
+  }
+
+  groupComposerDrafts.set(key, restored)
+
+  return restored
+}
+
+export function clearGroupComposerDraft(key: string) {
+  groupComposerDrafts.delete(key)
+}
+
+export function migrateGroupComposerDraft(oldKey: string, newKey: string) {
+  if (oldKey === newKey || !groupComposerDrafts.has(oldKey)) {
+    return
+  }
+
+  if (!groupComposerDrafts.has(newKey)) {
+    groupComposerDrafts.set(newKey, groupComposerDrafts.get(oldKey))
+  }
+
+  groupComposerDrafts.delete(oldKey)
+}
+
+/** React-style setter argument — the next value, or a function of the current. */
+export type GroupDraftSetter<T> = T | ((current: T) => T)
+
+/** Live closers for group-chat MAIN-window tabs, by group name — so a
+ *  disband (or the room view's own Back) can retire the tab it opened. */
+export const groupChatMainTabs = new Map<string, () => void>()
+
+/** Reactive shadow of `groupChatMainTabs` membership. The Map itself can't
+ *  notify React, and #89788's first fix read it non-reactively: a BotsPane
+ *  render that landed between selecting the group and recording its main
+ *  tab kept the in-pane room on screen forever (the map write repaints
+ *  nothing). Every map mutation goes through the two helpers below so the
+ *  rev bump re-evaluates the gate. */
+export const $groupMainTabsRev = atom(0)
+
+export function recordGroupMainTab(group: string, close: () => void) {
+  groupChatMainTabs.set(group, close)
+  $groupMainTabsRev.set($groupMainTabsRev.get() + 1)
+}
+
+export function dropGroupMainTab(group: string) {
+  if (groupChatMainTabs.delete(group)) {
+    $groupMainTabsRev.set($groupMainTabsRev.get() + 1)
+  }
+}
+
+/** The in-panel room is the FALLBACK surface, not a second copy: it renders
+ *  only while no main-window tab owns the group. On desktops with the door
+ *  the room already lives in a main tab, and painting it here too produced
+ *  two live panes with independent drafts driving one shared engine (#89788).
+ *  The selection atom stays set either way so the roster row still
+ *  highlights. Callers must subscribe to `$groupMainTabsRev` (BotsPane does)
+ *  so ownership changes re-run this gate. */
+export function shouldRenderGroupChatInPane(group: null | string): group is string {
+  return Boolean(group && !groupChatMainTabs.has(group))
+}
+
+export function closeGroupChatMainTab(group: string) {
+  const close = groupChatMainTabs.get(group)
+  dropGroupMainTab(group)
+
+  if ($groupChatWorkspace.get() === group) {
+    $groupChatWorkspace.set(null)
+  }
+
+  if (typeof close === 'function') {
+    try {
+      close()
+    } catch {
+      /* tab already gone */
+    }
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-rounds.test.ts b/apps/desktop/src/plugins/hermes-bots/group-rounds.test.ts
new file mode 100644
index 000000000000..fd9ec778bf98
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-rounds.test.ts
@@ -0,0 +1,857 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as groupActivity from './group-activity'
+import type * as groupChat from './group-chat'
+import type * as groupRounds from './group-rounds'
+import { createGroupGateway, drain, runTimersInline, scriptedStorage } from './group-test-utils'
+import type { GatewayOptions, ScriptedGateway } from './group-test-utils'
+import type * as groupTurns from './group-turns'
+import type { Attachment, GroupChat, GroupMember, GroupMessage } from './types'
+
+// The round engine: who answers a room message, in what order, with what
+// delta, and how a round ends. Every contract here is about a SERIAL loop that
+// can be superseded mid-flight — a second send, a stop, or a hold all have to
+// take effect at a member boundary without losing finished work.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+
+  return pluginSdkMock(host)
+})
+
+interface Room {
+  activity: typeof groupActivity
+  chat: typeof groupChat
+  gateway: ScriptedGateway
+  rounds: typeof groupRounds
+  turns: typeof groupTurns
+}
+
+async function loadRoom(options: GatewayOptions = {}): Promise<Room> {
+  vi.resetModules()
+  const gateway = createGroupGateway(options)
+
+  for (const key of Object.keys(host)) {
+    delete host[key]
+  }
+
+  Object.assign(host, gateway.host)
+
+  const [activity, chat, rounds, turns, shared] = await Promise.all([
+    import('./group-activity'),
+    import('./group-chat'),
+    import('./group-rounds'),
+    import('./group-turns'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx(scriptedStorage(gateway.storage))
+
+  return { activity, chat, gateway, rounds, turns }
+}
+
+const MEMBERS: GroupMember[] = [
+  { name: 'research', title: '' },
+  { name: 'builder', title: '' },
+  { name: 'ops', title: 'The Ops' }
+]
+
+const IMG: Attachment = { data: 'data:image/png;base64,iVBORw0KGgo=', kind: 'image', name: 'screenshot.png' }
+
+const log = (room: Room, group: string) => room.chat.$groupChats.get()[group]?.log || []
+
+/** Run the room's drive to completion. */
+async function settle(room: Room, group: string) {
+  await drain(() => Boolean(room.chat.$groupChats.get()[group]?.running))
+}
+
+beforeEach(() => {
+  runTimersInline()
+})
+
+describe('routing', () => {
+  it('reads (pass), pass, pass. and empty as silence, but not real text', async () => {
+    const { turns } = await loadRoom()
+
+    expect(turns.isGroupPassText('(pass)')).toBe(true)
+    expect(turns.isGroupPassText('pass')).toBe(true)
+    expect(turns.isGroupPassText('Pass.')).toBe(true)
+    expect(turns.isGroupPassText('  ')).toBe(true)
+    expect(turns.isGroupPassText('I will pass this to ops')).toBe(false)
+  })
+
+  it('answers only @-mentioned members; @everyone or no mention means all', async () => {
+    const { rounds } = await loadRoom()
+
+    const user = (text: string): GroupMessage[] =>
+      [{ at: 1, from: { kind: 'user', name: 'You' }, text }] as GroupMessage[]
+
+    expect(rounds.resolveGroupResponders(user('@builder take this one'), MEMBERS).map(m => m.name)).toEqual(['builder'])
+    expect(rounds.resolveGroupResponders(user('hello team'), MEMBERS)).toHaveLength(3)
+    expect(rounds.resolveGroupResponders(user('@everyone standup'), MEMBERS)).toHaveLength(3)
+  })
+
+  it('resolves display titles to the member and never matches @user against a bot', async () => {
+    const { rounds } = await loadRoom()
+
+    const parsed = rounds.parseGroupChatMentions('@theops please check, then ping @user', MEMBERS)
+
+    expect(parsed.mentioned.has('ops')).toBe(true)
+    expect(parsed.mentioned.size).toBe(1)
+  })
+
+  it('resolves @hermes to the default member', async () => {
+    const { rounds } = await loadRoom()
+
+    const members: GroupMember[] = [
+      { name: 'default', title: '' },
+      { name: 'builder', title: '' }
+    ]
+
+    const parsed = rounds.parseGroupChatMentions('@hermes take a look', members)
+
+    expect(parsed.mentioned.has('default')).toBe(true)
+    expect(parsed.mentioned.size).toBe(1)
+  })
+
+  it('rotates the lead speaker each round', async () => {
+    const { rounds } = await loadRoom()
+
+    expect(rounds.rotateGroupSpeakers(MEMBERS, 1).map(m => m.name)).toEqual(['builder', 'ops', 'research'])
+    expect(rounds.rotateGroupSpeakers([MEMBERS[0]], 3)).toHaveLength(1)
+  })
+
+  it('pulls a member mentioned by another bot into the NEXT round', async () => {
+    const room = await loadRoom({
+      turn: ({ profile, prompt }) => {
+        if (profile === 'research' && !prompt.includes('(you)')) {
+          return 'Interesting — @builder should own this.'
+        }
+
+        return profile === 'builder' ? 'On it. OWNER: @builder.' : '(pass)'
+      }
+    })
+
+    room.rounds.sendToGroupChat(
+      'Core',
+      [
+        { name: 'research', title: '' },
+        { name: 'builder', title: '' }
+      ],
+      '@research thoughts?'
+    )
+    await settle(room, 'Core')
+
+    const lines = log(room, 'Core').map(entry => `${entry.from.name}: ${entry.text}`)
+
+    expect(lines.some(line => line.startsWith('research:'))).toBe(true)
+    expect(lines.some(line => line.startsWith('builder: On it'))).toBe(true)
+  })
+})
+
+describe('round lifecycle', () => {
+  it('settles when everyone passes, logging only the user message', async () => {
+    const room = await loadRoom()
+
+    room.rounds.sendToGroupChat('Quiet', MEMBERS, 'fyi, deploy went out')
+    await settle(room, 'Quiet')
+
+    expect(log(room, 'Quiet')).toHaveLength(1)
+    expect(log(room, 'Quiet')[0].from.kind).toBe('user')
+    // Every member took exactly one turn (round 1), then the settle exit fired.
+    expect(room.gateway.calls).toHaveLength(3)
+  })
+
+  it('stops chatty members at GROUP_CHAT_MAX_MESSAGES', async () => {
+    const room = await loadRoom({ turn: ({ n }) => `message ${n} — @everyone keep going` })
+
+    room.rounds.sendToGroupChat('Loud', MEMBERS, 'go wild')
+    await settle(room, 'Loud')
+
+    const posted = log(room, 'Loud').filter(entry => entry.from.kind === 'member')
+
+    expect(posted.length).toBeLessThanOrEqual(room.chat.GROUP_CHAT_MAX_MESSAGES)
+  })
+
+  it('treats a failed member turn as a pass, not a room error', async () => {
+    const room = await loadRoom({
+      turn: ({ profile }) => {
+        if (profile === 'builder') {
+          throw new Error('gateway hiccup')
+        }
+
+        return '(pass)'
+      }
+    })
+
+    room.rounds.sendToGroupChat('Flaky', MEMBERS, 'anyone around?')
+    await settle(room, 'Flaky')
+
+    // Just the user message; no error entries.
+    expect(log(room, 'Flaky')).toHaveLength(1)
+  })
+
+  it('badges needs-you when a member addresses @user, and clears it on the next user send', async () => {
+    const room = await loadRoom({
+      turn: ({ profile }) => (profile === 'research' ? 'Blocked on billing access — @user which account?' : '(pass)')
+    })
+
+    const member: GroupMember[] = [{ name: 'research', title: '' }]
+
+    room.rounds.sendToGroupChat('Escalate', member, 'sort out the invoices')
+    await settle(room, 'Escalate')
+
+    expect(room.chat.$groupNeedsYou.get().Escalate).toBe(true)
+
+    room.rounds.sendToGroupChat('Escalate', member, 'use the ops account')
+
+    expect(room.chat.$groupNeedsYou.get().Escalate).toBe(false)
+  })
+
+  it('converts an "(empty)" member reply like the gateway does, never appending it raw', async () => {
+    const room = await loadRoom({ turn: ({ profile }) => (profile === 'research' ? '(empty)' : '(pass)') })
+
+    room.rounds.sendToGroupChat('Sentinel', [{ name: 'research', title: '' }], '@research thoughts?')
+    await settle(room, 'Sentinel')
+
+    const replies = log(room, 'Sentinel').filter(entry => entry.from.kind === 'member')
+
+    expect(replies).toHaveLength(1)
+    expect(replies[0].text).toContain('The model returned no response after processing tool results')
+    expect(replies[0].text).not.toContain('(empty)')
+  })
+
+  it('leaves normal replies untouched', async () => {
+    const room = await loadRoom({ turn: ({ profile }) => (profile === 'research' ? 'I am not empty.' : '(pass)') })
+
+    room.rounds.sendToGroupChat('Sentinel2', [{ name: 'research', title: '' }], '@research hi')
+    await settle(room, 'Sentinel2')
+
+    const replies = log(room, 'Sentinel2').filter(entry => entry.from.kind === 'member')
+
+    expect(replies).toHaveLength(1)
+    expect(replies[0].text).toBe('I am not empty.')
+  })
+})
+
+describe('per-member delta', () => {
+  it('feeds a second send only the NEW messages', async () => {
+    const room = await loadRoom()
+    const member: GroupMember[] = [{ name: 'research', title: '' }]
+
+    room.rounds.sendToGroupChat('Delta', member, 'first message')
+    await settle(room, 'Delta')
+    const firstCount = room.gateway.calls.length
+    room.rounds.sendToGroupChat('Delta', member, 'second message')
+    await settle(room, 'Delta')
+
+    const second = room.gateway.calls.slice(firstCount).find(call => call.prompt.includes('second message'))
+
+    expect(second).toBeDefined()
+    expect(second?.prompt).not.toContain('first message')
+  })
+
+  it('keeps concurrent rooms sharing one member isolated in sessions, deltas and context', async () => {
+    const room = await loadRoom()
+    const shared: GroupMember[] = [{ name: 'research', title: '' }]
+    const quiet = () => !room.chat.$groupChats.get().Alpha?.running && !room.chat.$groupChats.get().Beta?.running
+
+    // Start both rooms without waiting for either drive to finish.
+    room.rounds.sendToGroupChat('Alpha', shared, 'ALPHA_ONLY_1')
+    room.rounds.sendToGroupChat('Beta', shared, 'BETA_ONLY_1')
+    await drain(() => !quiet())
+
+    const alphaFirst = room.gateway.calls.find(call => call.title === 'Group: Alpha')
+    const betaFirst = room.gateway.calls.find(call => call.title === 'Group: Beta')
+
+    expect(alphaFirst && betaFirst).toBeTruthy()
+    expect(alphaFirst?.stored).not.toBe(betaFirst?.stored)
+    expect(alphaFirst?.runtime).not.toBe(betaFirst?.runtime)
+    expect(alphaFirst?.prompt).toContain('ALPHA_ONLY_1')
+    expect(alphaFirst?.prompt).not.toContain('BETA_ONLY_1')
+    expect(betaFirst?.prompt).toContain('BETA_ONLY_1')
+    expect(betaFirst?.prompt).not.toContain('ALPHA_ONLY_1')
+    expect(room.chat.$groupChats.get().Alpha.sessions?.research).toBe(alphaFirst?.stored)
+    expect(room.chat.$groupChats.get().Beta.sessions?.research).toBe(betaFirst?.stored)
+
+    // Interleave a second pair. Each room resumes its own session and receives
+    // only its unseen room delta, never the sibling room's messages.
+    const firstCallCount = room.gateway.calls.length
+    room.rounds.sendToGroupChat('Alpha', shared, 'ALPHA_ONLY_2')
+    room.rounds.sendToGroupChat('Beta', shared, 'BETA_ONLY_2')
+    await drain(() => !quiet())
+
+    const second = room.gateway.calls.slice(firstCallCount)
+    const alphaSecond = second.find(call => call.title === 'Group: Alpha')
+    const betaSecond = second.find(call => call.title === 'Group: Beta')
+
+    expect(alphaSecond?.stored).toBe(alphaFirst?.stored)
+    expect(betaSecond?.stored).toBe(betaFirst?.stored)
+    expect(alphaSecond?.prompt).toContain('ALPHA_ONLY_2')
+    expect(alphaSecond?.prompt).not.toContain('ALPHA_ONLY_1')
+    expect(alphaSecond?.prompt).not.toContain('BETA_ONLY_2')
+    expect(betaSecond?.prompt).toContain('BETA_ONLY_2')
+    expect(betaSecond?.prompt).not.toContain('BETA_ONLY_1')
+    expect(betaSecond?.prompt).not.toContain('ALPHA_ONLY_2')
+
+    const alphaSession = room.gateway.sessions.get(String(alphaFirst?.stored))
+    const betaSession = room.gateway.sessions.get(String(betaFirst?.stored))
+
+    expect(alphaSession?.messages.some(message => message.content.includes('BETA_ONLY'))).toBe(false)
+    expect(betaSession?.messages.some(message => message.content.includes('ALPHA_ONLY'))).toBe(false)
+  })
+})
+
+describe('threads', () => {
+  it('mints a new thread per composer send and lands replies in it', async () => {
+    const room = await loadRoom()
+    const member: GroupMember[] = [{ name: 'research', title: '' }]
+
+    const first = room.rounds.sendToGroupChat('Rooms', member, 'first topic')
+    await settle(room, 'Rooms')
+    const second = room.rounds.sendToGroupChat('Rooms', member, 'second topic')
+    await settle(room, 'Rooms')
+
+    expect(first).toBeTruthy()
+    expect(second).toBeTruthy()
+    expect(first).not.toBe(second)
+    expect(log(room, 'Rooms')[0].thread).toBe(first)
+    expect(log(room, 'Rooms')[1].thread).toBe(second)
+  })
+
+  it('continues an explicit thread and scopes the member delta to it', async () => {
+    const room = await loadRoom({
+      turn: ({ prompt }) => (prompt.includes('billing') ? 'On the billing fix.' : '(pass)')
+    })
+
+    const member: GroupMember[] = [{ name: 'research', title: '' }]
+
+    const billing = room.rounds.sendToGroupChat('Scoped', member, 'fix the billing bug')
+    await settle(room, 'Scoped')
+    room.rounds.sendToGroupChat('Scoped', member, 'research pricing')
+    await settle(room, 'Scoped')
+    const again = room.rounds.sendToGroupChat('Scoped', member, 'billing follow-up: ship it', billing)
+    await settle(room, 'Scoped')
+
+    const followUp = room.gateway.calls.find(call => call.prompt.includes('ship it'))
+    const replies = log(room, 'Scoped').filter(entry => entry.from.kind === 'member')
+
+    expect(again).toBe(billing)
+    expect(followUp).toBeDefined()
+    expect(followUp?.prompt).not.toContain('research pricing')
+    expect(replies.length).toBeGreaterThanOrEqual(1)
+    expect(replies.every(entry => entry.thread === billing)).toBe(true)
+  })
+})
+
+describe('turn prompt', () => {
+  it('addresses the default profile as @hermes', async () => {
+    const { rounds } = await loadRoom()
+
+    const members: GroupMember[] = [
+      { name: 'default', title: '' },
+      { name: 'builder', title: '' }
+    ]
+
+    const own = rounds.buildGroupChatTurnPrompt({
+      deltaLines: [],
+      groupName: 'Core',
+      members,
+      viewer: { name: 'default', title: '' }
+    })
+
+    expect(own).toMatch(/You are @hermes,/)
+    expect(own).not.toMatch(/@default\b/)
+
+    const peer = rounds.buildGroupChatTurnPrompt({
+      deltaLines: [],
+      groupName: 'Core',
+      members,
+      viewer: { name: 'builder', title: '' }
+    })
+
+    expect(peer).toMatch(/group chat with @hermes/)
+  })
+
+  it('asks for full-quality results and short chatter, not short results', async () => {
+    const { rounds } = await loadRoom()
+
+    const prompt = rounds.buildGroupChatTurnPrompt({
+      deltaLines: [],
+      groupName: 'Core',
+      members: [
+        { name: 'research', title: '' },
+        { name: 'builder', title: '' }
+      ],
+      viewer: { name: 'research', title: '' }
+    })
+
+    expect(prompt).toMatch(/never thin out real content/i)
+    expect(prompt).toMatch(/Keep chatter short/i)
+  })
+})
+
+describe('attachments', () => {
+  it('stages them into EVERY responding member session before that member submits', async () => {
+    const room = await loadRoom()
+
+    const members: GroupMember[] = [
+      { name: 'research', title: '' },
+      { name: 'builder', title: '' }
+    ]
+
+    room.rounds.sendToGroupChat('Vision', members, 'what does this show?', null, [IMG])
+    await settle(room, 'Vision')
+
+    expect(room.gateway.attaches).toHaveLength(2)
+    expect(room.gateway.attaches.map(entry => entry.profile).sort()).toEqual(['builder', 'research'])
+
+    for (const attach of room.gateway.attaches) {
+      expect(attach.filename).toBe('screenshot.png')
+      expect(attach.data).toBe(IMG.data)
+    }
+
+    // Each attach landed before that member's prompt.submit: the first attach
+    // happens before any submit, the second before the second submit.
+    expect(room.gateway.attaches[0].order).toBe(0)
+    expect(room.gateway.attaches[1].order).toBeLessThanOrEqual(1)
+    expect(room.gateway.calls).toHaveLength(2)
+  })
+
+  it('scopes attachments by mention: only the mentioned member receives the image', async () => {
+    const room = await loadRoom()
+
+    room.rounds.sendToGroupChat(
+      'Scoped',
+      [
+        { name: 'research', title: '' },
+        { name: 'builder', title: '' }
+      ],
+      '@builder look at this',
+      null,
+      [IMG]
+    )
+    await settle(room, 'Scoped')
+
+    expect(room.gateway.attaches.map(entry => entry.profile)).toEqual(['builder'])
+  })
+
+  it('accepts an image-only send and carries the attachment on the room entry', async () => {
+    const room = await loadRoom()
+
+    const minted = room.rounds.sendToGroupChat(
+      'Silent',
+      [
+        { name: 'research', title: '' },
+        { name: 'builder', title: '' }
+      ],
+      '',
+      null,
+      [IMG]
+    )
+
+    await settle(room, 'Silent')
+
+    expect(minted).toBeTruthy()
+    expect(log(room, 'Silent')).toHaveLength(1)
+    expect(log(room, 'Silent')[0].images?.[0].name).toBe('screenshot.png')
+    // Members still got prompted (with the image staged).
+    expect(room.gateway.attaches).toHaveLength(2)
+    expect(room.gateway.calls).toHaveLength(2)
+  })
+
+  it('never re-attaches an old entry on a later turn', async () => {
+    const room = await loadRoom()
+
+    const members: GroupMember[] = [
+      { name: 'research', title: '' },
+      { name: 'builder', title: '' }
+    ]
+
+    room.rounds.sendToGroupChat('Plain', members, 'with image', null, [IMG])
+    await settle(room, 'Plain')
+
+    expect(room.gateway.attaches).toHaveLength(2)
+
+    // The image already sits behind every member's watermark.
+    room.rounds.sendToGroupChat('Plain', members, 'plain follow-up')
+    await settle(room, 'Plain')
+
+    expect(room.gateway.attaches).toHaveLength(2)
+  })
+
+  it('skips an invalid attachment and still runs the member turn text-only', async () => {
+    const room = await loadRoom()
+
+    room.rounds.sendToGroupChat(
+      'Degraded',
+      [
+        { name: 'research', title: '' },
+        { name: 'builder', title: '' }
+      ],
+      'look',
+      null,
+      [{ data: null, name: 'bad' } as unknown as Attachment]
+    )
+    await settle(room, 'Degraded')
+
+    expect(room.gateway.attaches).toHaveLength(0)
+    expect(room.gateway.calls).toHaveLength(2)
+  })
+
+  it('routes PDFs through pdf.attach and files through file.attach, per member', async () => {
+    const room = await loadRoom()
+    const pdf: Attachment = { data: 'data:application/pdf;base64,JVBERi0=', kind: 'pdf', name: 'spec.pdf' }
+    const doc: Attachment = { data: 'data:text/plain;base64,aGVsbG8=', kind: 'file', name: 'notes.txt' }
+
+    room.rounds.sendToGroupChat(
+      'Mixed',
+      [
+        { name: 'research', title: '' },
+        { name: 'builder', title: '' }
+      ],
+      'review these',
+      null,
+      [IMG, pdf, doc]
+    )
+    await settle(room, 'Mixed')
+
+    const byMethod: Record<string, number> = {}
+
+    for (const attach of room.gateway.attaches) {
+      byMethod[attach.method] = (byMethod[attach.method] || 0) + 1
+    }
+
+    // 3 attachments × 2 members, each via its own RPC.
+    expect(room.gateway.attaches).toHaveLength(6)
+    expect(byMethod).toEqual({ 'file.attach': 2, 'image.attach_bytes': 2, 'pdf.attach': 2 })
+
+    const staged = room.gateway.attaches.find(attach => attach.method === 'pdf.attach')
+
+    expect(staged?.filename).toBe('spec.pdf')
+    expect(staged?.data).toBe(pdf.data)
+  })
+
+  it('appends the file.attach ref_text to the member turn prompt', async () => {
+    const room = await loadRoom()
+    const doc: Attachment = { data: 'data:text/plain;base64,aGVsbG8=', kind: 'file', name: 'notes.txt' }
+
+    room.rounds.sendToGroupChat(
+      'Refs',
+      [
+        { name: 'research', title: '' },
+        { name: 'builder', title: '' }
+      ],
+      'read the notes',
+      null,
+      [doc]
+    )
+    await settle(room, 'Refs')
+
+    expect(room.gateway.calls).toHaveLength(2)
+
+    for (const call of room.gateway.calls) {
+      expect(call.prompt).toContain('Attached files staged in your session workspace:')
+      expect(call.prompt).toContain('notes.txt → @file:attachments/notes.txt')
+    }
+  })
+
+  it('names attachments in the transcript line, labelling PDFs and files distinctly', async () => {
+    const { rounds } = await loadRoom()
+    const pdf: Attachment = { data: 'data:application/pdf;base64,JVBERi0=', kind: 'pdf', name: 'spec.pdf' }
+    const doc: Attachment = { data: 'data:text/plain;base64,aGVsbG8=', kind: 'file', name: 'notes.txt' }
+    const line = (entry: Partial<GroupMessage>) => rounds.formatGroupChatLine(entry as GroupMessage, 'research')
+
+    expect(line({ from: { kind: 'user', name: 'You' }, images: [IMG], text: 'see attached' })).toBe(
+      'You (user): see attached [attached image: screenshot.png]'
+    )
+    expect(line({ from: { kind: 'user', name: 'You' }, text: 'plain' })).toBe('You (user): plain')
+    expect(
+      line({
+        from: { kind: 'member', name: 'builder' },
+        images: [{ data: 'data:image/png;base64,x' } as Attachment],
+        text: 'made this'
+      })
+    ).toBe('builder: made this [attached image: image]')
+    expect(line({ from: { kind: 'user', name: 'You' }, images: [pdf, doc, IMG], text: 'here' })).toBe(
+      'You (user): here [attached PDF: spec.pdf] [attached file: notes.txt] [attached image: screenshot.png]'
+    )
+  })
+})
+
+// #93129: a bot told to stop must STAY stopped.
+describe('member holds (#93129)', () => {
+  it('holds the mentioned member on an explicit stop', async () => {
+    const { rounds } = await loadRoom()
+
+    for (const text of ['stop @impl', '@impl stop', '@impl please halt', 'pause @impl for now']) {
+      const action = rounds.classifyGroupHoldDirective(text, ['impl'], false)
+
+      expect([...action.hold]).toEqual(['impl'])
+      expect([...action.release]).toEqual([])
+    }
+  })
+
+  it('holds nobody when a stop word carries no mention', async () => {
+    const { rounds } = await loadRoom()
+
+    expect([...rounds.classifyGroupHoldDirective('stop', [], false).hold]).toEqual([])
+  })
+
+  it('still holds on "don\'t stop @x" — the documented conservative trade-off', async () => {
+    const { rounds } = await loadRoom()
+
+    expect([...rounds.classifyGroupHoldDirective("don't stop @impl", ['impl'], false).hold]).toEqual(['impl'])
+  })
+
+  it('does not trigger on "stop" inside another word', async () => {
+    const { rounds } = await loadRoom()
+
+    // \b(stop|halt|pause)\b — "unstoppable" is a different token.
+    const action = rounds.classifyGroupHoldDirective('@impl unstoppable work ahead', ['impl'], false)
+
+    expect([...action.hold]).toEqual([])
+    // A plain non-stop mention releases instead (direct address overrides hold).
+    expect([...action.release]).toEqual(['impl'])
+  })
+
+  it('sets a hold on stop and clears it on resume for the same member', async () => {
+    const { rounds } = await loadRoom()
+    const stamp = { at: 1000, byMessageId: 'm1', thread: 't1' }
+
+    const held = rounds.applyGroupHoldDirective({}, { everyone: false, mentioned: ['impl'] }, 'stop @impl', stamp)
+
+    expect(held.impl).toBeTruthy()
+    expect(held.impl.at).toBe(1000)
+    expect(
+      rounds.applyGroupHoldDirective(held, { everyone: false, mentioned: ['impl'] }, '@impl resume', stamp).impl
+    ).toBeUndefined()
+  })
+
+  it('releases a held member on a direct non-stop mention', async () => {
+    const { rounds } = await loadRoom()
+
+    const next = rounds.applyGroupHoldDirective(
+      { impl: { at: 1, byMessageId: null, thread: null } },
+      { everyone: false, mentioned: ['impl'] },
+      '@impl what is your status?',
+      {}
+    )
+
+    expect(next.impl).toBeUndefined()
+  })
+
+  it('releases every hold on @all resume and sets every hold on @all stop', async () => {
+    const { rounds } = await loadRoom()
+
+    expect(
+      rounds.applyGroupHoldDirective(
+        { docs: { at: 2 }, impl: { at: 1 } },
+        { everyone: true, mentioned: [] },
+        '@all resume',
+        {}
+      )
+    ).toEqual({})
+
+    const held = rounds.applyGroupHoldDirective({}, { everyone: true, mentioned: [] }, '@all stop', { at: 5 }, [
+      'impl',
+      'docs'
+    ])
+
+    expect(held.impl).toBeTruthy()
+    expect(held.docs).toBeTruthy()
+    expect(held.impl.at).toBe(5)
+  })
+
+  it('leaves holds untouched on an unrelated room message', async () => {
+    const { rounds } = await loadRoom()
+    const held = { impl: { at: 1 } }
+
+    expect(rounds.applyGroupHoldDirective(held, { everyone: false, mentioned: [] }, 'receipt round complete', {})).toBe(
+      held
+    )
+  })
+
+  it("does not disturb another member's hold", async () => {
+    const { rounds } = await loadRoom()
+
+    const next = rounds.applyGroupHoldDirective(
+      { impl: { at: 1 } },
+      { everyone: false, mentioned: ['docs'] },
+      'stop @docs',
+      {
+        at: 2
+      }
+    )
+
+    expect(next.impl).toBeTruthy()
+    expect(next.docs).toBeTruthy()
+  })
+
+  it('consumes a held skip exactly once so the loop cannot spin', async () => {
+    const { rounds } = await loadRoom()
+
+    // Fresh delta → advance to log length.
+    expect(rounds.heldMemberWatermarkAdvance(3, 7)).toBe(7)
+    // Already consumed → no write, no spin.
+    expect(rounds.heldMemberWatermarkAdvance(7, 7)).toBeNull()
+    expect(rounds.heldMemberWatermarkAdvance(9, 7)).toBeNull()
+    // Unset watermark treated as 0.
+    expect(rounds.heldMemberWatermarkAdvance(undefined, 2)).toBe(2)
+  })
+})
+
+// #91868/#94569: a REAL stop path for group-chat rounds. Before
+// stopGroupThread the loop's only cancellation primitives were the epoch bump
+// (checked at member boundaries only) and #93129 holds (which skip FUTURE
+// turns) — the plugin issued ZERO session.interrupt RPCs, so "stop" meant
+// "wait for the in-flight member to finish its whole model turn".
+describe('stopGroupThread (#91868/#94569)', () => {
+  const STOP_MEMBERS: GroupMember[] = [
+    { name: 'alpha', title: '' },
+    { name: 'beta', title: '' },
+    { name: 'gamma', title: '' }
+  ]
+
+  /** Seed a room mid-round: epoch 3, running, alpha on turn with a live
+   *  session id, nobody held yet. */
+  function seedRoom(room: Room, turn: null | string = 'alpha') {
+    room.chat.$groupChats.set({
+      Room: {
+        epoch: 3,
+        holds: {},
+        log: [],
+        members: STOP_MEMBERS,
+        running: true,
+        sessions: { alpha: 'live-alpha-sid' },
+        turn,
+        watermarks: {}
+      }
+    } as unknown as Record<string, GroupChat>)
+  }
+
+  it('bumps the epoch, clears running/turn, and holds every member', async () => {
+    const room = await loadRoom()
+    seedRoom(room)
+
+    await room.rounds.stopGroupThread('Room', 't1', STOP_MEMBERS)
+
+    const state = room.chat.$groupChats.get().Room
+
+    expect(state.epoch).toBe(4)
+    expect(state.running).toBe(false)
+    expect(state.turn).toBeNull()
+
+    for (const member of STOP_MEMBERS) {
+      expect(state.holds?.[member.name]).toBeTruthy()
+      expect(state.holds?.[member.name].thread).toBe('t1')
+    }
+  })
+
+  it('interrupts the member ON TURN via its live session', async () => {
+    const room = await loadRoom()
+    seedRoom(room)
+
+    await room.rounds.stopGroupThread('Room', 't1', STOP_MEMBERS)
+
+    const interrupts = room.gateway.rpcFor('session.interrupt')
+
+    // Exactly one — the serial loop has one member in flight.
+    expect(interrupts).toHaveLength(1)
+    expect(interrupts[0].params.session_id).toBe('live-alpha-sid')
+  })
+
+  it('stops a room with nobody on turn without any interrupt RPC', async () => {
+    const room = await loadRoom()
+    seedRoom(room, null)
+
+    await room.rounds.stopGroupThread('Room', 't1', STOP_MEMBERS)
+
+    expect(room.gateway.rpcFor('session.interrupt')).toHaveLength(0)
+    expect(room.chat.$groupChats.get().Room.running).toBe(false)
+    expect(room.chat.$groupChats.get().Room.epoch).toBe(4)
+  })
+
+  it('records a stopped activity event visible in the CURRENT run', async () => {
+    const room = await loadRoom()
+    seedRoom(room)
+
+    await room.rounds.stopGroupThread('Room', 't1', STOP_MEMBERS)
+
+    const stopped = room.activity.currentGroupActivity('Room').find(event => event.kind === 'stopped')
+
+    // Tagged with the POST-bump epoch, so it survives the epoch filter.
+    expect(stopped).toBeTruthy()
+    expect(stopped?.member).toBe('You')
+    expect(stopped?.thread).toBe('t1')
+    // The label comes from the shared activity label map and stays plain
+    // English — no hardcoded localized text (the #94570 shell shipped a 停止).
+    expect(room.activity.groupActivityLabel(stopped!)).toBeTruthy()
+    expect(room.activity.groupActivityLabel(stopped!)).not.toMatch(/[\u4e00-\u9fff]/)
+    expect(room.activity.GROUP_ACTIVITY_GLYPHS.stopped).toBeTruthy()
+  })
+
+  it('falls back to the durable room roster when called without members', async () => {
+    const room = await loadRoom()
+    seedRoom(room)
+
+    await room.rounds.stopGroupThread('Room', 't1')
+
+    expect(Object.keys(room.chat.$groupChats.get().Room.holds || {})).toHaveLength(STOP_MEMBERS.length)
+    expect(room.gateway.rpcFor('session.interrupt')).toHaveLength(1)
+  })
+
+  it('abandons an in-flight turn once a stop bumps the epoch and holds the member', async () => {
+    let live: Room | null = null
+
+    const room = await loadRoom({
+      onResumePoll: polls => {
+        // Fire the stop from inside the poll cadence, after the second busy
+        // poll — exactly the mid-turn click the Stop button produces.
+        if (polls === 2) {
+          void live?.rounds.stopGroupThread('Room', 't1', [{ name: 'helper', title: '' }])
+        }
+      },
+      pollsBusy: 50,
+      turn: () => 'long answer'
+    })
+
+    live = room
+
+    const reply = await room.turns.runGroupChatMemberTurn('Room', { name: 'helper', title: '' }, 'long task', 't1', [])
+
+    expect(reply).toBeNull()
+    // The poll loop exited promptly after the stop, not at the deadline.
+    expect(room.gateway.rpcFor('session.resume').length).toBeLessThanOrEqual(6)
+    expect(room.chat.$groupChats.get().Room.running).toBe(false)
+  })
+
+  it('keeps polling through an ordinary newer-send epoch bump so late work still lands', async () => {
+    let live: Room | null = null
+
+    const room = await loadRoom({
+      onResumePoll: polls => {
+        if (polls === 1) {
+          // A newer user send bumps the epoch but holds nobody. The in-flight
+          // poll must keep going so the finished reply can still be delivered
+          // (the #93127 commit check decides its fate at the boundary).
+          live?.chat.updateGroupChat('Room', current => {
+            current.epoch = (current.epoch || 0) + 1
+
+            return current
+          })
+        }
+      },
+      pollsBusy: 3,
+      turn: () => 'finished anyway'
+    })
+
+    live = room
+
+    const reply = await room.turns.runGroupChatMemberTurn('Room', { name: 'helper', title: '' }, 'long task', 't1', [])
+
+    expect(reply).toBe('finished anyway')
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-rounds.ts b/apps/desktop/src/plugins/hermes-bots/group-rounds.ts
new file mode 100644
index 000000000000..ff65ff2745f1
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-rounds.ts
@@ -0,0 +1,1052 @@
+/**
+ * Room-level coordination: who speaks, in what order, for how long — the
+ * @mention parse, the round-robin driver, the #93129 member holds, the stop
+ * path, and the user send that starts it all.
+ */
+
+import { botFriendlyNames, botHandle, clearBotAttention, mentionNameForms, noteBotAttention } from './data'
+import { recordGroupActivity } from './group-activity'
+import {
+  $groupChats,
+  $groupNeedsYou,
+  appendGroupChatEntry,
+  GROUP_CHAT_HISTORY_LIMIT,
+  GROUP_CHAT_MAX_CONTINUATIONS,
+  GROUP_CHAT_MAX_MESSAGES,
+  GROUP_CHAT_MAX_ROUNDS,
+  groupSpeakerLabel,
+  groupThreadOf,
+  mintGroupThreadId,
+  shouldCommitMemberTurn,
+  updateGroupChat
+} from './group-chat'
+import type { GroupChatRoom, GroupHoldStamp } from './group-chat'
+import { durableGroupChatMembers, groupMemberKey } from './group-membership'
+import { harvestStrandedGroupReply, isGroupPassText, runGroupChatMemberTurn } from './group-turns'
+import { requestForBot } from './routing'
+import type { Attachment, GroupMember, GroupMessage } from './types'
+
+// ── group chats: bounded round-robin coordination over a shared room log ─────
+//
+// Behavioral model (clean-room): a group conversation is ONE ordered room log
+// owned by the plugin. A user send triggers at most GROUP_CHAT_MAX_ROUNDS
+// serial round-robin rounds over the member roster — never parallel, no LLM
+// router. Who speaks each round is a deterministic @mention parse since the
+// last user message (mentioned members only, else everyone); whether a member
+// actually speaks is its own turn's choice — replying with exactly "(pass)"
+// (or nothing, or failing) is silence. Hard caps end every turn; a round in
+// which everyone passed means the conversation settled. Each member runs its
+// turn in its OWN persistent per-group Hermes session and is fed only the
+// room messages that are NEW since it last saw the room.
+
+/** Deterministic @mention parse. Handles @name, @"two words" via display
+ *  titles, and @everyone/@all. Names match case-insensitively against member
+ *  profile names, display titles, and collapsed no-space forms. */
+export function parseGroupChatMentions(text: unknown, members: GroupMember[]) {
+  const source = String(text || '')
+  const mentioned = new Set<string>()
+  let everyone = false
+  const handles = new Map<string, string>()
+
+  for (const member of members) {
+    const title = String(member.title || '').trim()
+    // Cross-connection members are also addressable by their @name-device
+    // handle (the roster's disambiguated form) — same-named agents on two
+    // machines resolve to the right one.
+    const handle = String(member.handle || botHandle(member.name, member) || '').trim()
+
+    const forms = new Set([
+      member.name.toLowerCase(),
+      member.name.toLowerCase().replace(/[\s_-]+/g, ''),
+      ...(handle ? [handle.toLowerCase(), handle.toLowerCase().replace(/[\s_-]+/g, '')] : []),
+      ...(title
+        ? [title.toLowerCase(), title.toLowerCase().replace(/[\s_-]+/g, ''), title.split(/\s+/)[0].toLowerCase()]
+        : [])
+    ])
+
+    // Renamed members answer to their friendly names too (profile
+    // display_name and Bot Mode title), in slugged and collapsed forms —
+    // the same tags the roster autocomplete inserts.
+    for (const friendly of botFriendlyNames(member)) {
+      for (const form of mentionNameForms(friendly)) {
+        forms.add(form)
+      }
+    }
+
+    for (const form of forms) {
+      if (form) {
+        handles.set(form, groupMemberKey(member))
+      }
+    }
+  }
+
+  for (const match of source.matchAll(/@([a-z0-9][a-z0-9._-]*)/gi)) {
+    const handle = match[1].toLowerCase()
+
+    if (handle === 'everyone' || handle === 'all') {
+      everyone = true
+
+      continue
+    }
+
+    if (handle === 'user') {
+      continue
+    }
+
+    const resolved = handles.get(handle) || handles.get(handle.replace(/[._-]+/g, ''))
+
+    if (resolved) {
+      mentioned.add(resolved)
+    }
+  }
+
+  return {
+    everyone,
+    mentioned
+  }
+}
+
+/** Members that should take a turn this round: everyone when no member is
+ *  @-mentioned in messages since the last user entry (or @everyone appears),
+ *  otherwise only the mentioned members. Recomputed every round so a member
+ *  pulled in mid-conversation joins the next round. */
+export function resolveGroupResponders(log: GroupMessage[], members: GroupMember[]) {
+  let sinceLastUser: GroupMessage[] = []
+
+  for (let i = log.length - 1; i >= 0; i--) {
+    if (log[i].from.kind === 'user') {
+      sinceLastUser = log.slice(i)
+
+      break
+    }
+  }
+
+  const mentioned = new Set<string>()
+  let everyone = false
+
+  for (const entry of sinceLastUser) {
+    const parsed = parseGroupChatMentions(entry.text, members)
+
+    if (parsed.everyone) {
+      everyone = true
+    }
+
+    for (const name of parsed.mentioned) {
+      mentioned.add(name)
+    }
+  }
+
+  if (everyone || mentioned.size === 0) {
+    return members
+  }
+
+  return members.filter(member => mentioned.has(groupMemberKey(member)))
+}
+
+/** Rotate the roster so a different member leads each round. */
+export function rotateGroupSpeakers(members: GroupMember[], round: number) {
+  if (members.length < 2) {
+    return members
+  }
+
+  const shift = round % members.length
+
+  return [...members.slice(shift), ...members.slice(0, shift)]
+}
+
+/** Room-log line as a member sees it: `Name (user): …` / `Name: …` /
+ *  `Name (you): …`. */
+export function formatGroupChatLine(entry: GroupMessage, viewerName: string) {
+  // Attachments are staged into each member's session as real payloads; the
+  // transcript line names them so the delta text and the bytes line up.
+  const attached =
+    Array.isArray(entry.images) && entry.images.length
+      ? ` ${entry.images
+          .map(img => {
+            const label = img.kind === 'pdf' ? 'attached PDF' : img.kind === 'file' ? 'attached file' : 'attached image'
+
+            return `[${label}: ${img.name || 'image'}]`
+          })
+          .join(' ')}`
+      : ''
+
+  if (entry.from.kind === 'user') {
+    return `${entry.from.name || 'User'} (user): ${entry.text}${attached}`
+  }
+
+  const suffix = entry.from.name === viewerName ? ' (you)' : ''
+  // Cross-connection speakers carry their device so same-named agents on
+  // two machines stay tellable apart in every member's transcript.
+  const source = entry.from.source ? ` [${entry.from.source}]` : ''
+
+  return `${groupSpeakerLabel(entry.from.name)}${suffix}${source}: ${entry.text}${attached}`
+}
+
+interface GroupChatTurnPromptInput {
+  deltaLines: string[]
+  groupName: string
+  members: GroupMember[]
+  viewer: GroupMember
+}
+
+/** The full per-turn payload for one member: participation rules + the room
+ *  delta. Rules travel in the turn payload (not SOUL) so every existing bot
+ *  can join a group chat without a profile migration. */
+export function buildGroupChatTurnPrompt({ groupName, members, viewer, deltaLines }: GroupChatTurnPromptInput) {
+  const viewerKey = groupMemberKey(viewer)
+  const peers = members.filter(m => groupMemberKey(m) !== viewerKey)
+
+  const peerNames = peers
+    .map(m => {
+      const handle = m.title ? `${m.title} (@${botHandle(m.name, m)})` : `@${botHandle(m.name, m)}`
+
+      return m.remoteSource ? `${handle} [on ${m.connectionLabel || m.connectionId}]` : handle
+    })
+    .join(', ')
+
+  return [
+    `[Group chat: "${groupName}"] You are @${botHandle(viewer.name, viewer)}, one participant in a group chat with ${peerNames || 'no one else yet'} and the user.`,
+    '',
+    'New messages in the room since your last turn (oldest first):',
+    ...deltaLines.map(line => `  ${line}`),
+    '',
+    'Rules for this room:',
+    '- Reply with ONE conversational message ONLY if you have something new worth adding: build on what was just said, claim or hand off work, answer a question aimed at you, or report a real result. Keep chatter short (1-3 sentences) — but when you are delivering a result, an answer the user asked for, or substantive work, give it at full quality and length; never thin out real content to fit the room.',
+    '- If you have nothing new to add, reply with exactly "(pass)". Passing is good — it lets the conversation settle.',
+    '- Mention a teammate as @name to pull them in; mention @user only for a judgment call or a result the user needs. Do not repeat points already made.',
+    '- Never reveal content from your private 1:1 chats. Your reply text goes to the room verbatim — no preamble, no meta-commentary.'
+  ].join('\n')
+}
+
+// --- member-hold helpers (#93129) — pure, unit-tested ---
+
+/** #93129: classify a USER room message's effect on member holds. Only user
+ *  sends ever reach this (bot replies are appended by the round loop, never
+ *  through sendToGroupChat), so a bot saying "stopped working on it" can
+ *  never set a hold. Conservative on purpose: any standalone stop/halt/pause
+ *  word next to a mention holds those members — "don't stop @x" therefore
+ *  also holds, which errs toward the bot staying quiet until re-addressed
+ *  (a wrongly-held bot is one mention away from release; a wrongly-running
+ *  one keeps doing work it was told to stop). A non-stop direct mention
+ *  releases the mentioned members — the user addressing a bot directly
+ *  overrides its hold. */
+export function classifyGroupHoldDirective(
+  text: string,
+  mentionedKeys: Iterable<string> | null | undefined,
+  everyone: boolean
+) {
+  const value = String(text || '')
+  const mentioned = [...(mentionedKeys || [])]
+  const stop = /\b(stop|halt|pause)\b/i.test(value)
+  const resume = /\b(resume|continue|go|proceed)\b/i.test(value)
+
+  if (stop) {
+    // "@all stop" holds every member — symmetric with "@all resume".
+    return {
+      hold: mentioned,
+      holdAll: Boolean(everyone),
+      release: [],
+      releaseAll: false
+    }
+  }
+
+  if (resume) {
+    return {
+      hold: [],
+      holdAll: false,
+      release: mentioned,
+      releaseAll: Boolean(everyone)
+    }
+  }
+
+  return {
+    hold: [],
+    holdAll: false,
+    release: mentioned,
+    releaseAll: false
+  }
+}
+
+/** What `parseGroupChatMentions` reports for one room message. */
+interface GroupMentionParse {
+  everyone?: boolean
+  mentioned?: Iterable<string>
+}
+
+/** #93129: next holds map after one user message. Holds are keyed by
+ *  memberKey at ROOM scope (not thread scope): every main-composer send
+ *  mints a NEW thread, so a thread-scoped hold would never block the next
+ *  send's turns and the stop would not stick. Returns the same object when
+ *  nothing changed. */
+export function applyGroupHoldDirective(
+  holds: Record<string, GroupHoldStamp> | null | undefined,
+  mentions: GroupMentionParse | null | undefined,
+  text: string,
+  stamp: GroupHoldStamp | null | undefined,
+  allMemberKeys: string[] = []
+): Record<string, GroupHoldStamp> {
+  const prior: Record<string, GroupHoldStamp> = holds && typeof holds === 'object' ? holds : {}
+  const action = classifyGroupHoldDirective(text, mentions?.mentioned || [], Boolean(mentions?.everyone))
+
+  if (action.releaseAll) {
+    return Object.keys(prior).length ? {} : prior
+  }
+
+  // "@all stop": expand to every member key the caller knows about.
+  const toHold = action.holdAll ? [...allMemberKeys] : action.hold
+  let next = prior
+
+  for (const key of toHold) {
+    if (next === prior) {
+      next = {
+        ...prior
+      }
+    }
+
+    next[key] = {
+      at: stamp?.at || Date.now(),
+      byMessageId: stamp?.byMessageId || null,
+      thread: stamp?.thread || null
+    }
+  }
+
+  for (const key of action.release) {
+    if (Object.prototype.hasOwnProperty.call(next, key)) {
+      if (next === prior) {
+        next = {
+          ...prior
+        }
+      }
+
+      delete next[key]
+    }
+  }
+
+  return next
+}
+
+/** #93129: a held member's skip must consume its delta exactly once —
+ *  advance the watermark past the current log so the same entries never
+ *  re-trigger the skip. Null = nothing to consume (no write, no spin). */
+export function heldMemberWatermarkAdvance(seen: number | undefined, logLength: number): null | number {
+  return logLength > (seen || 0) ? logLength : null
+}
+
+// --- end member-hold helpers ---
+
+/** Members cited by @mention in a thread who have not posted any entry after
+ *  the citing one — the unresolved-handoff detector for #94478. A mention
+ *  inside a member reply is visible to the NEXT round's responder selection,
+ *  but the round loop exits first when nobody has new delta to read
+ *  (`spokeThisRound === 0`) or a cap lands, so the room settles while a
+ *  called bot never answers. Returns member keys still owed a turn. */
+export function unaddressedGroupMentions(group: string, members: GroupMember[], thread: string) {
+  const room = $groupChats.get()[group] || {
+    log: []
+  }
+
+  const log = (room.log || []).filter((e: GroupMessage) => groupThreadOf(e) === thread)
+
+  // key → log INDEX of the entry that most recently cited this member.
+  // Entry ids are UUIDs (groupChatEntryId), NOT monotonic — index order is
+  // the only guaranteed ordering, and it is what "answered after the citing
+  // entry" actually means. (#94478 review)
+  const citedAt = new Map()
+
+  for (const entry of log) {
+    const parsed = parseGroupChatMentions(entry.text || '', members)
+
+    // A user send re-drives everyone anyway; only member-to-member handoffs
+    // can strand here.
+    if (entry.from.kind !== 'member') {
+      continue
+    }
+
+    for (const key of parsed.mentioned) {
+      const citingMemberKey = (() => {
+        const m = members.find((mm: GroupMember) => mm.name === entry.from?.name)
+
+        return m ? groupMemberKey(m) : null
+      })()
+
+      // Never count a bot citing itself as a pending handoff.
+      if (citingMemberKey && citingMemberKey !== key) {
+        citedAt.set(key, log.indexOf(entry))
+      }
+    }
+  }
+
+  // A citation is answered when the cited member posts any entry after the
+  // citing one (its turn, whatever the content).
+  const lastPostAt = new Map()
+
+  for (const entry of log) {
+    if (entry.from.kind !== 'member') {
+      continue
+    }
+
+    const speakerKey = (() => {
+      const m = members.find((mm: GroupMember) => mm.name === entry.from?.name)
+
+      return m ? groupMemberKey(m) : null
+    })()
+
+    if (speakerKey) {
+      lastPostAt.set(speakerKey, log.indexOf(entry))
+    }
+  }
+
+  return [...citedAt.keys()].filter(key => {
+    const citedIdx = citedAt.get(key)
+    const answeredIdx = lastPostAt.get(key)
+
+    return answeredIdx === undefined || answeredIdx <= citedIdx
+  })
+}
+
+/** #91868/#94569: the REAL stop path for a group round. The round loop's only
+ *  cancellation primitives were the epoch bump (checked at member boundaries)
+ *  and #93129 holds (skip FUTURE turns) — neither touches the member whose
+ *  model call is in flight RIGHT NOW, so "stop" meant "finish this turn
+ *  first". This primitive does all three legs atomically enough to matter:
+ *
+ *  1. Bumps the room epoch — the driving loop bails at its next boundary and
+ *     never selects another member (`isCurrent()` in runGroupChatRounds).
+ *  2. Sets a #93129 hold for EVERY member — future turns stay skipped until
+ *     the user explicitly releases (resume / @all resume / direct mention),
+ *     the exact contract user-typed "@all stop" already has.
+ *  3. Sends session.interrupt to the member currently ON TURN (room.turn,
+ *     runtime-only) via its own route, so the in-flight model call actually
+ *     dies instead of grinding to completion in the background. Best-effort:
+ *     an unreachable member still leaves the room stopped — the poll loop's
+ *     staleness check (epoch moved AND member held) abandons the turn.
+ *
+ *  `members` is the live roster when the caller has one (the workspace);
+ *  falls back to the room's durable roster so a two-arg call still works. */
+export async function stopGroupThread(group: string, thread: null | string, members: GroupMember[] | null = null) {
+  const room = $groupChats.get()[group] || {}
+  const roster = Array.isArray(members) && members.length ? members : room.members || []
+  const turnName = room.turn || null
+
+  const stamp: GroupHoldStamp = {
+    at: Date.now(),
+    byMessageId: null,
+    thread: thread || null
+  }
+
+  updateGroupChat(group, (r: GroupChatRoom) => {
+    r.epoch = (r.epoch || 0) + 1
+    r.running = false
+    r.turn = null
+
+    // Same hold shape applyGroupHoldDirective mints for "@all stop" — the
+    // held-skip path (watermark consume + 'held' activity note) and every
+    // release gesture apply unchanged. An existing hold keeps its stamp.
+    const holds: Record<string, GroupHoldStamp> = {
+      ...(r.holds || {})
+    }
+
+    for (const member of roster) {
+      const key = groupMemberKey(member)
+
+      if (key && !holds[key]) {
+        holds[key] = {
+          ...stamp
+        }
+      }
+    }
+
+    r.holds = holds
+
+    return r
+  })
+
+  // Recorded AFTER the bump so the event is tagged with the new epoch — it
+  // stays visible as the current run's outcome instead of dropping out of
+  // view with the superseded run's events.
+  recordGroupActivity(group, {
+    kind: 'stopped',
+    member: 'You',
+    thread: thread || null
+  })
+
+  // Interrupt the member actually mid-turn. room.turn is runtime-only and
+  // names exactly one member (the loop is serial); a settled room has none.
+  const onTurn = turnName ? roster.find((member: GroupMember) => member?.name === turnName) : null
+  const sessionId = onTurn ? (room.sessions || {})[groupMemberKey(onTurn)] : null
+
+  if (onTurn && sessionId) {
+    try {
+      await requestForBot(onTurn, 'session.interrupt', {
+        session_id: sessionId
+      })
+    } catch {
+      /* best-effort — the epoch/hold legs above already stopped the room;
+         the abandoned poll loop exits on its staleness check */
+    }
+  }
+}
+
+/** Drive one bounded round-robin turn for ONE THREAD. Serial — one member at
+ *  a time. A newer user send bumps the room epoch; this loop notices at the
+ *  next member boundary, bails, and the newest send's own loop takes over.
+ *  Watermarks are per thread+member (`${thread}::${memberKey}`), so parallel
+ *  topics never eat each other's deltas. */
+export async function runGroupChatRounds(group: string, members: GroupMember[], thread: string) {
+  const startEpoch = ($groupChats.get()[group] || {}).epoch || 0
+  const isCurrent = () => (($groupChats.get()[group] || {}).epoch || 0) === startEpoch
+  let posted = 0
+  let continuations = 0
+  // #94478: how this drive ended. 'settled' means quiet consensus (everyone
+  // passed with nothing pending); 'capped' means a round/message/continuation
+  // cap forced the exit — the activity feed must tell those apart.
+  let exitKind: 'capped' | 'settled' = 'settled'
+
+  try {
+    for (let round = 0; round < GROUP_CHAT_MAX_ROUNDS; round++) {
+      // Deliver any replies that finished after their turn timed out —
+      // every member, not just this round's responders, so long work is
+      // late, never lost.
+      for (const member of members) {
+        if (!isCurrent()) {
+          recordGroupActivity(group, {
+            kind: 'cancelled',
+            member: null,
+            thread
+          })
+
+          return
+        }
+
+        await harvestStrandedGroupReply(group, member)
+      }
+
+      const roomLog = (($groupChats.get()[group] || {}).log || []).filter(
+        (e: GroupMessage) => groupThreadOf(e) === thread
+      )
+
+      // Exclude members the harvest pass just above confirmed are STILL
+      // running (their stranded marker survived harvest because
+      // state.inflight/running was true). Re-selecting one here would
+      // prompt.submit into their live session — the gateway's default busy
+      // policy redirects or hard-interrupts that turn (tui_gateway's
+      // _handle_busy_submit), killing exactly the long-running work this
+      // stranded/harvest mechanism exists to protect. Skip them; the next
+      // harvest pass picks the reply up once it actually lands. A marker's
+      // mere presence means "still stranded" (harvestStrandedGroupReply
+      // deletes it once the member is confirmed done/dead) — presence, not
+      // value shape, since markers are a bare number pre-thread or
+      // {before, thread} post-thread.
+      const strandedNow = ($groupChats.get()[group] || {}).stranded || {}
+
+      const responders = rotateGroupSpeakers(resolveGroupResponders(roomLog, members), round).filter(
+        (member: GroupMember) => !Object.prototype.hasOwnProperty.call(strandedNow, groupMemberKey(member))
+      )
+
+      let spokeThisRound = 0
+
+      for (const member of responders) {
+        if (!isCurrent() || posted >= GROUP_CHAT_MAX_MESSAGES) {
+          if (!isCurrent()) {
+            recordGroupActivity(group, {
+              kind: 'cancelled',
+              member: null,
+              thread
+            })
+          } else {
+            exitKind = 'capped' // message cap, not consensus (#94478)
+          }
+
+          return
+        }
+
+        const room = $groupChats.get()[group] || {
+          log: [],
+          watermarks: {}
+        }
+
+        const memberKey = groupMemberKey(member)
+        const markKey = `${thread}::${memberKey}`
+        const seen = room.watermarks[markKey] || 0
+        // Delta: NEW room entries, narrowed to this thread — the member's
+        // turn sees only the conversation it's part of.
+        const delta = room.log.slice(seen).filter((e: GroupMessage) => groupThreadOf(e) === thread)
+
+        if (!delta.length) {
+          continue
+        }
+
+        // #93129: a member the user told to stop is HELD — no turn until an
+        // explicit release (resume / @all resume / a direct non-stop
+        // mention). Consume the delta exactly once (watermark past the
+        // current log) so the same entries never re-trigger this skip, and
+        // surface WHY the bot is silent in the activity feed the first time.
+        const heldEntry = (room.holds || {})[memberKey]
+
+        if (heldEntry) {
+          const advance = heldMemberWatermarkAdvance(seen, room.log.length)
+          updateGroupChat(group, (r: GroupChatRoom) => {
+            if (advance !== null) {
+              r.watermarks[markKey] = advance
+            }
+
+            if (r.holds?.[memberKey] && !r.holds[memberKey].noted) {
+              r.holds = {
+                ...r.holds,
+                [memberKey]: {
+                  ...r.holds[memberKey],
+                  noted: true
+                }
+              }
+            }
+
+            return r
+          })
+
+          if (!heldEntry.noted) {
+            recordGroupActivity(group, {
+              kind: 'held',
+              member: member.name,
+              thread
+            })
+          }
+
+          continue
+        }
+
+        const prompt = buildGroupChatTurnPrompt({
+          groupName: group,
+          members,
+          viewer: member,
+          deltaLines: delta
+            .slice(-GROUP_CHAT_HISTORY_LIMIT)
+            .map((e: GroupMessage) => formatGroupChatLine(e, member.name))
+        })
+
+        // Images riding this delta (user attachments — member entries don't
+        // carry images today, but flatMap keeps this future-proof) get staged
+        // into the member's session so the model sees the pixels, not just
+        // the transcript's [attached image: …] marker.
+        const deltaImages = delta.flatMap((e: GroupMessage) => (Array.isArray(e.images) ? e.images : []))
+
+        // Surface WHO is on turn (runtime-only, like running/epoch) so the
+        // room shows "Radar is thinking…" instead of a generic working line —
+        // long model turns otherwise read as the room being stuck.
+        updateGroupChat(group, (r: GroupChatRoom) => {
+          r.turn = member.name
+
+          return r
+        })
+        let reply: null | string = null
+
+        try {
+          reply = await runGroupChatMemberTurn(group, member, prompt, thread, deltaImages)
+
+          // Needs-attention hook (#93091 item 3): a turn that produced a real
+          // reply (or an explicit pass) is a good turn — clear the badge.
+          // A timed-out turn also returns null but never threw; leaving any
+          // prior badge in place there is the conservative choice.
+          if (reply !== null) {
+            clearBotAttention(groupMemberKey(member))
+          }
+        } catch (error: any) {
+          const reason = String(error?.data?.reason || '').trim()
+          recordGroupActivity(group, {
+            kind: 'failed',
+            member: member.name,
+            thread,
+            ...(reason
+              ? {
+                  reason
+                }
+              : {})
+          })
+          noteBotAttention(groupMemberKey(member), reason || error?.message || error)
+          reply = null // a failed turn is a pass, never a room error
+        }
+
+        // #93127: the turn may have finished AFTER a newer user send bumped
+        // the room epoch. That newer send's loop re-drives this member with
+        // the full delta, so committing this stale result (watermark advance
+        // + append) would double-deliver the same reply. Drop it here —
+        // BEFORE the watermark advance and BEFORE the append. Only a newer
+        // USER entry in THIS thread makes the re-drive premise true: a
+        // cross-thread send bumps the epoch too, but its loop filters this
+        // thread out and would never regenerate the finished reply. The
+        // during-turn tail is anchored by entry id, not index — the history
+        // trim drops entries from the FRONT, so an index slice could
+        // overshoot after a mid-turn trim and silently commit a stale turn.
+        const roomNow = $groupChats.get()[group] || {
+          log: []
+        }
+
+        const epochNow = roomNow.epoch || 0
+        const anchorId = room.log.length ? room.log[room.log.length - 1].id : null
+        const anchorIdx = anchorId === null ? -1 : roomNow.log.findIndex((e: GroupMessage) => e.id === anchorId)
+        // Anchor trimmed away ⇒ every pre-turn entry was dropped, so every
+        // surviving entry is newer — scanning the whole log stays exact.
+        const turnTail = anchorIdx >= 0 ? roomNow.log.slice(anchorIdx + 1) : roomNow.log
+
+        const newerUserEntryInThread = turnTail.some(
+          (e: GroupMessage) => e.from?.kind === 'user' && groupThreadOf(e) === thread
+        )
+
+        if (!shouldCommitMemberTurn(startEpoch, epochNow, newerUserEntryInThread)) {
+          recordGroupActivity(group, {
+            kind: 'cancelled',
+            member: member.name,
+            thread
+          })
+
+          return
+        }
+
+        // The member has now seen everything up to the pre-reply log length.
+        updateGroupChat(group, (r: GroupChatRoom) => {
+          r.watermarks[markKey] = r.log.length
+
+          return r
+        })
+
+        if (reply !== null && !isGroupPassText(reply)) {
+          appendGroupChatEntry(
+            group,
+            {
+              kind: 'member',
+              name: member.name,
+              ...(member.remoteSource
+                ? {
+                    source: member.connectionLabel || member.connectionId
+                  }
+                : {})
+            },
+            reply,
+            thread
+          )
+          // Its own message counts as seen too.
+          updateGroupChat(group, (r: GroupChatRoom) => {
+            r.watermarks[markKey] = r.log.length
+
+            return r
+          })
+          posted += 1
+          spokeThisRound += 1
+        }
+      }
+
+      if (spokeThisRound === 0) {
+        // #94478: "everyone passed" is NOT the only way a round can go quiet —
+        // responders can be narrowed to members with no new delta while the
+        // thread's tail carries an @mention handoff that was never answered.
+        // Before settling, check for cited members still owed a turn and run
+        // one bounded continuation round for exactly those members. If none
+        // exist (or the continuation also goes quiet), the room genuinely
+        // settled.
+        const pendingKeys = unaddressedGroupMentions(group, members, thread)
+
+        // #94478 review: bound continuation rounds independently of the
+        // message cap so a pathological mention chain can't consume the
+        // room's entire budget on back-and-forth handoffs.
+        continuations += 1
+
+        if (pendingKeys.length && continuations <= GROUP_CHAT_MAX_CONTINUATIONS) {
+          const citedMembers = members.filter((member: GroupMember) => pendingKeys.includes(groupMemberKey(member)))
+
+          if (citedMembers.length && posted < GROUP_CHAT_MAX_MESSAGES) {
+            const strandedNow = ($groupChats.get()[group] || {}).stranded || {}
+
+            const continuationResponders = citedMembers.filter(
+              (member: GroupMember) => !Object.prototype.hasOwnProperty.call(strandedNow, groupMemberKey(member))
+            )
+
+            for (const member of continuationResponders) {
+              if (!isCurrent() || posted >= GROUP_CHAT_MAX_MESSAGES || continuations > GROUP_CHAT_MAX_CONTINUATIONS) {
+                break
+              }
+
+              const room = $groupChats.get()[group] || {
+                log: [],
+                watermarks: {}
+              }
+
+              const memberKey = groupMemberKey(member)
+              const markKey = `${thread}::${memberKey}`
+              const seen = room.watermarks[markKey] || 0
+              const delta = room.log.slice(seen).filter((e: GroupMessage) => groupThreadOf(e) === thread)
+
+              // A cited member always has delta here (the citing reply IS in
+              // its tail); skip defensively anyway so an empty prompt never
+              // fires.
+              if (!delta.length) {
+                continue
+              }
+
+              const heldEntry = (room.holds || {})[memberKey]
+
+              if (heldEntry) {
+                continue // holds still apply to continuation turns (#93129)
+              }
+
+              const prompt = buildGroupChatTurnPrompt({
+                groupName: group,
+                members,
+                viewer: member,
+                // The continuation prompt centers on what the member missed:
+                // everything since its watermark, which includes the reply
+                // that cites it.
+                deltaLines: delta
+                  .slice(-GROUP_CHAT_HISTORY_LIMIT)
+                  .map((e: GroupMessage) => formatGroupChatLine(e, member.name))
+              })
+
+              updateGroupChat(group, (r: GroupChatRoom) => {
+                r.turn = member.name
+
+                return r
+              })
+              let continuationReply: null | string = null
+
+              try {
+                continuationReply = await runGroupChatMemberTurn(group, member, prompt, thread)
+
+                if (continuationReply !== null) {
+                  clearBotAttention(memberKey)
+                }
+              } catch (error: any) {
+                recordGroupActivity(group, {
+                  kind: 'failed',
+                  member: member.name,
+                  thread
+                })
+                noteBotAttention(memberKey, error?.message || error)
+                continuationReply = null
+              }
+
+              if (!isCurrent()) {
+                return
+              }
+
+              updateGroupChat(group, (r: GroupChatRoom) => {
+                r.watermarks[markKey] = r.log.length
+
+                return r
+              })
+
+              if (continuationReply !== null && !isGroupPassText(continuationReply)) {
+                appendGroupChatEntry(
+                  group,
+                  {
+                    kind: 'member',
+                    name: member.name,
+                    ...(member.remoteSource
+                      ? {
+                          source: member.connectionLabel || member.connectionId
+                        }
+                      : {})
+                  },
+                  continuationReply,
+                  thread
+                )
+                updateGroupChat(group, (r: GroupChatRoom) => {
+                  r.watermarks[markKey] = r.log.length
+
+                  return r
+                })
+                posted += 1
+
+                // The continuation's own reply may cite someone else — fall
+                // through to the normal loop so the next round handles it via
+                // the same responder machinery. Reaching here means the loop
+                // continues rather than settling; the outer for-loop's next
+                // iteration re-evaluates everything.
+                spokeThisRound += 1
+              }
+            }
+          }
+        }
+
+        if (spokeThisRound === 0) {
+          // Genuinely nothing left to say — including after the continuation
+          // attempt above produced no spoken turns. Settle honestly, but if
+          // cited members are STILL owed a turn and only the continuation /
+          // message caps stopped us from driving them, this is a capped
+          // exit, not consensus. (#94478)
+          if (
+            pendingKeys.length &&
+            (continuations > GROUP_CHAT_MAX_CONTINUATIONS || posted >= GROUP_CHAT_MAX_MESSAGES)
+          ) {
+            exitKind = 'capped'
+          }
+
+          return
+        }
+      }
+    }
+
+    // All GROUP_CHAT_MAX_ROUNDS rounds ran with someone still speaking —
+    // the round cap ended the drive, not consensus. (#94478)
+    exitKind = 'capped'
+  } finally {
+    if (isCurrent()) {
+      recordGroupActivity(group, {
+        kind: exitKind,
+        member: null,
+        thread
+      })
+      updateGroupChat(group, (r: GroupChatRoom) => {
+        r.running = false
+        r.turn = null
+
+        return r
+      })
+
+      // #89545: the loop's harvest pass only ran at the top of each round of
+      // an ACTIVE loop — a member whose turn timed out after the final round
+      // stayed stranded until the user's NEXT send. Poll for the late reply
+      // in the background (bounded) so long work is late, never lost.
+      // (window feature-detect: the engine also runs under node in tests.)
+      const strandedLeft = Object.keys(($groupChats.get()[group] || {}).stranded || {})
+
+      if (strandedLeft.length && typeof window !== 'undefined') {
+        void harvestStrandedUntilSettled(group, members, thread)
+      }
+    }
+  }
+}
+
+/** Bounded background harvest for members whose replies outlived the turn
+ *  loop. Polls every 5s for up to 5 minutes; stops early when nothing is
+ *  stranded, a new loop takes the room over (it harvests on its own), or the
+ *  room record disappears (disband). */
+async function harvestStrandedUntilSettled(group: string, members: GroupMember[], thread: string) {
+  const HARVEST_INTERVAL_MS = 5000
+  const HARVEST_MAX_TRIES = 60
+
+  for (let attempt = 0; attempt < HARVEST_MAX_TRIES; attempt++) {
+    await new Promise(resolve => window.setTimeout(resolve, HARVEST_INTERVAL_MS))
+    const room = $groupChats.get()[group]
+
+    if (!room || room.running) {
+      return
+    }
+
+    const stranded = room.stranded || {}
+
+    if (!Object.keys(stranded).length) {
+      return
+    }
+
+    for (const member of members) {
+      if (Object.prototype.hasOwnProperty.call(stranded, groupMemberKey(member))) {
+        try {
+          await harvestStrandedGroupReply(group, member)
+        } catch {
+          // Best-effort: the next tick retries; the bound stops runaways.
+        }
+      }
+    }
+  }
+
+  recordGroupActivity(group, {
+    kind: 'failed',
+    member: null,
+    thread
+  })
+}
+
+/** User send into a group room. `thread` continues that thread (its reply
+ *  box); omitted/null mints a NEW thread — the main composer's Slack shape.
+ *  Appends, bumps the room epoch (supersedes any running loop at its next
+ *  member boundary), and starts the turn drive for the target thread.
+ *  Returns the thread id the message landed in. */
+export function sendToGroupChat(
+  group: string,
+  members: GroupMember[],
+  text: string,
+  thread?: null | string,
+  images?: Attachment[]
+): null | string {
+  const trimmed = String(text || '').trim()
+  const attached = Array.isArray(images) ? images.filter((img: Attachment) => img && img.data) : []
+
+  if ((!trimmed && !attached.length) || !members.length) {
+    return null
+  }
+
+  const target = thread || mintGroupThreadId()
+  $groupNeedsYou.set({
+    ...$groupNeedsYou.get(),
+    [group]: false
+  })
+  // Refresh the durable room roster on every send. This backfills rooms made
+  // by older Desktop builds and keeps the gateway mirror complete even when
+  // members overlap across multiple groups.
+  updateGroupChat(group, (room: GroupChatRoom) => {
+    room.members = durableGroupChatMembers(members)
+
+    return room
+  })
+
+  const sent = appendGroupChatEntry(
+    group,
+    {
+      kind: 'user',
+      name: 'You'
+    },
+    trimmed,
+    target,
+    attached
+  )
+
+  const wasRunning = ($groupChats.get()[group] || {}).running === true
+  updateGroupChat(group, (room: GroupChatRoom) => {
+    room.epoch = (room.epoch || 0) + 1
+    room.running = true
+    // #93129: user text is the ONLY input that changes member holds. An
+    // explicit "stop @member" sets a sticky hold; "@member resume" (or
+    // @all resume, or any direct non-stop mention of the held member)
+    // releases it. Bot replies never flow through this function.
+    room.holds = applyGroupHoldDirective(
+      room.holds,
+      parseGroupChatMentions(trimmed, members),
+      trimmed,
+      {
+        at: sent?.at,
+        byMessageId: sent?.id,
+        thread: target
+      },
+      members.map((member: GroupMember) => groupMemberKey(member))
+    )
+
+    return room
+  })
+  recordGroupActivity(group, {
+    kind: 'queued',
+    member: 'You',
+    thread: target
+  })
+
+  if (!wasRunning) {
+    void runGroupChatRounds(group, members, target).catch(() => {
+      updateGroupChat(group, (r: GroupChatRoom) => {
+        r.running = false
+
+        return r
+      })
+    })
+  } else {
+    // A loop is live; it bails at its next boundary. Chain the fresh loop
+    // after a short settle so exactly one drive owns the room.
+    setTimeout(() => {
+      void runGroupChatRounds(group, members, target).catch(() => {
+        updateGroupChat(group, (r: GroupChatRoom) => {
+          r.running = false
+
+          return r
+        })
+      })
+    }, 250)
+  }
+
+  return target
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-rounds.unaddressed.test.ts b/apps/desktop/src/plugins/hermes-bots/group-rounds.unaddressed.test.ts
new file mode 100644
index 000000000000..a78f8eed9592
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-rounds.unaddressed.test.ts
@@ -0,0 +1,101 @@
+/**
+ * #94478 — the unresolved-handoff detector.
+ *
+ * A bot's @mention of a teammate inside its own reply IS visible to the next
+ * round's responder selection, but the round loop exits before that round
+ * runs: `spokeThisRound === 0` fires whenever the round's responders had no new
+ * delta to read (everyone already spoke; the only new entry is the citing
+ * reply), and a `GROUP_CHAT_MAX_*` cap can land in the same gap. The room then
+ * records "settled" while a called bot never answered.
+ *
+ * `unaddressedGroupMentions` is what the quiet-round exit consults before
+ * settling, so the continuation round it drives is only as correct as this
+ * detector. Two subtleties it has to get right:
+ *
+ *  - **Log INDEX, not entry id, is the ordering.** Entry ids are UUIDs
+ *    (`groupChatEntryId`), so "answered after the citing entry" can only mean
+ *    positional order. Sorting by id marked answered handoffs as pending and
+ *    re-drove them — a loop.
+ *  - **A self-citation is not a handoff**, and neither is a user entry: a user
+ *    send re-drives everyone anyway.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { $groupChats } from './group-chat'
+import { unaddressedGroupMentions } from './group-rounds'
+import type { GroupMember, GroupMessage } from './types'
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    atom,
+    host: {
+      request: vi.fn(),
+      state: { connectionId: { get: () => 'local' }, profile: { get: () => 'default' } }
+    },
+    queryClient: { invalidateQueries: vi.fn() },
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+const members = [{ name: 'alpha' }, { name: 'beta' }, { name: 'gamma' }] as GroupMember[]
+
+const from = (name: string, id: string, text: string): GroupMessage =>
+  ({ at: 0, from: { kind: 'member', name }, id, text, thread: 't1' }) as GroupMessage
+
+const fromUser = (id: string, text: string): GroupMessage =>
+  ({ at: 0, from: { kind: 'user', name: 'You' }, id, text, thread: 't1' }) as GroupMessage
+
+function room(log: GroupMessage[]) {
+  $groupChats.set({ g: { log, members, roomId: 'room-1' } as never })
+}
+
+beforeEach(() => {
+  $groupChats.set({})
+})
+
+describe('unaddressedGroupMentions', () => {
+  it('flags a cited member with no later post', () => {
+    room([from('alpha', 'zzzz-0002', 'hello'), from('beta', 'aaaa-0003', 'ping @gamma — take this')])
+
+    expect(unaddressedGroupMentions('g', members, 't1')).toEqual(['gamma'])
+  })
+
+  it('counts a reply that follows in LOG order even when its id sorts lower', () => {
+    room([from('beta', 'aaaa-0003', 'ping @gamma — take this'), from('gamma', '9999-0004', 'on it')])
+
+    expect(unaddressedGroupMentions('g', members, 't1')).toEqual([])
+  })
+
+  it('re-flags a handoff cited again after the answer', () => {
+    room([from('beta', 'a', 'ping @gamma'), from('gamma', 'b', 'on it'), from('beta', 'c', 'one more thing @gamma')])
+
+    expect(unaddressedGroupMentions('g', members, 't1')).toEqual(['gamma'])
+  })
+
+  it('never treats a self-citation or a user entry as a handoff', () => {
+    room([
+      from('alpha', 'bbbb-0001', 'I will do @alpha things myself'),
+      fromUser('cccc-0002', '@beta @gamma look here')
+    ])
+
+    expect(unaddressedGroupMentions('g', members, 't1')).toEqual([])
+  })
+
+  it('ignores citations in another thread', () => {
+    const other = { ...from('beta', 'x', 'ping @gamma'), thread: 't2' } as GroupMessage
+
+    room([other, from('alpha', 'y', 'unrelated')])
+
+    expect(unaddressedGroupMentions('g', members, 't1')).toEqual([])
+  })
+
+  it('reports nothing for an unknown room', () => {
+    expect(unaddressedGroupMentions('missing', members, 't1')).toEqual([])
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-test-utils.ts b/apps/desktop/src/plugins/hermes-bots/group-test-utils.ts
new file mode 100644
index 000000000000..158bdf823454
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-test-utils.ts
@@ -0,0 +1,488 @@
+/**
+ * A scripted gateway for the group-chat room-engine tests.
+ *
+ * A member turn is a session-scoped RPC SEQUENCE (create/resume → attach →
+ * prompt.submit → poll), so nearly every room contract is only observable in
+ * what those RPCs saw. This models the parts of the gateway's session
+ * lifecycle those contracts depend on:
+ *
+ *  - the STORED id is the durable identity and every `session.resume` mints a
+ *    FRESH runtime id, which is why a turn that loses its socket mid-sequence
+ *    has to recover through the stored id (#93602);
+ *  - a missing session answers JSON-RPC 4007 — the real "genuinely not found"
+ *    code that `ensureGroupChatSession`'s fail-closed branch keys on, so a
+ *    plain failure here is NOT read as "no session, mint a new one";
+ *  - `host.requestProfile` takes a per-request socket lease and disposes the
+ *    socket at refcount 0, the reap that made routed members go silent.
+ *
+ * Its predecessors sliced `plugin.js` out of the bundle with string offsets
+ * and ran it under `vm`; this drives the real modules through the real
+ * `host` surface instead.
+ */
+
+import type { PluginContext } from '@hermes/plugin-sdk'
+import { vi } from 'vitest'
+
+/** One message in a scripted session transcript, in the gateway's own shape. */
+export interface ScriptedMessage {
+  content: string
+  role: string
+}
+
+export interface ScriptedSession {
+  contracts?: { follow_profile_config: boolean; room_plumbing: boolean }
+  messages: ScriptedMessage[]
+  profile: string
+  runtime: string
+  stored: string
+  title: string
+}
+
+/** What the scripted member "said" this turn: one reply, or the whole tail of
+ *  messages a real turn can append (a substantive answer plus a continuation
+ *  nudge and its synthetic pass, #94376). */
+export type TurnReply = ScriptedMessage[] | string
+
+export interface ScriptedTurn {
+  /** 1-based index across every prompt.submit the gateway has seen. */
+  n: number
+  profile: string
+  prompt: string
+  session: ScriptedSession
+}
+
+export type TurnScript = (turn: ScriptedTurn) => Promise<TurnReply> | TurnReply
+
+/** Every prompt.submit the gateway received, with the session it landed on. */
+export interface PromptCall {
+  profile: string
+  prompt: string
+  runtime: string
+  stored: string
+  title: string
+}
+
+/** Every attachment staging RPC, and how many submits preceded it. */
+export interface AttachCall {
+  data: string
+  filename: string
+  method: string
+  order: number
+  profile: null | string
+  runtime: string
+}
+
+export interface RpcCall {
+  method: string
+  params: Record<string, unknown>
+  /** Socket refcount after this request released its own lease. */
+  refcountAfter: number
+}
+
+export interface GatewayOptions {
+  /** Per profile: report inflight/running on its first N `session.resume`s. */
+  busyResumes?: Record<string, number>
+  /** Per profile: carry `pending_approval` on its first `until` resumes. */
+  approvalUntil?: Record<string, { payload: Record<string, unknown>; until: number }>
+  /** Per profile: carry `pending_clarify` on its first `until` resumes. */
+  clarifyUntil?: Record<string, { payload: Record<string, unknown>; until: number }>
+  /** Land a competing writer's `ui_meta` under `key` during the FIRST
+   *  `profiles.configure`, then reject it as a CAS conflict — the race the
+   *  sync worker's pull-merge-retry exists for. */
+  conflictOnce?: { key: string; value: unknown }
+  /** Reject every prompt.submit with this — a fatal, non-recoverable failure. */
+  failEverySubmitWith?: unknown
+  /** Reject only the FIRST prompt.submit — the 4001 reap the retry recovers. */
+  failFirstSubmitWith?: unknown
+  /** Fired on each post-submit poll, so a test can land a stop mid-turn. */
+  onResumePoll?: (polls: number) => void
+  /** Report the member inflight for the first N post-submit polls. */
+  pollsBusy?: number
+  turn?: TurnScript
+}
+
+/** A gateway-shaped rejection: `.code` is what the engine branches on. */
+function gatewayError(message: string, code: number) {
+  return Object.assign(new Error(message), { code })
+}
+
+export interface ScriptedGateway {
+  /** Attachment staging RPCs, in order. */
+  attaches: AttachCall[]
+  /** prompt.submit calls, in order. */
+  calls: PromptCall[]
+  /** Times the socket refcount fell to zero — each one reaps a runtime session. */
+  disposals: () => number
+  /** The mock `host` the `@hermes/plugin-sdk` mock should expose. */
+  host: Record<string, unknown>
+  /** Every RPC, for methods the typed recorders above don't cover. */
+  rpc: RpcCall[]
+  /** Filter `rpc` by method. */
+  rpcFor: (method: string) => RpcCall[]
+  /** Live socket refcount — zero between turns, never zero during one. */
+  refcount: () => number
+  /** Sessions by stored id, so a test can pre-seed a finished transcript. */
+  sessions: Map<string, ScriptedSession>
+  /** Plugin storage writes, by key. */
+  storage: Map<string, unknown>
+  /** `retain`/`release`/method names in call order — the lease lifetime. */
+  timeline: string[]
+  /** The default profile's `ui_meta`, as `profiles.list` reports it. */
+  uiMeta: Record<string, unknown>
+  /** CAS revisions for `uiMeta`, advanced by every applied configure. */
+  uiMetaRevisions: Record<string, number>
+}
+
+export function createGroupGateway(options: GatewayOptions = {}): ScriptedGateway {
+  const { turn = () => '(pass)' } = options
+  const sessions = new Map<string, ScriptedSession>()
+  const runtimeToStored = new Map<string, string>()
+  const titleToStored = new Map<string, string>()
+  const resumesByProfile = new Map<string, number>()
+  const calls: PromptCall[] = []
+  const attaches: AttachCall[] = []
+  const rpc: RpcCall[] = []
+  const timeline: string[] = []
+  const storage = new Map<string, unknown>()
+  const uiMeta: Record<string, unknown> = {}
+  const uiMetaRevisions: Record<string, number> = {}
+  let sequence = 0
+  let submits = 0
+  let polls = 0
+  let refcount = 0
+  let disposals = 0
+  let conflicted = false
+
+  const resolveSession = (profile: unknown, target: unknown) => {
+    const key = String(target ?? '')
+
+    const stored =
+      runtimeToStored.get(key) || (sessions.has(key) ? key : titleToStored.get(`${String(profile)}::${key}`))
+
+    return stored ? sessions.get(stored) || null : null
+  }
+
+  const handle = async (method: string, params: Record<string, unknown>): Promise<unknown> => {
+    if (method === 'profiles.list') {
+      return {
+        profiles: [{ name: 'default', ui_meta: { ...uiMeta }, ui_meta_revisions: { ...uiMetaRevisions } }]
+      }
+    }
+
+    if (method === 'profiles.configure') {
+      if (options.conflictOnce && !conflicted) {
+        conflicted = true
+        const { key, value } = options.conflictOnce
+        uiMeta[key] = value
+        uiMetaRevisions[key] = (uiMetaRevisions[key] || 0) + 1
+
+        return {
+          applied: {
+            ui_meta: false,
+            ui_meta_conflicts: { [key]: { actual: uiMetaRevisions[key], expected: uiMetaRevisions[key] - 1 } },
+            ui_meta_revisions: { ...uiMetaRevisions }
+          }
+        }
+      }
+
+      const expected = params.ui_meta_expected_revisions as Record<string, number> | undefined
+      const incoming = (params.ui_meta || {}) as Record<string, unknown>
+
+      if (expected) {
+        for (const key of Object.keys(incoming)) {
+          if ((uiMetaRevisions[key] || 0) !== expected[key]) {
+            return {
+              applied: {
+                ui_meta: false,
+                ui_meta_conflicts: { [key]: { actual: uiMetaRevisions[key] || 0, expected: expected[key] } }
+              }
+            }
+          }
+        }
+      }
+
+      for (const [key, value] of Object.entries(incoming)) {
+        if (value === null) {
+          delete uiMeta[key]
+        } else {
+          uiMeta[key] = value
+        }
+
+        uiMetaRevisions[key] = (uiMetaRevisions[key] || 0) + 1
+      }
+
+      return { applied: { ui_meta: true, ui_meta_revisions: { ...uiMetaRevisions } } }
+    }
+
+    if (method === 'session.create') {
+      sequence += 1
+      const profile = String(params.profile ?? '')
+      const title = String(params.title ?? '')
+
+      const session: ScriptedSession = {
+        contracts: {
+          follow_profile_config: params.follow_profile_config === true,
+          room_plumbing: params.room_plumbing === true
+        },
+        messages: [],
+        profile,
+        runtime: `rt-${profile}-${sequence}`,
+        stored: `sid-${profile}-${sequence}`,
+        title
+      }
+
+      sessions.set(session.stored, session)
+      runtimeToStored.set(session.runtime, session.stored)
+      titleToStored.set(`${profile}::${title}`, session.stored)
+
+      return { message_count: 0, messages: [], session_id: session.runtime, stored_session_id: session.stored }
+    }
+
+    if (method === 'session.resume') {
+      const session = resolveSession(params.profile, params.session_id)
+
+      if (!session) {
+        throw gatewayError(`session not found: ${String(params.session_id)}`, 4007)
+      }
+
+      // Every resume mints a fresh runtime id; the stored id is the durable
+      // identity. Old runtime ids stay resolvable so an in-flight turn that
+      // still holds one is not spuriously reaped by the harness itself.
+      sequence += 1
+      session.runtime = `rt-${session.profile}-${sequence}`
+      runtimeToStored.set(session.runtime, session.stored)
+
+      const seen = (resumesByProfile.get(session.profile) || 0) + 1
+      resumesByProfile.set(session.profile, seen)
+      let busy = Boolean(options.busyResumes?.[session.profile] && seen <= options.busyResumes[session.profile])
+
+      if (session.messages.length > 0) {
+        polls += 1
+        busy = busy || Boolean(options.pollsBusy && polls <= options.pollsBusy)
+        options.onResumePoll?.(polls)
+      }
+
+      const clarify = options.clarifyUntil?.[session.profile]
+      const approval = options.approvalUntil?.[session.profile]
+
+      return {
+        inflight: busy,
+        message_count: busy ? 0 : session.messages.length,
+        messages: busy || params.omit_messages ? [] : [...session.messages],
+        running: false,
+        session_id: session.runtime,
+        session_key: session.stored,
+        ...(clarify && seen <= clarify.until ? { pending_clarify: clarify.payload } : {}),
+        ...(approval && seen <= approval.until ? { pending_approval: approval.payload } : {})
+      }
+    }
+
+    if (method === 'image.attach_bytes' || method === 'pdf.attach' || method === 'file.attach') {
+      const session = resolveSession(null, params.session_id)
+
+      if (!session) {
+        throw gatewayError(`session-scoped RPC rejected: ${String(params.session_id)} not in memory`, 4001)
+      }
+
+      attaches.push({
+        data: String(params.content_base64 ?? params.data_url ?? ''),
+        filename: String(params.filename ?? params.name ?? ''),
+        method,
+        order: calls.length,
+        profile: session.profile,
+        runtime: String(params.session_id ?? '')
+      })
+
+      return method === 'file.attach'
+        ? { attached: true, ref_text: `@file:attachments/${String(params.name ?? 'attachment')}` }
+        : { attached: true }
+    }
+
+    if (method === 'prompt.submit') {
+      submits += 1
+
+      if (options.failEverySubmitWith) {
+        throw options.failEverySubmitWith
+      }
+
+      if (submits === 1 && options.failFirstSubmitWith) {
+        throw options.failFirstSubmitWith
+      }
+
+      const session = resolveSession(null, params.session_id)
+
+      if (!session) {
+        throw gatewayError(`session-scoped RPC rejected: ${String(params.session_id)} not in memory`, 4001)
+      }
+
+      const prompt = String(params.text ?? '')
+      session.messages.push({ content: prompt, role: 'user' })
+      calls.push({
+        profile: session.profile,
+        prompt,
+        runtime: session.runtime,
+        stored: session.stored,
+        title: session.title
+      })
+      const reply = await turn({ n: calls.length, profile: session.profile, prompt, session })
+
+      for (const message of typeof reply === 'string' ? [{ content: reply, role: 'assistant' }] : reply) {
+        session.messages.push(message)
+      }
+
+      return {}
+    }
+
+    return {}
+  }
+
+  const record = async (method: string, params: Record<string, unknown>) => {
+    try {
+      return await handle(method, params)
+    } finally {
+      rpc.push({ method, params, refcountAfter: refcount })
+    }
+  }
+
+  const host: Record<string, unknown> = {
+    activeConnectionId: () => 'local',
+    notify: vi.fn(),
+    notifyError: vi.fn(),
+    request: async (method: string, params: Record<string, unknown> = {}) => record(method, params),
+    requestProfile: async (_route: unknown, method: string, params: Record<string, unknown> = {}) => {
+      refcount += 1
+
+      try {
+        return await handle(method, params)
+      } finally {
+        refcount -= 1
+
+        if (refcount === 0) {
+          disposals += 1
+        }
+
+        rpc.push({ method, params, refcountAfter: refcount })
+        timeline.push(method)
+      }
+    },
+    retainProfile: async () => {
+      timeline.push('retain')
+      refcount += 1
+      let released = false
+
+      return () => {
+        if (released) {
+          return
+        }
+
+        released = true
+        timeline.push('release')
+        refcount -= 1
+
+        if (refcount === 0) {
+          disposals += 1
+        }
+      }
+    },
+    setWorkspaceScope: vi.fn(),
+    state: {
+      connectionId: { get: () => 'local', listen: () => () => undefined },
+      gateway: { get: () => 'open', listen: () => () => undefined },
+      profile: { get: () => 'default', listen: () => () => undefined }
+    }
+  }
+
+  return {
+    attaches,
+    calls,
+    disposals: () => disposals,
+    host,
+    refcount: () => refcount,
+    rpc,
+    rpcFor: (method: string) => rpc.filter(entry => entry.method === method),
+    sessions,
+    storage,
+    timeline,
+    uiMeta,
+    uiMetaRevisions
+  }
+}
+
+/** The `@hermes/plugin-sdk` surface the group modules actually reach for.
+ *  `atom` must be the real nanostores one — the room store IS its atoms — and
+ *  it has to come from the CURRENT module generation, so this is built inside
+ *  the `vi.mock` factory rather than hoisted alongside it. */
+export async function pluginSdkMock(host: Record<string, unknown>) {
+  const nanostores = await import('nanostores')
+
+  return {
+    atom: nanostores.atom,
+    // Feature-detected SDK members: the modules read them off the namespace
+    // and fall back when absent, but vitest rejects a namespace access with
+    // no matching export at all — so they have to be present and undefined.
+    BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS: undefined,
+    blobatarSvg: undefined,
+    computed: nanostores.computed,
+    createBudgetedLoop: undefined,
+    host,
+    SkillsView: undefined,
+    Streamdown: undefined,
+    queryClient: { invalidateQueries: () => undefined },
+    useQuery: () => ({ data: [], isLoading: false }),
+    useValue: <T>(store: { get: () => T }) => store.get()
+  }
+}
+
+/** Plugin storage backed by a plain map, for `setPluginCtx`. */
+export function scriptedStorage(storage: Map<string, unknown>): PluginContext {
+  return {
+    storage: {
+      get: async (key: string) => storage.get(key) ?? null,
+      set: async (key: string, value: unknown) => {
+        storage.set(key, structuredClone(value))
+      }
+    }
+    // The modules under test only ever reach for ctx.storage; the rest of the
+    // host-supplied context has no bearing on room state.
+  } as unknown as PluginContext
+}
+
+/** Run the room engine's timers inline.
+ *
+ *  The turn poll sleeps `GROUP_TURN_POLL_MS` between resumes and the sync
+ *  mirror debounces by 350ms; both are wall-clock waits a test must not
+ *  actually serve. Resolving immediately keeps the awaits (and therefore the
+ *  interleaving the race contracts depend on) while removing the delay. */
+export function runTimersInline() {
+  vi.stubGlobal('setTimeout', (fn: () => void) => {
+    fn()
+
+    return 0
+  })
+  vi.stubGlobal('clearTimeout', () => undefined)
+}
+
+/** Run the engine's timers on the next macrotask instead of inline.
+ *
+ *  The sync worker's retry path stores its own timer handle AFTER scheduling
+ *  it (`retryTimers.set(id, setTimeout(...))`), so an inline timer deletes the
+ *  handle before it is written and the entry never clears. Deferring keeps
+ *  that ordering intact while still ignoring the backoff delay. */
+export function deferTimers() {
+  vi.stubGlobal('setTimeout', (fn: () => void) => {
+    setImmediate(fn)
+
+    return 1
+  })
+  vi.stubGlobal('clearTimeout', () => undefined)
+}
+
+/** Let the room engine's async loop run to completion. */
+export async function drain(isRunning: () => boolean, limit = 400) {
+  for (let i = 0; i < limit && isRunning(); i++) {
+    await new Promise(resolve => setImmediate(resolve))
+  }
+
+  // One more flush so the `finally` bookkeeping after the last await lands.
+  await new Promise(resolve => setImmediate(resolve))
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/group-turns.test.ts b/apps/desktop/src/plugins/hermes-bots/group-turns.test.ts
new file mode 100644
index 000000000000..90b7deaef41d
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-turns.test.ts
@@ -0,0 +1,672 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as groupChat from './group-chat'
+import type * as groupRounds from './group-rounds'
+import { createGroupGateway, drain, runTimersInline, scriptedStorage } from './group-test-utils'
+import type { GatewayOptions, ScriptedGateway } from './group-test-utils'
+import type * as groupTurns from './group-turns'
+import type { Attachment, GroupChat, GroupMember } from './types'
+
+// One member's turn: resolve its per-room session, stage attachments, submit,
+// and poll until the gateway says the member is done. The session is the
+// fragile part — it is addressed by a STORED id that outlives every runtime
+// id, and the socket it rides can be reaped underneath a turn in flight.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+
+  return pluginSdkMock(host)
+})
+
+interface Room {
+  chat: typeof groupChat
+  gateway: ScriptedGateway
+  rounds: typeof groupRounds
+  turns: typeof groupTurns
+}
+
+async function loadRoom(options: GatewayOptions = {}): Promise<Room> {
+  vi.resetModules()
+  const gateway = createGroupGateway(options)
+
+  for (const key of Object.keys(host)) {
+    delete host[key]
+  }
+
+  Object.assign(host, gateway.host)
+
+  const [chat, rounds, turns, shared] = await Promise.all([
+    import('./group-chat'),
+    import('./group-rounds'),
+    import('./group-turns'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx(scriptedStorage(gateway.storage))
+
+  return { chat, gateway, rounds, turns }
+}
+
+const LOCAL_MEMBER: GroupMember = { name: 'helper', title: '' }
+const ROUTED_MEMBER: GroupMember = { connectionId: 'mini', name: 'helper', remoteSource: true }
+const IMG: Attachment = { data: 'data:image/png;base64,iVBORw0KGgo=', kind: 'image', name: 'shot.png' }
+
+const log = (room: Room, group: string) => room.chat.$groupChats.get()[group]?.log || []
+
+beforeEach(() => {
+  runTimersInline()
+})
+
+describe('session resolution', () => {
+  it('pins session titles to the roomId, with a legacy fallback to the display name', async () => {
+    const room = await loadRoom()
+
+    // Rooms persisted before roomIds keep name-based titles so their existing
+    // "Group: <name>" sessions keep resolving after an upgrade.
+    room.chat.updateGroupChat('Legacy', current => current)
+    const legacy = await room.turns.ensureGroupChatSession('Legacy', { name: 'research', title: '' })
+
+    expect(room.gateway.sessions.get(String(legacy.stored))?.title).toBe('Group: Legacy')
+
+    // New rooms pin the title to the immutable roomId, never the display name.
+    room.chat.updateGroupChat('New', current => {
+      current.roomId = 'r-abc'
+
+      return current
+    })
+    const fresh = await room.turns.ensureGroupChatSession('New', { name: 'research', title: '' })
+
+    expect(room.gateway.sessions.get(String(fresh.stored))?.title).toBe('Group: r-abc')
+  })
+
+  it('creates member sessions with the room_plumbing + follow_profile_config contracts', async () => {
+    // The PR #97008 contracts: room member sessions always rebuild from the
+    // member profile's CURRENT config on resume, never a stale stored
+    // model/provider pin. Dropping either param silently regresses rooms to
+    // the server's hidden + "Group: " title legacy fallback.
+    const room = await loadRoom()
+
+    room.chat.updateGroupChat('Contract', current => {
+      current.roomId = 'r-contract'
+
+      return current
+    })
+    const handle = await room.turns.ensureGroupChatSession('Contract', { name: 'research', title: '' })
+
+    expect(room.gateway.sessions.get(String(handle.stored))?.contracts).toEqual({
+      follow_profile_config: true,
+      room_plumbing: true
+    })
+  })
+
+  it('mints fresh member sessions when a same-name group is recreated after disband', async () => {
+    const room = await loadRoom()
+    const member: GroupMember = { name: 'research', title: '' }
+
+    room.chat.updateGroupChat('Alpha', current => {
+      current.roomId = 'r-one'
+
+      return current
+    })
+    const first = await room.turns.ensureGroupChatSession('Alpha', member)
+
+    // Disband: the room record is gone; the member's gateway session survives.
+    const rooms = { ...room.chat.$groupChats.get() }
+    delete rooms.Alpha
+    room.chat.$groupChats.set(rooms)
+
+    // Recreate under the same display name with a freshly minted roomId.
+    room.chat.updateGroupChat('Alpha', current => {
+      current.roomId = 'r-two'
+
+      return current
+    })
+    const second = await room.turns.ensureGroupChatSession('Alpha', member)
+
+    expect(first.stored).not.toBe(second.stored)
+    expect(room.gateway.sessions.get(String(first.stored))?.title).toBe('Group: r-one')
+    expect(room.gateway.sessions.get(String(second.stored))?.title).toBe('Group: r-two')
+  })
+
+  it('fails closed on a transient resume failure instead of forking the member session', async () => {
+    // Mirrors findExistingCanonicalChat's fix (87b645f52c): a resume that
+    // fails for any reason OTHER than "genuinely doesn't exist" (JSON-RPC code
+    // 4007) must surface, not be read as "no session, mint a new one" — that
+    // would fork the member's real history and silently overwrite
+    // room.sessions[key] so the old session becomes unreachable.
+    const room = await loadRoom()
+    const member: GroupMember = { name: 'research', title: '' }
+
+    room.chat.updateGroupChat('Alpha', current => {
+      current.roomId = 'r-one'
+
+      return current
+    })
+    const first = await room.turns.ensureGroupChatSession('Alpha', member)
+    const before = room.chat.$groupChats.get().Alpha.sessions
+
+    // A real gateway error on the NEXT resume of the member's own stored
+    // session — backend still warming up, a network blip, not "not found".
+    const request = host.request as (method: string, params: Record<string, unknown>) => Promise<unknown>
+
+    host.request = async (method: string, params: Record<string, unknown>) => {
+      if (method === 'session.resume' && params.session_id === first.stored) {
+        throw Object.assign(new Error('gateway temporarily unavailable'), { code: 5000 })
+      }
+
+      return request(method, params)
+    }
+
+    await expect(room.turns.ensureGroupChatSession('Alpha', member)).rejects.toThrow(/Could not check .*group session/)
+
+    host.request = request
+
+    // Nothing was forked: the room's session pointer is untouched, and the
+    // original session is still the only one on record for this member.
+    expect(room.chat.$groupChats.get().Alpha.sessions).toEqual(before)
+    expect(room.gateway.sessions.size).toBe(1)
+  })
+
+  it('falls through a genuine 4007 to the title lookup, then creates', async () => {
+    const room = await loadRoom()
+
+    room.chat.updateGroupChat('Alpha', current => {
+      current.roomId = 'r-one'
+      // A stored sid pointing at a session the gateway no longer has (e.g. an
+      // out-of-band deletion) is a genuine 4007 on the first target.
+      current.sessions = { research: 'sid-gone' }
+
+      return current
+    })
+
+    const result = await room.turns.ensureGroupChatSession('Alpha', { name: 'research', title: '' })
+
+    expect(result.stored).toBeTruthy()
+    expect(result.stored).not.toBe('sid-gone')
+  })
+})
+
+describe('session-gone classification', () => {
+  it('treats 4001 and "not in memory" as recoverable, 4007 as not', async () => {
+    const { turns } = await loadRoom()
+
+    expect(turns.isSessionGoneError(Object.assign(new Error('x'), { code: 4001 }))).toBe(true)
+    expect(turns.isSessionGoneError(new Error('session_id=rt-1 not in memory'))).toBe(true)
+    expect(turns.isSessionGoneError(Object.assign(new Error('session not found'), { code: 4007 }))).toBe(false)
+    expect(turns.isSessionGoneError(null)).toBe(false)
+    expect(turns.isSessionGoneError(new Error('network blip'))).toBe(false)
+  })
+
+  it('recovers a 4001 on the first submit via the STORED id and delivers', async () => {
+    const room = await loadRoom({
+      failFirstSubmitWith: Object.assign(new Error("session-scoped RPC rejected: session_id='rt-1' not in memory"), {
+        code: 4001
+      }),
+      turn: () => 'recovered reply'
+    })
+
+    const reply = await room.turns.runGroupChatMemberTurn('Room', LOCAL_MEMBER, 'hi there', 't1', [])
+
+    expect(reply).toBe('recovered reply')
+    // One failed submit + exactly one retry — never more.
+    expect(room.gateway.rpcFor('prompt.submit')).toHaveLength(2)
+    // The recovery re-resumed the durable stored id, not the dead runtime id.
+    expect(room.chat.$groupChats.get().Room.sessions?.helper).toBeTruthy()
+  })
+
+  it('does not retry a persistent non-4001 submit failure', async () => {
+    const room = await loadRoom({ failEverySubmitWith: new Error('backend exploded') })
+
+    await expect(room.turns.runGroupChatMemberTurn('Room', LOCAL_MEMBER, 'hi', 't1', [])).rejects.toThrow(
+      'backend exploded'
+    )
+    expect(room.gateway.rpcFor('prompt.submit')).toHaveLength(1)
+  })
+})
+
+describe('per-turn socket lease', () => {
+  it('is acquired before any session RPC and held across attach + submit', async () => {
+    const room = await loadRoom({ turn: () => 'routed reply' })
+
+    const reply = await room.turns.runGroupChatMemberTurn('Room', ROUTED_MEMBER, 'look at this', 't1', [IMG])
+
+    expect(reply).toBe('routed reply')
+    // The retain landed before the first session-scoped RPC on the route.
+    expect(room.gateway.timeline[0]).toBe('retain')
+
+    // The socket was NEVER disposed mid-turn: after every per-request lease
+    // released, the turn lease still held the refcount above zero.
+    for (const call of room.gateway.rpc) {
+      expect(call.refcountAfter).toBeGreaterThanOrEqual(1)
+    }
+
+    // Exactly one disposal, via the turn lease's own release at the end.
+    expect(room.gateway.disposals()).toBe(1)
+    expect(room.gateway.timeline.at(-1)).toBe('release')
+  })
+
+  it('is released after the turn — the refcount returns to zero', async () => {
+    const room = await loadRoom({ turn: () => 'done' })
+
+    await room.turns.runGroupChatMemberTurn('Room', ROUTED_MEMBER, 'hi', 't1', [])
+
+    expect(room.gateway.refcount()).toBe(0)
+    expect(room.gateway.disposals()).toBe(1)
+  })
+
+  it('is released even when the turn fails', async () => {
+    const room = await loadRoom({ failEverySubmitWith: new Error('backend exploded') })
+
+    await expect(room.turns.runGroupChatMemberTurn('Room', ROUTED_MEMBER, 'hi', 't1', [])).rejects.toThrow()
+    expect(room.gateway.refcount()).toBe(0)
+  })
+
+  it('is feature-detected: hosts without retainProfile still run the turn', async () => {
+    const room = await loadRoom({ turn: () => 'legacy ok' })
+    delete host.retainProfile
+
+    expect(await room.turns.runGroupChatMemberTurn('Room', ROUTED_MEMBER, 'hi', 't1', [])).toBe('legacy ok')
+  })
+})
+
+// #94376: a Codex intent-ack continuation nudge can land a substantive
+// answer, then get a synthetic "(pass)" reply to the nudge itself.
+describe('reply selection (#94376)', () => {
+  it('surfaces a substantive answer followed by a synthetic continuation (pass)', async () => {
+    const answer = "Yes. I welcomed them, and I'll review their first assignments with them."
+
+    const room = await loadRoom({
+      turn: () => [
+        { content: answer, role: 'assistant' },
+        {
+          content:
+            '[System: Continue now. Execute the required tool calls and only send your final answer after completing the task.]',
+          role: 'user'
+        },
+        { content: '(pass)', role: 'assistant' }
+      ]
+    })
+
+    expect(await room.turns.runGroupChatMemberTurn('Room', LOCAL_MEMBER, 'Did you welcome them?', 't1', [])).toBe(
+      answer
+    )
+  })
+
+  it('still reads a genuine pass-only turn as silent', async () => {
+    const room = await loadRoom({ turn: () => '(pass)' })
+
+    expect(await room.turns.runGroupChatMemberTurn('Room', LOCAL_MEMBER, 'anything new?', 't1', [])).toBe('(pass)')
+  })
+})
+
+// #90694: a member can block inside its own turn on a clarify question or a
+// command approval. Those live in a hidden session the room can't see, so the
+// poll mirrors them into the room and holds the turn open until they resolve.
+describe('clarify and approvals (#90694)', () => {
+  const CLARIFY = {
+    choices: ['staging', 'prod'],
+    multi_select: false,
+    question: 'Which env should I target?',
+    request_id: 'req-clarify-1'
+  }
+
+  const APPROVAL = {
+    choices: ['once', 'session', 'deny'],
+    command: 'rm -rf ./build',
+    description: 'Clean the build directory',
+    request_id: 'req-approval-1'
+  }
+
+  it('holds the turn open while a member is blocked on clarify, then lands the reply', async () => {
+    const room = await loadRoom({
+      clarifyUntil: { research: { payload: CLARIFY, until: 3 } },
+      turn: () => 'targeting staging'
+    })
+
+    const thread = room.rounds.sendToGroupChat(
+      'Core',
+      [{ name: 'research', title: '' }],
+      '@research deploy it',
+      null,
+      []
+    )
+
+    await drain(() => Boolean(room.chat.$groupChats.get().Core?.running))
+
+    const replies = log(room, 'Core').filter(entry => entry.thread === thread && entry.from.kind === 'member')
+
+    expect(replies).toHaveLength(1)
+    expect(replies[0].text).toBe('targeting staging')
+    expect(Object.keys(room.chat.$groupClarify.get())).toHaveLength(0)
+    // The mirror pass ran while the question was blocking, badging the room.
+    // A poll that never inspects pending_clarify leaves this unset — it is the
+    // observable proof the gate executed.
+    expect(room.chat.$groupNeedsYou.get().Core).toBe(true)
+  })
+
+  it('mirrors a question, badges needs-you, and is idempotent per request', async () => {
+    const { chat, turns } = await loadRoom()
+    const member: GroupMember = { name: 'research', title: '' }
+
+    expect(turns.syncGroupClarify('Core', member, { pending_clarify: CLARIFY })).toBe(true)
+
+    const mirrored = Object.values(chat.$groupClarify.get())
+
+    expect(mirrored).toHaveLength(1)
+    expect(mirrored[0].requestId).toBe('req-clarify-1')
+    expect(mirrored[0].question).toBe('Which env should I target?')
+    expect(mirrored[0].choices).toEqual(['staging', 'prod'])
+    expect(chat.$groupNeedsYou.get().Core).toBe(true)
+
+    // Same request again: no new entry, identity preserved.
+    turns.syncGroupClarify('Core', member, { pending_clarify: CLARIFY })
+
+    expect(Object.values(chat.$groupClarify.get())[0]).toBe(mirrored[0])
+
+    // Question resolved server-side: the mirror clears.
+    expect(turns.syncGroupClarify('Core', member, {})).toBe(false)
+    expect(Object.keys(chat.$groupClarify.get())).toHaveLength(0)
+  })
+
+  it('never mirrors a question for older backends without pending_clarify', async () => {
+    const { chat, turns } = await loadRoom()
+
+    expect(turns.syncGroupClarify('Core', { name: 'research' }, { messages: [] })).toBe(false)
+    expect(Object.keys(chat.$groupClarify.get())).toHaveLength(0)
+  })
+
+  it('routes an answer through clarify.respond and clears the mirror', async () => {
+    const room = await loadRoom()
+    const member: GroupMember = { name: 'research', title: '' }
+
+    room.turns.syncGroupClarify('Core', member, { pending_clarify: CLARIFY })
+    await room.turns.answerGroupClarify(Object.values(room.chat.$groupClarify.get())[0], member, 'staging')
+
+    expect(room.gateway.rpcFor('clarify.respond').map(call => call.params)).toEqual([
+      { answer: 'staging', request_id: 'req-clarify-1' }
+    ])
+    expect(Object.keys(room.chat.$groupClarify.get())).toHaveLength(0)
+  })
+
+  it('sends one respond per batch question, in order', async () => {
+    const room = await loadRoom()
+    const member: GroupMember = { name: 'research', title: '' }
+
+    room.turns.syncGroupClarify('Core', member, {
+      pending_clarify: {
+        questions: [
+          { choices: ['staging', 'prod'], qid: 'q0', question: 'Env?' },
+          { choices: [], qid: 'q1', question: 'Region?' }
+        ],
+        request_id: 'req-batch-1'
+      }
+    })
+    await room.turns.answerGroupClarify(Object.values(room.chat.$groupClarify.get())[0], member, {
+      q0: 'staging',
+      q1: 'eu-west'
+    })
+
+    expect(room.gateway.rpcFor('clarify.respond').map(call => call.params)).toEqual([
+      { answer: 'staging', question_id: 'q0', request_id: 'req-batch-1' },
+      { answer: 'eu-west', question_id: 'q1', request_id: 'req-batch-1' }
+    ])
+    expect(Object.keys(room.chat.$groupClarify.get())).toHaveLength(0)
+  })
+
+  it('clears only the disbanded room’s mirrored questions', async () => {
+    const room = await loadRoom()
+
+    room.turns.syncGroupClarify('Core', { name: 'research' }, { pending_clarify: CLARIFY })
+    room.turns.syncGroupClarify('Other', { name: 'ops' }, { pending_clarify: { ...CLARIFY, request_id: 'req-2' } })
+    room.turns.clearGroupClarify('Core')
+
+    const remaining = Object.values(room.chat.$groupClarify.get())
+
+    expect(remaining).toHaveLength(1)
+    expect(remaining[0].group).toBe('Other')
+  })
+
+  it('holds the turn open on a command approval too', async () => {
+    const room = await loadRoom({
+      approvalUntil: { research: { payload: APPROVAL, until: 3 } },
+      turn: () => 'build cleaned'
+    })
+
+    const thread = room.rounds.sendToGroupChat(
+      'Core',
+      [{ name: 'research', title: '' }],
+      '@research clean up',
+      null,
+      []
+    )
+
+    await drain(() => Boolean(room.chat.$groupChats.get().Core?.running))
+
+    const replies = log(room, 'Core').filter(entry => entry.thread === thread && entry.from.kind === 'member')
+
+    expect(replies).toHaveLength(1)
+    expect(replies[0].text).toBe('build cleaned')
+    expect(Object.keys(room.chat.$groupClarify.get())).toHaveLength(0)
+    expect(room.chat.$groupNeedsYou.get().Core).toBe(true)
+  })
+
+  it('mirrors an approval with its kind, command and server choices', async () => {
+    const { chat, turns } = await loadRoom()
+
+    expect(
+      turns.syncGroupClarify(
+        'Core',
+        { name: 'research', title: '' },
+        {
+          pending_approval: APPROVAL,
+          session_id: 'rt-research-1'
+        }
+      )
+    ).toBe(true)
+
+    const entry = Object.values(chat.$groupClarify.get())[0]
+
+    expect(entry.kind).toBe('approval')
+    expect(entry.command).toBe('rm -rf ./build')
+    expect(entry.question).toBe('Clean the build directory')
+    expect(entry.choices).toEqual(['once', 'session', 'deny'])
+    expect(entry.sessionId).toBe('rt-research-1')
+  })
+
+  it('falls back to once/deny when the server sends no choice set', async () => {
+    const { chat, turns } = await loadRoom()
+
+    turns.syncGroupClarify('Core', { name: 'research' }, { pending_approval: { command: 'ls', request_id: 'req-a2' } })
+
+    expect(Object.values(chat.$groupClarify.get())[0].choices).toEqual(['once', 'deny'])
+  })
+
+  it('routes approvals through approval.respond with the session and choice', async () => {
+    const room = await loadRoom()
+    const member: GroupMember = { name: 'research', title: '' }
+
+    room.turns.syncGroupClarify('Core', member, { pending_approval: APPROVAL, session_id: 'rt-research-1' })
+    await room.turns.answerGroupClarify(Object.values(room.chat.$groupClarify.get())[0], member, 'once')
+
+    expect(room.gateway.rpcFor('approval.respond').map(call => call.params)).toEqual([
+      { choice: 'once', request_id: 'req-approval-1', session_id: 'rt-research-1' }
+    ])
+    expect(room.gateway.rpcFor('clarify.respond')).toHaveLength(0)
+    expect(Object.keys(room.chat.$groupClarify.get())).toHaveLength(0)
+  })
+
+  it('lets clarify outrank approval when a snapshot carries both', async () => {
+    const { chat, turns } = await loadRoom()
+
+    turns.syncGroupClarify('Core', { name: 'research' }, { pending_approval: APPROVAL, pending_clarify: CLARIFY })
+
+    const entry = Object.values(chat.$groupClarify.get())[0]
+
+    expect(entry.kind).toBe('clarify')
+    expect(entry.requestId).toBe('req-clarify-1')
+  })
+})
+
+// A turn that outlives its deadline leaves a "stranded" marker. The member is
+// still working; the next round harvests whatever landed instead of throwing
+// the finished work away.
+describe('stranded harvest', () => {
+  const seedSession = (room: Room, stored: string, profile: string, title: string, messages: string[][]) => {
+    room.gateway.sessions.set(stored, {
+      messages: messages.map(([role, content]) => ({ content, role })),
+      profile,
+      runtime: `rt-${profile}`,
+      stored,
+      title
+    })
+  }
+
+  it('posts a late reply into the room and clears the marker', async () => {
+    const room = await loadRoom()
+
+    room.chat.updateGroupChat('Late', current => {
+      current.sessions = { research: 'sid-research' }
+      current.stranded = { research: 0 }
+
+      return current
+    })
+    // The member's session finished after we stopped waiting.
+    seedSession(room, 'sid-research', 'research', 'Group: Late', [
+      ['user', 'the turn prompt'],
+      ['assistant', 'Here is the full research result, delivered late.']
+    ])
+
+    await room.turns.harvestStrandedGroupReply('Late', { name: 'research', title: '' })
+
+    expect(log(room, 'Late')).toHaveLength(1)
+    expect(log(room, 'Late')[0].from.name).toBe('research')
+    expect(log(room, 'Late')[0].text).toMatch(/delivered late/)
+    expect(room.chat.$groupChats.get().Late.stranded?.research).toBeUndefined()
+  })
+
+  it('prefers the substantive answer over a trailing synthetic (pass)', async () => {
+    const room = await loadRoom()
+
+    // #94376 class bug at the second call site: the late-landing turn ends
+    // with a Codex intent-ack continuation nudge that gets a synthetic
+    // "(pass)" — the harvest must still surface the substantive answer.
+    room.chat.updateGroupChat('Rescue', current => {
+      current.sessions = { research: 'sid-research' }
+      current.stranded = { research: 0 }
+
+      return current
+    })
+    seedSession(room, 'sid-research', 'research', 'Group: Rescue', [
+      ['user', 'the turn prompt'],
+      ['assistant', 'Here is the full research result, delivered late.'],
+      [
+        'user',
+        '[System: Continue now. Execute the required tool calls and only send your final answer after completing the task.]'
+      ],
+      ['assistant', '(pass)']
+    ])
+
+    await room.turns.harvestStrandedGroupReply('Rescue', { name: 'research', title: '' })
+
+    expect(log(room, 'Rescue')).toHaveLength(1)
+    expect(log(room, 'Rescue')[0].text).toMatch(/delivered late/)
+    expect(room.chat.$groupChats.get().Rescue.stranded?.research).toBeUndefined()
+  })
+
+  it('consumes the marker without posting when the late reply is a pass', async () => {
+    const room = await loadRoom()
+
+    room.chat.updateGroupChat('Quiet2', current => {
+      current.sessions = { builder: 'sid-builder' }
+      current.stranded = { builder: 2 }
+
+      return current
+    })
+    seedSession(room, 'sid-builder', 'builder', 'Group: Quiet2', [
+      ['user', 'p1'],
+      ['user', 'prompt'],
+      ['assistant', '(pass)']
+    ])
+
+    await room.turns.harvestStrandedGroupReply('Quiet2', { name: 'builder', title: '' })
+
+    expect(log(room, 'Quiet2')).toHaveLength(0)
+    expect(room.chat.$groupChats.get().Quiet2.stranded?.builder).toBeUndefined()
+  })
+
+  it('never re-submits into a member the harvest just confirmed is still running', async () => {
+    // research is confirmed busy on exactly its first two session.resume calls
+    // — the number of harvest-only touches the FIXED code makes across two
+    // rounds. Without the responder guard research gets re-selected and picks
+    // up two EXTRA resume calls of its own before its first post-resubmit
+    // poll, which then reports done — so the unguarded run still finishes fast
+    // while proving the resubmission happened.
+    const room = await loadRoom({
+      busyResumes: { research: 2 },
+      turn: ({ profile }) => (profile === 'builder' ? 'builder here, all good' : '(pass)')
+    })
+
+    // The marker's pre-thread bare-number shape is still supported: presence
+    // in `stranded` is what the round-loop guard checks, not the value shape.
+    room.gateway.sessions.set('sid-research', {
+      messages: [],
+      profile: 'research',
+      runtime: 'rt-research',
+      stored: 'sid-research',
+      title: 'Group: Grind'
+    })
+    room.chat.updateGroupChat('Grind', current => {
+      current.log = [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'u1', text: '@research @builder status?' }]
+      current.sessions = { research: 'sid-research' }
+      current.stranded = { research: 0 }
+      current.watermarks = { 'legacy::builder': 0, 'legacy::research': 0 }
+
+      return current
+    })
+
+    await room.rounds.runGroupChatRounds(
+      'Grind',
+      [
+        { name: 'research', title: '' },
+        { name: 'builder', title: '' }
+      ],
+      'legacy'
+    )
+
+    expect(room.gateway.calls.filter(call => call.profile === 'research')).toHaveLength(0)
+    // The marker survives untouched — the harvest confirmed research is still
+    // running, so there is nothing to consume yet.
+    expect(room.chat.$groupChats.get().Grind.stranded?.research).toBe(0)
+    expect(room.gateway.calls.filter(call => call.profile === 'builder')).toHaveLength(1)
+  })
+})
+
+describe('room record', () => {
+  it('persists the roomId alongside the room and survives another room’s disband', async () => {
+    const room = await loadRoom()
+
+    room.chat.updateGroupChat('Keep', current => {
+      current.log = [{ at: 1, from: { kind: 'user', name: 'You' }, id: 'k1', text: 'hi' }]
+      current.roomId = 'r-keep'
+
+      return current
+    })
+    room.chat.updateGroupChat('Gone', current => {
+      current.roomId = 'r-gone'
+
+      return current
+    })
+
+    const rooms = { ...room.chat.$groupChats.get() }
+    delete rooms.Gone
+    room.chat.$groupChats.set(rooms)
+    await room.chat.persistGroupChatRooms(rooms)
+
+    const durable = (room.gateway.storage.get('group-chats') || {}) as Record<string, GroupChat>
+
+    expect(durable.Keep.roomId).toBe('r-keep')
+    expect('Gone' in durable).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/group-turns.ts b/apps/desktop/src/plugins/hermes-bots/group-turns.ts
new file mode 100644
index 000000000000..b9bd3e172c9e
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/group-turns.ts
@@ -0,0 +1,802 @@
+/**
+ * One member's turn: its hidden per-group session, the submit/poll loop that
+ * runs it, the pending clarify/approval prompts mirrored out of it, and the
+ * late-reply harvest for a turn that timed out.
+ *
+ * Room-level sequencing lives in group-rounds.ts, which drives these.
+ */
+
+import { host } from '@hermes/plugin-sdk'
+
+import { recordGroupActivity } from './group-activity'
+import { $groupChats, $groupClarify, $groupNeedsYou, appendGroupChatEntry, updateGroupChat } from './group-chat'
+import type { GroupChatRoom } from './group-chat'
+import { groupMemberKey, groupSessionOwner } from './group-membership'
+import { botConnectionRoute, requestForBot } from './routing'
+import type { Attachment, GroupMember, GroupPrompt, GroupPromptQuestion, ProfileRoute } from './types'
+
+/** "(pass)" (loosely: pass / (pass) / pass.) or empty = the member stayed silent. */
+export function isGroupPassText(text: unknown) {
+  const trimmed = String(text || '').trim()
+
+  if (!trimmed) {
+    return true
+  }
+
+  return /^\(?\s*pass\s*\)?\.?$/i.test(trimmed)
+}
+
+/** One transcript entry in a `session.resume` snapshot, as the turn harvester
+ *  reads it — the session's own message shape, not the plugin's GroupMessage.
+ *  `content` is a plain string on most providers and a part array on the rest. */
+interface GroupTurnTranscriptMessage {
+  content?: string | Array<string | { text?: string }>
+  role?: string
+  text?: string
+}
+
+/** #94376: pick the reply a finished turn should surface among the messages
+ *  appended since `before`. Scans newest-first and prefers the last
+ *  substantive (non-pass) assistant answer over a trailing pass — a Codex
+ *  intent-ack continuation nudge can land a complete answer and then get a
+ *  synthetic "(pass)" to the nudge itself, which must not hide the answer.
+ *  When only pass text exists in range, returns the newest (last
+ *  chronological) one rather than the oldest. Returns null only when no
+ *  assistant message appears in that range. */
+function pickGroupTurnReply(messages: GroupTurnTranscriptMessage[], before: number): null | string {
+  let passText: null | string = null
+
+  for (let i = messages.length - 1; i >= before; i--) {
+    const msg = messages[i]
+
+    if (msg?.role !== 'assistant') {
+      continue
+    }
+
+    const text =
+      typeof msg.content === 'string'
+        ? msg.content
+        : Array.isArray(msg.content)
+          ? msg.content.map(p => (typeof p === 'string' ? p : p?.text || '')).join('')
+          : msg?.text || ''
+
+    const replyText = String(text).trim()
+
+    if (isGroupPassText(replyText)) {
+      if (passText === null) {
+        passText = replyText
+      }
+
+      continue
+    }
+
+    return replyText
+  }
+
+  return passText
+}
+
+/** A clarify question blocking inside a member's session, as `session.resume`
+ *  reports it. Older backends omit the field entirely. */
+interface GroupPendingClarify {
+  choices?: string[]
+  multi_select?: unknown
+  question?: unknown
+  questions?: GroupPromptQuestion[]
+  request_id?: string
+}
+
+/** A command approval blocking inside a member's session, same wire as the
+ *  1:1 approval card. */
+interface GroupPendingApproval {
+  choices?: string[]
+  command?: unknown
+  description?: unknown
+  request_id?: string
+}
+
+/** The `session.resume` fields the room engine reads off a member's hidden
+ *  per-group session. */
+interface GroupSessionSnapshot {
+  inflight?: boolean
+  message_count?: number
+  messages?: GroupTurnTranscriptMessage[]
+  pending_approval?: GroupPendingApproval
+  pending_clarify?: GroupPendingClarify
+  running?: boolean
+  session_id?: string
+  session_key?: string
+}
+
+/** A member's per-group session, resolved for one turn. */
+interface GroupMemberSessionHandle {
+  /** Live runtime id every RPC in this turn targets. */
+  runtime: null | string
+  /** Durable id persisted in `room.sessions`; `true` is the legacy sentinel. */
+  stored?: null | string | true
+}
+
+/** Ensure the member's per-group session exists and return a LIVE runtime
+ *  session id for it. Gateway-native: session.create mints the session
+ *  (lazy until its first message), session.resume by stored id — or by
+ *  title, which also covers rehydrated rooms whose sid was lost — reopens
+ *  it after restarts. Cross-connection members route to their OWN source
+ *  via requestForBot; the window's gateway never switches. */
+export async function ensureGroupChatSession(group: string, member: GroupMember): Promise<GroupMemberSessionHandle> {
+  const room = $groupChats.get()[group] || {}
+  // New rooms title member sessions by their immutable roomId so a
+  // same-name recreate never resumes the old room's sessions by title;
+  // legacy rooms without a roomId fall back to the display name.
+  const title = `Group: ${room.roomId || group}`
+  const key = groupMemberKey(member)
+  const known = room.sessions && room.sessions[key]
+
+  // Try resuming what we know (stored sid first, then title lookup).
+  //
+  // FAIL CLOSED on a transient lookup failure — mirrors the sibling fix in
+  // findExistingCanonicalChat (87b645f52c). session.resume signals "this
+  // target genuinely doesn't exist" with JSON-RPC code 4007; every other
+  // failure (network blip, the backend still warming up after a restart,
+  // an oversized-resume refusal) means the real session might still be
+  // there and must not be read as "no session, mint a new one" — that
+  // forks the member's real history, and the fork silently overwrites
+  // room.sessions[key] so the old session becomes unreachable from the
+  // room. Only a genuine 4007 on BOTH targets means there truly is nothing
+  // to resume yet, so the loop falls through to session.create below.
+  for (const target of [known, title]) {
+    if (!target || target === true) {
+      continue
+    }
+
+    try {
+      const res = (await requestForBot(member, 'session.resume', {
+        session_id: target,
+        profile: member.name,
+        omit_messages: true
+      })) as GroupSessionSnapshot
+
+      if (res?.session_id) {
+        // TODO(bot-mode-types): `known` is `room.sessions[key]`, which the
+        // domain model types `string | true` — and the `target === true` skip
+        // above shows the legacy `true` sentinel is expected here. A backend
+        // that answers the title resume without a `session_key` therefore
+        // stores `true` back into room.sessions and hands `true` on as the
+        // durable id, which later rides into `session_id` on the recovery
+        // resume and on session.interrupt. Typed as-written.
+        const stored = res.session_key || known
+
+        if (stored) {
+          updateGroupChat(group, (current: GroupChatRoom) => {
+            current.sessions = {
+              ...(current.sessions || {}),
+              [key]: stored
+            }
+            current.sessionOwners = {
+              ...(current.sessionOwners || {}),
+              [key]: groupSessionOwner(member)
+            }
+
+            return current
+          })
+        }
+
+        return {
+          runtime: res.session_id,
+          stored
+        }
+      }
+    } catch (error: any) {
+      if (error?.code !== 4007) {
+        const detail = error instanceof Error && error.message ? ` (${error.message})` : ''
+        throw new Error(`Could not check ${member?.name || 'member'}'s group session${detail} — not starting a new one`)
+      }
+      /* genuinely doesn't exist (4007) — try the next target / fall through to create */
+    }
+  }
+
+  const created = (await requestForBot(member, 'session.create', {
+    profile: member.name,
+    title,
+    // Room member sessions are plumbing — always hidden from the sidebar.
+    hidden: true,
+    // Explicit contracts (PR #97008): room plumbing sessions always rebuild
+    // from the member profile's CURRENT config on resume, never a stale
+    // stored model/provider pin. Older gateways ignore the unknown params;
+    // the server's hidden + "Group: " title fallback then covers legacy.
+    room_plumbing: true,
+    follow_profile_config: true
+  })) as { session_id?: string; stored_session_id?: string }
+
+  const stored = created?.stored_session_id || null
+
+  if (stored) {
+    updateGroupChat(group, (r: GroupChatRoom) => {
+      r.sessions = {
+        ...(r.sessions || {}),
+        [key]: stored
+      }
+      r.sessionOwners = {
+        ...(r.sessionOwners || {}),
+        [key]: groupSessionOwner(member)
+      }
+
+      return r
+    })
+  }
+
+  return {
+    runtime: created?.session_id || null,
+    stored
+  }
+}
+
+const GROUP_TURN_TIMEOUT_MS = 180000
+const GROUP_TURN_POLL_MS = 2000
+
+// --- group-turn session-lease helpers (#93602) ------------------------------
+// A member turn is a session-scoped RPC SEQUENCE (resume → attach → submit →
+// poll) issued with the runtime id its first RPC minted. requestForBot routes
+// each RPC through a per-request socket lease (retained:false secondaries in
+// store/gateway), so between two RPCs the refcount can hit 0, the leased
+// socket closes, the gateway detaches the runtime session on WS disconnect,
+// and the orphan reaper frees it — the next RPC then fails 4001 "not in
+// memory" and the bot goes silent in the room.
+
+/** A gateway rejection as it reaches the room engine: an `Error`, a raw
+ *  JSON-RPC error object, or (across a realm boundary) a bare string. */
+interface GatewayErrorLike {
+  code?: number
+  data?: { reason?: unknown }
+  message?: unknown
+}
+
+/** 4001-class "the runtime session was reaped" failure. Distinct from 4007
+ *  ("genuinely never existed"), which must keep flowing to session.create. */
+export function isSessionGoneError(error: GatewayErrorLike | null | undefined): boolean {
+  if (!error || error.code === 4007) {
+    return false
+  }
+
+  if (error.code === 4001) {
+    return true
+  }
+
+  // Duck-typed (not instanceof): gateway errors can cross realm boundaries.
+  const message = typeof error?.message === 'string' ? error.message : typeof error === 'string' ? error : ''
+
+  return message.includes('not in memory') || /session not found/i.test(message)
+}
+// --- end group-turn session-lease helpers ---
+
+/** Hold the member's pooled socket open for the WHOLE turn. Feature-detected:
+ *  hosts without retainProfile (or members on the active gateway, which never
+ *  closes mid-turn) get a no-op release. A failed acquire must not kill the
+ *  turn — the catch-retry on submit still covers the race. */
+async function retainGroupTurnRoute(member: GroupMember): Promise<() => void> {
+  const noop = () => undefined
+  let route: ProfileRoute | null = null
+
+  try {
+    route = botConnectionRoute(member)
+  } catch {
+    return noop
+  }
+
+  if (!route || typeof host.retainProfile !== 'function') {
+    return noop
+  }
+
+  try {
+    const release = await host.retainProfile(route)
+
+    return typeof release === 'function' ? release : noop
+  } catch {
+    return noop
+  }
+}
+
+/** prompt.submit with one belt-and-braces retry: when the runtime session was
+ *  reaped between minting and submitting (4001 class), re-resume via the
+ *  STORED id — the durable identity — to mint a fresh runtime id, and submit
+ *  exactly once more. Returns the runtime id the submit actually landed on so
+ *  the poll loop keeps a live fallback target. */
+async function submitGroupTurnPrompt(
+  member: GroupMember,
+  runtime: string,
+  stored: null | string | true | undefined,
+  text: string
+): Promise<string> {
+  try {
+    await requestForBot(member, 'prompt.submit', {
+      session_id: runtime,
+      text
+    })
+
+    return runtime
+  } catch (error: any) {
+    if (!isSessionGoneError(error) || !stored) {
+      throw error
+    }
+
+    const res = (await requestForBot(member, 'session.resume', {
+      session_id: stored,
+      profile: member.name,
+      omit_messages: true
+    })) as GroupSessionSnapshot
+
+    const fresh = res?.session_id
+
+    if (!fresh) {
+      throw error
+    }
+
+    await requestForBot(member, 'prompt.submit', {
+      session_id: fresh,
+      text
+    })
+
+    return fresh
+  }
+}
+
+// A member turn that is VISIBLY still working (session reports
+// inflight/running) keeps its slot alive up to this hard cap. The base
+// timeout alone silently dropped long real turns: a 7-minute research run
+// timed out at 3 minutes, read as a pass, and its finished result never
+// reached the room (db's Aug 2026 report).
+const GROUP_TURN_HARD_CAP_MS = 20 * 60000
+
+/** Mirror a member's pending prompt — clarify question OR command approval —
+ *  from its resume snapshot into the room store, keyed
+ *  `${group}::${memberKey}` (#90694). Returns true while a prompt is
+ *  blocking, so the turn poll can extend its deadline — a waiting prompt
+ *  must not be eaten by the group-turn timeout. Feature-detected: older
+ *  backends without `pending_clarify`/`pending_approval` in the resume
+ *  payload always sync to "no prompt". Clarify wins when both are somehow
+ *  present (approvals resolve inside tool batches; clarify is the outer
+ *  blocker). */
+export function syncGroupClarify(group: string, member: GroupMember, state: GroupSessionSnapshot | null): boolean {
+  const key = `${group}::${groupMemberKey(member)}`
+  const clarify = state && typeof state.pending_clarify === 'object' ? state.pending_clarify : null
+
+  // The `!requestId` bail below is what makes the approval branch reachable,
+  // so an approval read there is never the null arm of this ternary — a fact
+  // control-flow analysis can't carry across the two separate locals.
+  const approval = (
+    state && typeof state.pending_approval === 'object' ? state.pending_approval : null
+  ) as GroupPendingApproval
+
+  const pending = clarify || approval
+  const requestId = pending?.request_id || null
+  const all = $groupClarify.get()
+  const current = all[key]
+
+  if (!requestId) {
+    if (current) {
+      const next = {
+        ...all
+      }
+
+      delete next[key]
+      $groupClarify.set(next)
+    }
+
+    return false
+  }
+
+  // Same request already mirrored — keep the object identity so the card
+  // doesn't lose its draft to a re-render.
+  if (current?.requestId === requestId) {
+    return true
+  }
+
+  const base = {
+    requestId,
+    group,
+    member: member.name,
+    memberKey: groupMemberKey(member),
+    // approval.respond keys on the session, not just the request — carry the
+    // runtime id the snapshot came from.
+    sessionId: state?.session_id || null,
+    at: Date.now()
+  }
+
+  $groupClarify.set({
+    ...all,
+    [key]: clarify
+      ? {
+          ...base,
+          kind: 'clarify',
+          question: typeof clarify.question === 'string' ? clarify.question : '',
+          choices: Array.isArray(clarify.choices) ? clarify.choices.filter(c => typeof c === 'string' && c) : [],
+          multiSelect: Boolean(clarify.multi_select),
+          // Batch clarifies carry `questions`; the room card answers them
+          // one wire call per question, mirroring the 1:1 batch contract.
+          questions: Array.isArray(clarify.questions) ? clarify.questions : null
+        }
+      : {
+          ...base,
+          kind: 'approval',
+          question: typeof approval.description === 'string' ? approval.description : '',
+          command: typeof approval.command === 'string' ? approval.command : '',
+          // The server precomputes the choice set from allow_permanent
+          // (once/session/always/deny); fall back to the minimal pair.
+          choices:
+            Array.isArray(approval.choices) && approval.choices.length
+              ? approval.choices.filter(c => typeof c === 'string' && c)
+              : ['once', 'deny'],
+          multiSelect: false,
+          questions: null
+        }
+  })
+  // A blocked member is a question for the human — badge the room.
+  $groupNeedsYou.set({
+    ...$groupNeedsYou.get(),
+    [group]: true
+  })
+
+  return true
+}
+
+/** Drop every mirrored clarify belonging to `group` (disband/rename). */
+export function clearGroupClarify(group: string) {
+  const all = $groupClarify.get()
+  const next: Record<string, GroupPrompt> = {}
+  let changed = false
+
+  for (const [key, value] of Object.entries<GroupPrompt>(all)) {
+    if (value?.group === group) {
+      changed = true
+    } else {
+      next[key] = value
+    }
+  }
+
+  if (changed) {
+    $groupClarify.set(next)
+  }
+}
+
+/** Answer a member's pending prompt from the room. Routes to the member's
+ *  OWN source (requestForBot), so cross-connection members work.
+ *  - clarify: `clarify.respond`; batch questions send one respond per
+ *    question, sequentially — the LAST lock resolves the blocked tool
+ *    server-side (same contract as the 1:1 batch card). allow_expired
+ *    server-side makes racing the timeout harmless.
+ *  - approval: `approval.respond` with the choice (once/session/always/deny),
+ *    keyed by session + request_id — the same wire the 1:1 approval card
+ *    and native notifications use. */
+export async function answerGroupClarify(
+  entry: GroupPrompt,
+  member: GroupMember,
+  answers: Record<string, string> | string | undefined
+) {
+  if (entry.kind === 'approval') {
+    await requestForBot(member, 'approval.respond', {
+      session_id: entry.sessionId || undefined,
+      request_id: entry.requestId,
+      choice: typeof answers === 'string' && answers ? answers : 'deny'
+    })
+  } else if (entry.questions && entry.questions.length) {
+    for (const question of entry.questions) {
+      // Question ids are opaque on the wire (`GroupPrompt.questions` types
+      // them `unknown`); the batch card keys its answer bag by exactly them.
+      const qid = (question?.qid ?? question?.id) as string
+      await requestForBot(member, 'clarify.respond', {
+        request_id: entry.requestId,
+        question_id: qid,
+        answer: (answers as Record<string, string>)?.[qid] ?? ''
+      })
+    }
+  } else {
+    await requestForBot(member, 'clarify.respond', {
+      request_id: entry.requestId,
+      answer: typeof answers === 'string' ? answers : ''
+    })
+  }
+
+  const all = $groupClarify.get()
+  const key = `${entry.group}::${entry.memberKey}`
+
+  if (all[key]?.requestId === entry.requestId) {
+    const next = {
+      ...all
+    }
+
+    delete next[key]
+    $groupClarify.set(next)
+  }
+}
+
+/** One member turn, gateway-native: submit the room delta as a prompt into
+ *  the member's per-group session, then poll the session until a NEW
+ *  assistant message lands (or timeout → pass). While the session visibly
+ *  reports work in flight the deadline extends (bounded by the hard cap),
+ *  so slow models aren't cut off mid-run. A turn that still times out
+ *  records a stranded marker so the finished reply can be harvested into
+ *  the room at the member's next turn instead of being lost. */
+export async function runGroupChatMemberTurn(
+  group: string,
+  member: GroupMember,
+  prompt: string,
+  thread: string,
+  images?: Attachment[]
+): Promise<null | string> {
+  // #93602: hold the member's route socket for the whole turn. Without the
+  // lease, every RPC below rides its own request-scoped socket lease; the
+  // socket that minted `runtime` can close between RPCs, the gateway reaps
+  // the runtime session, and prompt.submit dies 4001 — the bot goes silent.
+  const releaseTurnLease = await retainGroupTurnRoute(member)
+
+  try {
+    return await runGroupChatMemberTurnLeased(group, member, prompt, thread, images)
+  } finally {
+    releaseTurnLease()
+  }
+}
+
+async function runGroupChatMemberTurnLeased(
+  group: string,
+  member: GroupMember,
+  prompt: string,
+  thread: string,
+  images?: Attachment[]
+): Promise<null | string> {
+  const { runtime, stored } = await ensureGroupChatSession(group, member)
+
+  if (!runtime) {
+    return null
+  }
+
+  // #91868/#94569: remember the epoch this turn was dispatched under so the
+  // poll loop below can tell an explicit stop from ordinary room churn.
+  const dispatchEpoch = ($groupChats.get()[group] || {}).epoch || 0
+  const memberKey = groupMemberKey(member)
+  recordGroupActivity(group, {
+    kind: 'working',
+    member: member.name,
+    thread
+  })
+
+  // Baseline: how many messages exist before our submit.
+  let before = 0
+
+  try {
+    const pre = (await requestForBot(member, 'session.resume', {
+      session_id: stored || runtime,
+      profile: member.name
+    })) as GroupSessionSnapshot
+
+    before = Array.isArray(pre?.messages) ? pre.messages.length : pre?.message_count || 0
+  } catch {
+    /* lazy session — zero messages */
+  }
+
+  // Stage this delta's attachments into the member's session so the model
+  // receives the actual payload with the prompt — the same attach RPCs the
+  // 1:1 chat uses (they also work cross-connection, where the member's
+  // gateway can't see this machine's files). Images queue as vision tiles,
+  // PDFs render per-page via pdf.attach, and other files materialize in the
+  // session workspace (their @file: refs are appended to the prompt so the
+  // member's file tools can read them). A failed attach degrades that
+  // member to text-only; the transcript line still names the attachment so
+  // the member knows something was shared.
+  const fileRefs: string[] = []
+
+  for (const img of Array.isArray(images) ? images : []) {
+    if (!img || typeof img.data !== 'string' || !img.data) {
+      continue
+    }
+
+    try {
+      if (img.kind === 'pdf') {
+        await requestForBot(member, 'pdf.attach', {
+          session_id: runtime,
+          content_base64: img.data,
+          filename: img.name || 'attachment.pdf'
+        })
+      } else if (img.kind === 'file') {
+        const res = (await requestForBot(member, 'file.attach', {
+          session_id: runtime,
+          data_url: img.data,
+          name: img.name || 'attachment'
+        })) as { ref_text?: string }
+
+        if (res?.ref_text) {
+          fileRefs.push(`${img.name || 'attachment'} → ${res.ref_text}`)
+        }
+      } else {
+        await requestForBot(member, 'image.attach_bytes', {
+          session_id: runtime,
+          content_base64: img.data,
+          filename: img.name || 'attachment.png'
+        })
+      }
+    } catch {
+      /* text-only fallback for this member */
+    }
+  }
+
+  const turnText = fileRefs.length
+    ? `${prompt}\n\nAttached files staged in your session workspace:\n${fileRefs.join('\n')}`
+    : prompt
+
+  // #93602: one-shot recovery when the runtime session was reaped between
+  // minting and submitting. Tracks the runtime id the submit landed on so
+  // the poll fallback below targets a live session.
+  const liveRuntime = await submitGroupTurnPrompt(member, runtime, stored, turnText)
+  const started = Date.now()
+  let deadline = started + GROUP_TURN_TIMEOUT_MS
+
+  while (Date.now() < deadline) {
+    await new Promise(resolve => setTimeout(resolve, GROUP_TURN_POLL_MS))
+
+    // #91868/#94569: an explicit stop (stopGroupThread) bumped the epoch AND
+    // held this member — the member's session was interrupted, so nothing is
+    // coming; abandon the poll instead of grinding until the deadline. Both
+    // conditions on purpose: an ordinary newer send bumps the epoch WITHOUT
+    // a hold, and that turn must keep polling so finished work can still be
+    // delivered (the #93127 commit check decides its fate, not this loop).
+    const roomDuringPoll = $groupChats.get()[group] || {}
+
+    if ((roomDuringPoll.epoch || 0) !== dispatchEpoch && (roomDuringPoll.holds || {})[memberKey]) {
+      return null
+    }
+
+    let state: GroupSessionSnapshot | null = null
+
+    try {
+      state = (await requestForBot(member, 'session.resume', {
+        session_id: stored || liveRuntime,
+        profile: member.name
+      })) as GroupSessionSnapshot
+    } catch {
+      continue
+    }
+
+    const messages = Array.isArray(state?.messages) ? state.messages : []
+    const busy = Boolean(state?.inflight || state?.running)
+    // A clarify blocking inside the member's session is a question for the
+    // HUMAN (#90694) — mirror it into the room store so a card renders, and
+    // hold the turn open: the member isn't stalling, it's waiting on us.
+    const awaitingUser = syncGroupClarify(group, member, state)
+    const done = !busy && !awaitingUser
+
+    if (messages.length > before && done) {
+      const replyText = pickGroupTurnReply(messages, before)
+
+      if (replyText !== null) {
+        recordGroupActivity(group, {
+          kind: isGroupPassText(replyText) ? 'passed' : 'replied',
+          member: member.name,
+          thread
+        })
+
+        return replyText
+      }
+
+      recordGroupActivity(group, {
+        kind: 'passed',
+        member: member.name,
+        thread
+      })
+
+      return null
+    }
+
+    // Still visibly working — or waiting on the user's answer to a clarify:
+    // extend the deadline (never past the hard cap). A pending question must
+    // outlive the base turn timeout or it dies unanswered at 3 minutes.
+    if (busy || awaitingUser) {
+      deadline = Math.min(started + GROUP_TURN_HARD_CAP_MS, Math.max(deadline, Date.now() + GROUP_TURN_TIMEOUT_MS))
+    }
+  }
+
+  // Timeout — clear any still-mirrored question card (the server-side
+  // clarify timeout runs its own course) and read as a pass, but remember the baseline + thread
+  // (runtime-only) so the finished reply can be posted late into the RIGHT
+  // thread instead of vanishing.
+  recordGroupActivity(group, {
+    kind: 'timed-out',
+    member: member.name,
+    thread
+  })
+  syncGroupClarify(group, member, null)
+  updateGroupChat(group, (r: GroupChatRoom) => {
+    r.stranded = {
+      ...(r.stranded || {}),
+      [groupMemberKey(member)]: {
+        before,
+        thread
+      }
+    }
+
+    return r
+  })
+
+  return null
+}
+
+/** Post a timed-out member's finished reply into the room, if it landed
+ *  after we stopped waiting. Called at the member's next turn boundary and
+ *  on user sends, so long-running work is delivered late rather than lost. */
+export async function harvestStrandedGroupReply(group: string, member: GroupMember) {
+  const memberKey = groupMemberKey(member)
+  const room = $groupChats.get()[group] || {}
+  const marker = room.stranded?.[memberKey]
+  // Markers were a bare number before threads; normalize both shapes.
+  const strandedBefore = typeof marker === 'number' ? marker : marker?.before
+  const strandedThread = (typeof marker === 'object' && marker?.thread) || 'legacy'
+
+  if (typeof strandedBefore !== 'number') {
+    return
+  }
+
+  let state: GroupSessionSnapshot | null = null
+
+  try {
+    const stored = room.sessions?.[memberKey]
+    state = (await requestForBot(member, 'session.resume', {
+      session_id: stored || `Group: ${room.roomId || group}`,
+      profile: member.name
+    })) as GroupSessionSnapshot
+  } catch {
+    return // source unreachable — leave the marker for the next boundary
+  }
+
+  if (state?.inflight || state?.running) {
+    return // still grinding — keep waiting
+  }
+
+  // A stranded member blocked on a clarify is not "grinding" — surface the
+  // question card (#90694) and keep the marker until it resolves.
+  if (syncGroupClarify(group, member, state)) {
+    return
+  }
+
+  // Done (or dead): the marker is consumed either way.
+  updateGroupChat(group, (r: GroupChatRoom) => {
+    const next = {
+      ...(r.stranded || {})
+    }
+
+    delete next[memberKey]
+    r.stranded = next
+
+    return r
+  })
+  const messages = Array.isArray(state?.messages) ? state.messages : []
+
+  if (messages.length <= strandedBefore) {
+    return
+  }
+
+  const reply = pickGroupTurnReply(messages, strandedBefore)
+
+  if (reply && !isGroupPassText(reply)) {
+    recordGroupActivity(group, {
+      kind: 'delivered',
+      member: member.name,
+      thread: strandedThread
+    })
+    appendGroupChatEntry(
+      group,
+      {
+        kind: 'member',
+        name: member.name,
+        ...(member.remoteSource
+          ? {
+              source: member.connectionLabel || member.connectionId
+            }
+          : {})
+      },
+      reply,
+      strandedThread
+    )
+    updateGroupChat(group, (r: GroupChatRoom) => {
+      r.watermarks[`${strandedThread}::${memberKey}`] = r.log.length
+
+      return r
+    })
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/hidden-bots.test.ts b/apps/desktop/src/plugins/hermes-bots/hidden-bots.test.ts
new file mode 100644
index 000000000000..5ddfae7fb13e
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/hidden-bots.test.ts
@@ -0,0 +1,232 @@
+/**
+ * Per-bot Hide/Unhide.
+ *
+ * Right-click → Hide Bot persists `hidden: true` in bot meta (local
+ * ctx.storage AND server ui_meta via saveBotMeta), hidden bots drop out of the
+ * roster list, and a header eye toggle — rendered only while at least one bot
+ * is hidden — reveals them dimmed for right-click → Unhide.
+ *
+ * Hiding is a roster-DISPLAY concern only: the bot keeps working, stays
+ * mentionable, keeps its group membership, and any open chat stays open. The
+ * one behavioral consequence is quiet: a hidden bot still accumulates unread,
+ * it just never toasts.
+ *
+ * Ported from tests/hide-bots.test.mjs, which ran the whole plugin.js bundle
+ * under `vm`.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+const { markSessionUnreadFinished, notify, request } = vi.hoisted(() => ({
+  markSessionUnreadFinished: vi.fn(),
+  notify: vi.fn(),
+  request: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const sdk = await importOriginal<typeof HermesSdk>()
+
+  return {
+    ...sdk,
+    ackStoredSessionId: vi.fn(),
+    host: { ...sdk.host, notify, request },
+    markSessionUnreadFinished
+  }
+})
+
+/** Every ctx.storage write the module graph made, oldest first. */
+interface StorageWrite {
+  key: string
+  value: Record<string, { hidden?: boolean; title?: string }>
+}
+
+/** Bot Mode keeps roster/meta/watermark state in module-level atoms, so each
+ *  test gets a fresh graph rather than unwinding the previous one's writes. */
+async function loadModules() {
+  vi.resetModules()
+
+  const writes: StorageWrite[] = []
+
+  const [botState, data, hiddenBots, profileOps, rosterActions, shared] = await Promise.all([
+    import('./bot-state'),
+    import('./data'),
+    import('./hidden-bots'),
+    import('./profile-ops'),
+    import('./roster-actions'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx({
+    storage: {
+      get: () => null,
+      remove: () => undefined,
+      set: (key: string, value: unknown) => {
+        writes.push({ key, value } as StorageWrite)
+      }
+    }
+  } as unknown as Parameters<typeof shared.setPluginCtx>[0])
+
+  return { botState, data, hiddenBots, profileOps, rosterActions, writes }
+}
+
+// Pay the graph's cold transform once, up front. `loadModules` re-imports on
+// every test, and charging that one-time cost to whichever test happens to run
+// first makes it time out under a loaded runner.
+beforeAll(async () => {
+  await loadModules()
+}, 60_000)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  request.mockResolvedValue({ applied: { ui_meta: true } })
+})
+
+describe('hiding persists locally and cross-machine', () => {
+  it('writes hidden:true to storage and ships it in the server ui_meta', async () => {
+    const { data, writes } = await loadModules()
+
+    await data.saveBotMeta('default', { hidden: true })
+
+    expect(data.$botMeta.get().default.hidden).toBe(true)
+    expect(writes.at(-1)?.key).toBe('bot-meta')
+    expect(writes.at(-1)?.value.default.hidden).toBe(true)
+
+    const configure = request.mock.calls.find(([method]) => method === 'profiles.configure')
+
+    expect(configure?.[1].ui_meta['hermes-bots'].hidden).toBe(true)
+  })
+
+  it('clears the flag on unhide, and the server false beats a stale local true', async () => {
+    const { data, profileOps } = await loadModules()
+
+    data.$botMeta.set({ ghost: { hidden: true, title: 'Ghost' } })
+    await data.saveBotMeta('ghost', { hidden: false })
+
+    expect(data.$botMeta.get().ghost.hidden).toBe(false)
+
+    const configure = request.mock.calls.find(([method]) => method === 'profiles.configure')
+
+    // The server copy carries the literal false, not an omission.
+    expect(configure?.[1].ui_meta['hermes-bots'].hidden).toBe(false)
+
+    // Machine B: its stale local copy still says hidden:true; the server
+    // overlay (which merges OVER local) must win with the false.
+    data.$botMeta.set({ ghost: { hidden: true, title: 'Ghost' } })
+    profileOps.mergeServerMeta([
+      { name: 'ghost', ui_meta: { 'hermes-bots': { hidden: false, title: 'Ghost' } } }
+    ] as unknown as RosterRow[])
+
+    expect(data.$botMeta.get().ghost.hidden).toBe(false)
+  })
+
+  it('lands a hide done on another machine and persists it to storage', async () => {
+    const { data, profileOps, writes } = await loadModules()
+
+    data.$botMeta.set({ ghost: { title: 'Ghost' } })
+    profileOps.mergeServerMeta([
+      { name: 'ghost', ui_meta: { 'hermes-bots': { hidden: true, title: 'Ghost' } } }
+    ] as unknown as RosterRow[])
+
+    expect(data.$botMeta.get().ghost.hidden).toBe(true)
+    expect(writes.at(-1)?.value.ghost.hidden).toBe(true)
+  })
+})
+
+describe('the roster drops hidden rows without touching their twins', () => {
+  it('keeps a same-named remote-source row visible when the local one is hidden', async () => {
+    const { data, hiddenBots } = await loadModules()
+
+    data.$botMeta.set({ ghost: { hidden: true } })
+
+    const roster = [
+      { name: 'default' },
+      { name: 'ghost' },
+      { connectionId: 'mini', name: 'ghost', remoteSource: true }
+    ] as RosterRow[]
+
+    const meta = data.$botMeta.get()
+    const visible = roster.filter(bot => !hiddenBots.isBotHidden(bot, meta))
+
+    expect(visible.map(bot => `${bot.remoteSource ? 'r:' : ''}${bot.name}`)).toEqual(['default', 'r:ghost'])
+  })
+})
+
+describe('hiding the selected bot re-homes the selection', () => {
+  it('falls back to the first visible bot', async () => {
+    const { botState, data, hiddenBots } = await loadModules()
+
+    botState.$selectedBot.set('ghost')
+    data.$botMeta.set({ ghost: { hidden: true } })
+    data.$lastRoster.set([{ name: 'ghost' }, { name: 'scribe' }, { name: 'default' }] as RosterRow[])
+
+    hiddenBots.fallbackSelectionAfterHide('ghost')
+
+    expect(botState.$selectedBot.get()).toBe('scribe')
+  })
+
+  it('falls back to default when nothing else is visible', async () => {
+    const { botState, data, hiddenBots } = await loadModules()
+
+    botState.$selectedBot.set('ghost')
+    data.$botMeta.set({ ghost: { hidden: true } })
+    data.$lastRoster.set([{ name: 'ghost' }] as RosterRow[])
+
+    hiddenBots.fallbackSelectionAfterHide('ghost')
+
+    expect(botState.$selectedBot.get()).toBe('default')
+  })
+
+  it('keeps the selection when default itself is hidden and alone', async () => {
+    // Routines is scoped to the selected bot — it must not chase a ghost.
+    const { botState, data, hiddenBots } = await loadModules()
+
+    botState.$selectedBot.set('default')
+    data.$botMeta.set({ default: { hidden: true } })
+    data.$lastRoster.set([{ name: 'default' }] as RosterRow[])
+
+    hiddenBots.fallbackSelectionAfterHide('default')
+
+    expect(botState.$selectedBot.get()).toBe('default')
+  })
+
+  it('never moves the selection when an unselected bot is hidden', async () => {
+    const { botState, data, hiddenBots } = await loadModules()
+
+    botState.$selectedBot.set('scribe')
+    data.$botMeta.set({ ghost: { hidden: true } })
+    data.$lastRoster.set([{ name: 'ghost' }, { name: 'scribe' }] as RosterRow[])
+
+    hiddenBots.fallbackSelectionAfterHide('ghost')
+
+    expect(botState.$selectedBot.get()).toBe('scribe')
+  })
+})
+
+describe('a hidden bot stays quiet without going deaf', () => {
+  it('accumulates unread but never toasts, even with toasts on', async () => {
+    const { botState, data, rosterActions } = await loadModules()
+
+    rosterActions.setActivityToasts(true)
+    data.$botMeta.set({ ghost: { hidden: true } })
+    botState.$selectedBot.set('default')
+
+    const rosterAt = (at: number) =>
+      [
+        {
+          canonical_session: { id: 'ghost-chat', last_active: at, preview: 'Message from writer: hi' },
+          name: 'ghost'
+        }
+      ] as unknown as RosterRow[]
+
+    rosterActions.trackInboundActivity(rosterAt(100)) // seeding poll
+    rosterActions.trackInboundActivity(rosterAt(200)) // activity past the watermark
+
+    // Unread goes straight into core's store, keyed by the same canonical id
+    // the row's status dot reads.
+    expect(markSessionUnreadFinished).toHaveBeenCalledWith('ghost-chat', 'ghost')
+    expect(notify).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/hidden-bots.ts b/apps/desktop/src/plugins/hermes-bots/hidden-bots.ts
new file mode 100644
index 000000000000..a3f8c406a93b
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/hidden-bots.ts
@@ -0,0 +1,57 @@
+/**
+ * Roster-display hiding: the session-only reveal toggle, the two per-row
+ * predicates every surface reads, and the selection re-home a hide performs.
+ *
+ * A leaf by design. Hiding is presentation, so it knows nothing about the
+ * rows that render it — the bot row, the roster pane and selection
+ * reconciliation all read these and none of them owns the state.
+ */
+
+import { atom } from '@hermes/plugin-sdk'
+
+import { $selectedBot } from './bot-state'
+import { $botMeta, $lastRoster, botSelectionKey, isDefaultBot } from './data'
+import type { BotMetaSnapshot } from './data'
+import { botRosterMeta } from './routing'
+import type { RosterRow } from './types'
+
+// ── hidden bots (right-click → Hide Bot) ────────────────────────────────────
+// Hiding is a ROSTER-DISPLAY concern only: a hidden bot keeps working,
+// remains mentionable, keeps group membership, and any open chat stays open.
+
+/** Session-only view toggle: reveal hidden bots (dimmed) in the roster. */
+export const $showHiddenBots = atom(false)
+
+export function isBotHidden(bot: RosterRow, metaByName: BotMetaSnapshot) {
+  return Boolean(botRosterMeta(bot, metaByName)?.hidden)
+}
+
+export function isBotPinned(bot: RosterRow, metaByName: BotMetaSnapshot) {
+  return Boolean(botRosterMeta(bot, metaByName)?.pinned)
+}
+
+/** Hiding the selected bot re-homes the selection to the next visible owner. */
+export function fallbackSelectionAfterHide(name: string) {
+  if ($selectedBot.get() !== name) {
+    return
+  }
+
+  const meta = $botMeta.get()
+  const visible = $lastRoster.get().filter(bot => botSelectionKey(bot) !== name && !botRosterMeta(bot, meta)?.hidden)
+
+  if (visible.length) {
+    $selectedBot.set(botSelectionKey(visible[0]))
+
+    return
+  }
+
+  const defaultBot = $lastRoster.get().find(bot => isDefaultBot(bot) && !botRosterMeta(bot, meta)?.hidden)
+
+  if (defaultBot && botSelectionKey(defaultBot) !== name) {
+    $selectedBot.set(botSelectionKey(defaultBot))
+  } else if (!$lastRoster.get().some(isDefaultBot)) {
+    // Legacy sole-local rosters can transiently omit the default row. Keep the
+    // historic fallback rather than leaving Routines attached to a hidden bot.
+    $selectedBot.set('default')
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/hide-bot-chats.runtime.test.ts b/apps/desktop/src/plugins/hermes-bots/hide-bot-chats.runtime.test.ts
similarity index 94%
rename from apps/desktop/src/plugins/hermes-bots/tests/hide-bot-chats.runtime.test.ts
rename to apps/desktop/src/plugins/hermes-bots/hide-bot-chats.runtime.test.ts
index da3f06f2bc8c..ad474b759cde 100644
--- a/apps/desktop/src/plugins/hermes-bots/tests/hide-bot-chats.runtime.test.ts
+++ b/apps/desktop/src/plugins/hermes-bots/hide-bot-chats.runtime.test.ts
@@ -41,8 +41,7 @@ vi.mock('@hermes/plugin-sdk', async importOriginal => {
 })
 
 const { createPluginContext } = await import('@/contrib/plugin')
-// @ts-expect-error The bundled Bot Mode entry intentionally remains plain ESM JavaScript for older runtime loaders.
-const { default: plugin } = await import('../plugin.js')
+const { default: plugin } = await import('./plugin')
 
 const flushSweep = async () => {
   await vi.advanceTimersByTimeAsync(0)
diff --git a/apps/desktop/src/plugins/hermes-bots/hide-bot-chats.test.ts b/apps/desktop/src/plugins/hermes-bots/hide-bot-chats.test.ts
new file mode 100644
index 000000000000..4c9dab7ff8f4
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/hide-bot-chats.test.ts
@@ -0,0 +1,268 @@
+/**
+ * Bot Mode sessions are ALWAYS hidden from the global Sessions sidebar.
+ *
+ * Canonical Bot Chats and group-chat member sessions alike ride the core
+ * generic `hidden` session flag. There is no user pref: `session.create`
+ * passes `hidden: true` unconditionally (pinned in
+ * canonical-chat-creation.test.ts), and this reconciliation sweep pushes rows
+ * born visible under the old pref — or minted outside the plugin entirely —
+ * back to hidden on load and on every reconnect.
+ *
+ * The sweep has two halves and runs BOTH, id-based first:
+ *   1. by id — every group room's member sessions, which the plugin recorded;
+ *   2. by title — each roster bot's own profile listing, which is the only
+ *      thing that reaches CLI-born "Agent Inbox" / extra "Bot Chat" rows AND
+ *      the only thing that hides a canonical Bot Chat. Canonical chats are
+ *      identified by NAME; no stored id pointer is consulted anywhere here.
+ *
+ * Ported from tests/hide-bot-chats.test.mjs, which sliced the sweep out of
+ * the old plugin.js bundle and ran it under `vm`. The functions are module-
+ * private, so this drives them through the scheduler the plugin actually
+ * starts.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { GroupMember, ProfileRoute, RosterRow } from './types'
+
+interface SweepRow {
+  id: string
+  started_at?: number
+  title?: string
+}
+
+const { groupChats, hostMock, lastRoster, requestForBotMock } = vi.hoisted(() => ({
+  groupChats: { value: {} as Record<string, unknown> },
+  hostMock: {
+    listPersistedSessions: vi.fn(),
+    request: vi.fn(),
+    setPersistedSessionHidden: vi.fn(),
+    state: {
+      gateway: { listen: vi.fn(() => () => undefined) },
+      profile: { get: () => 'default' }
+    }
+  },
+  lastRoster: { value: [] as RosterRow[] },
+  requestForBotMock: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', () => ({ host: hostMock }))
+
+vi.mock('./canonical-chat', () => ({ PROFILE_SESSION_LIST_LIMIT: 200 }))
+
+vi.mock('./data', () => ({ $lastRoster: { get: () => lastRoster.value } }))
+
+vi.mock('./group-chat', () => ({ $groupChats: { get: () => groupChats.value } }))
+
+vi.mock('./group-membership', () => ({
+  groupMemberKey: (member: GroupMember) =>
+    member?.route?.connectionId ? `${member.route.connectionId}::${member.name}` : member?.name
+}))
+
+vi.mock('./routing', () => ({
+  backendTargetProfile: (route: null | ProfileRoute, fallback: string) => route?.targetProfile || fallback,
+  botConnectionRoute: (bot: RosterRow) =>
+    bot?.route ||
+    (bot?.remoteSource
+      ? { connectionId: bot.connectionId, mode: 'remote', profile: bot.name, targetProfile: bot.name }
+      : null),
+  requestForBot: requestForBotMock
+}))
+
+/** Every (route, options) pair the sweep pushed through the REST setter. */
+function hiddenCalls() {
+  return hostMock.setPersistedSessionHidden.mock.calls as Array<
+    [null | ProfileRoute, { hidden: boolean; profile: string; sessionId: string }]
+  >
+}
+
+/** Start the scheduler the plugin starts and let its first pass settle. The
+ *  sweep is scheduled on a macrotask, then runs as an unawaited promise
+ *  chain — three turns is well past what its resolved awaits need. */
+async function runSweep() {
+  const { startHideSweepScheduler } = await import('./session-sweep')
+
+  startHideSweepScheduler({})
+
+  for (let turn = 0; turn < 3; turn += 1) {
+    await new Promise(resolve => setTimeout(resolve, 0))
+  }
+}
+
+beforeEach(() => {
+  vi.resetModules()
+  vi.clearAllMocks()
+  // Date only: the scheduler's own setTimeout must stay real so runSweep can
+  // simply wait for it. 1_000_000ms puts `Date.now() / 1000` at 1000s, which
+  // is what the age fixtures below are written against.
+  vi.useFakeTimers({ toFake: ['Date'] })
+  vi.setSystemTime(1_000_000)
+  groupChats.value = {}
+  lastRoster.value = []
+  hostMock.listPersistedSessions.mockResolvedValue({ sessions: [] })
+  hostMock.setPersistedSessionHidden.mockResolvedValue(undefined)
+  hostMock.request.mockResolvedValue({})
+  requestForBotMock.mockResolvedValue({})
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('the id half: group room member sessions', () => {
+  it('hides every room member session exactly once', async () => {
+    groupChats.value = {
+      Core: { sessions: { alpha: 'room-core-a', beta: 'room-core-b' } },
+      // Duplicate id under the same key — must dedupe.
+      Quiet: { sessions: { alpha: 'room-core-a' } },
+      // Pre-sessions room shape.
+      Legacy: {}
+    }
+    lastRoster.value = [{ name: 'alpha' } as RosterRow]
+
+    await runSweep()
+
+    expect(
+      hiddenCalls()
+        .map(([, options]) => options.sessionId)
+        .sort()
+    ).toEqual(['room-core-a', 'room-core-b'])
+    expect(hiddenCalls().every(([, options]) => options.hidden)).toBe(true)
+  })
+
+  it('never consults a stored canonical pointer', async () => {
+    // Canonical Bot Chats are hidden by the TITLE sweep below — they are
+    // identified by name, not by pointer. The load-time reconciliation reads
+    // no bot-meta chat id and issues no id-verification RPC.
+    groupChats.value = { Core: { sessions: { alpha: 'room-core-a' } } }
+    lastRoster.value = [{ name: 'alpha' } as RosterRow]
+
+    await runSweep()
+
+    expect(requestForBotMock).not.toHaveBeenCalled()
+    expect(hostMock.request).not.toHaveBeenCalled()
+  })
+
+  it('routes a remote member session through its immutable persisted owner', async () => {
+    const owner = {
+      name: 'worker',
+      route: { connectionId: 'source-a', mode: 'remote', profile: 'worker', targetProfile: 'backend-worker' },
+      sourceScoped: true
+    }
+
+    groupChats.value = {
+      Core: { members: [owner], sessions: { 'source-a::worker': 'remote-room-1' } }
+    }
+    requestForBotMock.mockRejectedValue(new Error('gateway RPC must not be used'))
+
+    await runSweep()
+
+    expect(hiddenCalls()).toHaveLength(1)
+
+    const [route, options] = hiddenCalls()[0]
+
+    expect(route).toMatchObject({ connectionId: 'source-a', targetProfile: 'backend-worker' })
+    expect(options.sessionId).toBe('remote-room-1')
+  })
+
+  it('keeps two remote owners of the same session id on their own routes', async () => {
+    const owner = (connectionId: string) => ({
+      name: 'worker',
+      route: { connectionId, mode: 'remote', profile: 'worker', targetProfile: 'backend-worker' },
+      sourceScoped: true
+    })
+
+    groupChats.value = {
+      A: { sessionOwners: { 'source-a::worker': owner('source-a') }, sessions: { 'source-a::worker': 'same-id' } },
+      B: { sessionOwners: { 'source-b::worker': owner('source-b') }, sessions: { 'source-b::worker': 'same-id' } }
+    }
+    requestForBotMock.mockRejectedValue(new Error('gateway RPC must not be used'))
+
+    await runSweep()
+
+    expect(
+      hiddenCalls()
+        .map(([route]) => route?.connectionId)
+        .sort()
+    ).toEqual(['source-a', 'source-b'])
+    expect(hiddenCalls().every(([, options]) => options.sessionId === 'same-id')).toBe(true)
+  })
+
+  it('fails closed on a source-qualified session whose persisted owner is malformed', async () => {
+    // A source-qualified key without its immutable owner must never fall
+    // through to ambient routing — that hides whichever session happens to
+    // carry that id on the active connection.
+    groupChats.value = {
+      LegacyRemote: {
+        sessionOwners: { 'source-a::worker': { name: 'worker' } },
+        sessions: { 'source-a::worker': 'same-id' }
+      }
+    }
+    lastRoster.value = [{ name: 'worker' } as RosterRow]
+
+    await runSweep()
+
+    expect(hiddenCalls()).toHaveLength(0)
+    expect(requestForBotMock).not.toHaveBeenCalled()
+  })
+})
+
+describe('the title half: each roster bot’s own profile listing', () => {
+  const rowsByProfile: Record<string, SweepRow[]> = {
+    alpha: [
+      { id: 'a-1', started_at: 1, title: 'Bot Chat' },
+      { id: 'a-2', started_at: 1, title: 'Agent Inbox' },
+      { id: 'a-3', started_at: 1, title: 'Group: Core' },
+      { id: 'a-4', started_at: 1, title: 'My real conversation' },
+      // Not an exact title — kept.
+      { id: 'a-5', started_at: 1, title: 'Bot Chat notes' },
+      // Live draft inside the grace period — kept.
+      { id: 'a-6', started_at: 701, title: 'Bot Chat' },
+      // Missing age metadata — kept, fail closed.
+      { id: 'a-7', title: 'Agent Inbox' },
+      // Grace boundary reached — hidden.
+      { id: 'a-8', started_at: 700, title: 'Bot Chat' }
+    ],
+    remy: [{ id: 'r-1', started_at: 1, title: 'Agent Inbox' }]
+  }
+
+  beforeEach(() => {
+    lastRoster.value = [{ name: 'alpha' }, { connectionId: 'mini', name: 'remy', remoteSource: true }] as RosterRow[]
+    hostMock.listPersistedSessions.mockImplementation(async (_route: unknown, options: { profile: string }) => ({
+      sessions: rowsByProfile[options.profile] || []
+    }))
+  })
+
+  it('hides Bot-Mode plumbing titles per roster bot, and only those', async () => {
+    await runSweep()
+
+    const lists = hostMock.listPersistedSessions.mock.calls as Array<
+      [null | ProfileRoute, { include_hidden?: boolean; profile: string }]
+    >
+
+    expect(lists.map(([, options]) => options.profile).sort()).toEqual(['alpha', 'remy'])
+    // Visible-rows-only listing keeps the sweep idempotent.
+    expect(lists.every(([, options]) => !options.include_hidden)).toBe(true)
+
+    // Exact plumbing titles only — user-titled and brand-new rows stay visible.
+    expect(
+      hiddenCalls()
+        .map(([, options]) => options.sessionId)
+        .sort()
+    ).toEqual(['a-1', 'a-2', 'a-3', 'a-8', 'r-1'])
+    expect(hiddenCalls().every(([, options]) => options.hidden)).toBe(true)
+    // Remote-source rows keep their immutable source owner on the REST route.
+    expect(hiddenCalls().find(([, options]) => options.sessionId === 'r-1')?.[0]?.connectionId).toBe('mini')
+  })
+
+  it('runs beside the id half, and a throwing title sweep never breaks it', async () => {
+    // The load/reconnect entrypoint runs BOTH halves; the title sweep is
+    // best-effort, so an unreachable source must not cost the known ids.
+    groupChats.value = { Core: { sessions: { alpha: 'room-core-a' } } }
+    hostMock.listPersistedSessions.mockRejectedValue(new Error('gateway not ready'))
+
+    await runSweep()
+
+    expect(hiddenCalls().map(([, options]) => options.sessionId)).toEqual(['room-core-a'])
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/hygiene.test.ts b/apps/desktop/src/plugins/hermes-bots/hygiene.test.ts
new file mode 100644
index 000000000000..4da3bc30aa52
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/hygiene.test.ts
@@ -0,0 +1,205 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import type * as data from './data'
+import type * as groupChat from './group-chat'
+import { createGroupGateway, scriptedStorage } from './group-test-utils'
+import type * as hygiene from './hygiene'
+import type { GroupChat, GroupMember, RosterRow } from './types'
+
+// #93492 root fix: deleting a connection sweeps/annotates the persisted
+// group-chat member rows that referenced it (registry 'removed' push), and a
+// hydrate-time pass annotates rows orphaned before the sweep existed. Rows are
+// marked (sourceMissing → the existing 'Gateway removed' degraded state),
+// never silently deleted — the poisoned row lives in plugin storage, so a hard
+// delete would take the user's membership with it.
+
+const { host } = vi.hoisted(() => ({ host: {} as Record<string, unknown> }))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { pluginSdkMock } = await import('./group-test-utils')
+
+  return pluginSdkMock(host)
+})
+
+interface Rooms {
+  chat: typeof groupChat
+  data: typeof data
+  hygiene: typeof hygiene
+  writes: Map<string, unknown>
+}
+
+async function load(): Promise<Rooms> {
+  vi.resetModules()
+  const gateway = createGroupGateway()
+
+  for (const key of Object.keys(host)) {
+    delete host[key]
+  }
+
+  Object.assign(host, gateway.host)
+
+  const [chat, data, hygiene, shared] = await Promise.all([
+    import('./group-chat'),
+    import('./data'),
+    import('./hygiene'),
+    import('./shared')
+  ])
+
+  shared.setPluginCtx(scriptedStorage(gateway.storage))
+
+  return { chat, data, hygiene, writes: gateway.storage }
+}
+
+function member(overrides: Partial<GroupMember> = {}): GroupMember {
+  return {
+    connectionId: 'conn-gone',
+    handle: 'dixie',
+    name: 'dixie',
+    remoteSource: true,
+    route: { connectionId: 'conn-gone', mode: 'remote', profile: 'dixie', targetProfile: 'dixie' },
+    sourceScoped: true,
+    ...overrides
+  }
+}
+
+describe('removed-connection sweep', () => {
+  it('annotates matching members and persists; other rows are untouched', async () => {
+    const { chat, data, writes } = await load()
+    chat.$groupChats.set({
+      Crew: {
+        log: [{ at: 1, from: { kind: 'user', name: 'You' }, id: '1', text: 'hi' }],
+        members: [
+          member(),
+          member({
+            connectionId: 'conn-live',
+            name: 'bob',
+            route: { connectionId: 'conn-live', mode: 'remote', profile: 'bob', targetProfile: 'bob' }
+          })
+        ],
+        watermarks: {}
+      }
+    })
+
+    expect(chat.sweepGroupChatMembersForRemovedConnection('conn-gone')).toBe(true)
+
+    const room = chat.$groupChats.get().Crew
+    const swept = room.members?.find(row => row.name === 'dixie')
+    const kept = room.members?.find(row => row.name === 'bob')
+
+    // Annotated, not deleted: identity survives, marked degraded.
+    expect(room.members).toHaveLength(2)
+    expect(swept?.sourceMissing).toBe(true)
+    expect(swept?.sourceReachable).toBe(false)
+    expect(kept?.sourceMissing).toBeUndefined()
+    // The degraded mark renders as the existing 'Gateway removed' state.
+    expect(data.botSourceStatus(swept).label).toBe('Gateway removed')
+    // Persisted so the fix survives restarts (the poisoned row lived in storage).
+    expect(writes.has('group-chats')).toBe(true)
+  })
+
+  it('is idempotent and ignores blank ids', async () => {
+    const { chat } = await load()
+    chat.$groupChats.set({ Crew: { log: [], members: [member()], watermarks: {} } })
+
+    expect(chat.sweepGroupChatMembersForRemovedConnection('')).toBe(false)
+    expect(chat.sweepGroupChatMembersForRemovedConnection('conn-gone')).toBe(true)
+    // Already annotated: nothing left to change.
+    expect(chat.sweepGroupChatMembersForRemovedConnection('conn-gone')).toBe(false)
+  })
+})
+
+describe('hydrate-time annotate', () => {
+  it('marks lost-connectionId rows even without a registry', async () => {
+    const { data, hygiene } = await load()
+
+    const rooms: Record<string, GroupChat> = {
+      Crew: {
+        log: [],
+        // The exact persisted shape from #93492: remoteSource kept, connectionId
+        // NULLED. The descriptor type models it as absent, but what older builds
+        // actually wrote to disk is an explicit null — that is the shape the
+        // annotate pass has to recognise.
+        members: [
+          { connectionId: null, handle: 'halakukhan', name: 'halakukhan', remoteSource: true } as unknown as GroupMember
+        ],
+        watermarks: {}
+      }
+    }
+
+    const { rooms: next, changed } = hygiene.annotateOrphanedGroupChatMembers(rooms, null)
+
+    expect(changed).toBe(true)
+    expect(next.Crew.members?.[0].sourceMissing).toBe(true)
+    expect(data.botSourceStatus(next.Crew.members?.[0]).label).toBe('Gateway removed')
+  })
+
+  it('with a live registry, marks members on dead connections and keeps live and local ones', async () => {
+    const { hygiene } = await load()
+
+    const rooms: Record<string, GroupChat> = {
+      Crew: {
+        log: [],
+        members: [
+          member(),
+          member({
+            connectionId: 'conn-live',
+            name: 'bob',
+            route: { connectionId: 'conn-live', mode: 'remote', profile: 'bob', targetProfile: 'bob' }
+          }),
+          { name: 'local-pal' }
+        ],
+        watermarks: {}
+      }
+    }
+
+    const { rooms: next, changed } = hygiene.annotateOrphanedGroupChatMembers(rooms, new Set(['conn-live']))
+    const seated = (name: string) => next.Crew.members?.find(row => row.name === name)
+
+    expect(changed).toBe(true)
+    expect(seated('dixie')?.sourceMissing).toBe(true)
+    expect(seated('bob')?.sourceMissing).toBeUndefined()
+    expect(seated('local-pal')?.sourceMissing).toBeUndefined()
+  })
+
+  it('without a registry, touches only the unresolvable-route shape', async () => {
+    const { hygiene } = await load()
+
+    // conn-gone still has an id; without a registry we cannot prove it dead.
+    const { changed } = hygiene.annotateOrphanedGroupChatMembers(
+      { Crew: { log: [], members: [member()], watermarks: {} } },
+      null
+    )
+
+    expect(changed).toBe(false)
+  })
+})
+
+describe('render-path callers', () => {
+  it('degrade on an orphaned row instead of throwing', async () => {
+    const { chat } = await load()
+    const [membership, routing] = await Promise.all([import('./group-membership'), import('./routing')])
+
+    // Persisted-on-disk shape, nulled connectionId included (see above).
+    const orphaned = {
+      connectionId: null,
+      handle: 'halakukhan',
+      name: 'halakukhan',
+      remoteSource: true
+    } as unknown as RosterRow
+
+    // botWorkspaceOwnerKey (sidebar sync / Bots home / context menus)
+    expect(routing.botWorkspaceOwnerKey(orphaned)).toBe('bot:halakukhan')
+    // setBotsWorkspaceOwner (sidebar visibility listener)
+    expect(() => routing.setBotsWorkspaceOwner('bot:halakukhan', orphaned)).not.toThrow()
+    // durableGroupChatMembers (every group send / roster refresh)
+    expect(() => membership.durableGroupChatMembers([orphaned])).not.toThrow()
+
+    const durable = membership.durableGroupChatMembers([
+      { ...orphaned, sourceMissing: true, sourceReachable: false }
+    ])[0]
+
+    // The degraded mark survives the durable rebuild.
+    expect(durable.sourceMissing).toBe(true)
+    expect(chat.$groupChats.get()).toEqual({})
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/hygiene.ts b/apps/desktop/src/plugins/hermes-bots/hygiene.ts
new file mode 100644
index 000000000000..356af0b13ff0
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/hygiene.ts
@@ -0,0 +1,100 @@
+/**
+ * Deleted-connection roster hygiene: the pure half of the #93492 sweep.
+ *
+ * Marking a group-chat member descriptor whose connection is gone does not
+ * depend on where the rooms live, so it sits below the room store — the sweep
+ * in plugin.tsx drives these against the live atom.
+ */
+
+import type { GroupChat, GroupMember } from './types'
+
+// ── deleted-connection roster hygiene (#93492 root cause) ───────────────────
+// Deleting a cloud/remote connection used to leave every persisted group-chat
+// member descriptor that referenced it behind untouched. Those orphaned rows
+// (remoteSource: true, connection gone) are exactly the shape that made
+// render-path route lookups throw "Bot X has no connection owner" on every
+// group open, permanently — the poisoned row lives in plugin storage. The
+// sweep below runs on the registry's 'removed' push (and its annotate helper
+// again at hydrate for rows orphaned before this build). It never hard-deletes
+// user data: the member row is kept and marked, so panes render the existing
+// degraded 'Gateway removed' botSourceStatus state instead of crashing.
+
+/** Keep the member's identity; mark it so botSourceStatus reads
+ *  'Gateway removed' and no render-path route lookup can throw on it. */
+export function markOrphanedGroupMemberDescriptor(member: GroupMember): GroupMember {
+  return {
+    ...member,
+    sourceMissing: true,
+    sourceReachable: false
+  }
+}
+
+export function groupMemberReferencesConnection(member: GroupMember, connectionId: string) {
+  const id = String(connectionId || '').trim()
+
+  if (!id) {
+    return false
+  }
+
+  return String(member?.connectionId || '').trim() === id || String(member?.route?.connectionId || '').trim() === id
+}
+
+/** Hydrate-time pass for rows orphaned BEFORE this build (the poisoned rows
+ *  that made #93492 survive app restarts). Two shapes are annotated, never
+ *  deleted:
+ *  - a descriptor that already lost its connectionId (route unresolvable —
+ *    exactly what a stale row looks like once its connection was deleted);
+ *  - a descriptor whose connectionId is absent from the live registry, when
+ *    the caller could obtain one (liveConnectionIds === null means "registry
+ *    unavailable", which must NOT read as "everything is orphaned").
+ *  Pure on the rooms map; returns { rooms, changed }. */
+export function annotateOrphanedGroupChatMembers(
+  rooms: Record<string, GroupChat>,
+  liveConnectionIds: ReadonlySet<string> | null = null
+) {
+  // Duck-typed, not instanceof: callers (and vm-based tests) may hand a Set
+  // constructed in another realm.
+  const live = liveConnectionIds && typeof liveConnectionIds.has === 'function' ? liveConnectionIds : null
+  const next: Record<string, GroupChat> = {}
+  let changed = false
+
+  for (const [name, room] of Object.entries(rooms || {})) {
+    const members = Array.isArray(room?.members) ? room.members : []
+
+    const orphaned = (member: GroupMember) => {
+      if (!member || member.sourceMissing) {
+        return false
+      }
+
+      if (!member.sourceScoped && !member.remoteSource) {
+        return false
+      }
+
+      const id = String(member.route?.connectionId || member.connectionId || '').trim()
+
+      if (!id) {
+        // Route unresolvable: this is the row shape that threw on render.
+        return true
+      }
+
+      return live ? !live.has(id) : false
+    }
+
+    if (!members.some(orphaned)) {
+      next[name] = room
+
+      continue
+    }
+
+    changed = true
+    next[name] = {
+      ...room,
+      members: members.map(member => (orphaned(member) ? markOrphanedGroupMemberDescriptor(member) : member))
+    }
+  }
+
+  return {
+    rooms: next,
+    changed
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/i18n-test-helper.ts b/apps/desktop/src/plugins/hermes-bots/i18n-test-helper.ts
new file mode 100644
index 000000000000..34c6dd0fb99b
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/i18n-test-helper.ts
@@ -0,0 +1,25 @@
+/**
+ * Resolve a Bot Mode message key against the plugin's own `en` bundle.
+ *
+ * Tests that render Bot Mode components stub `usePluginI18n` with this instead
+ * of registering the bundle for real: registration normally happens in
+ * `ctx.register`, and the registry lives behind an app-internal module a plugin
+ * (or its tests) may not import.
+ */
+
+import { BOTS_LOCALES } from './i18n'
+
+export function translateBots(key: string, ...args: unknown[]): string {
+  const value = key
+    .split('.')
+    .reduce<unknown>(
+      (node, part) => (node && typeof node === 'object' ? (node as Record<string, unknown>)[part] : undefined),
+      BOTS_LOCALES.en
+    )
+
+  if (typeof value === 'function') {
+    return String((value as (...params: unknown[]) => string)(...args))
+  }
+
+  return typeof value === 'string' ? value : key
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/i18n.test.ts b/apps/desktop/src/plugins/hermes-bots/i18n.test.ts
new file mode 100644
index 000000000000..d2d162d84777
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/i18n.test.ts
@@ -0,0 +1,70 @@
+/**
+ * The English bundle is the message shape. ja / zh / zh-hant must cover the
+ * same leaves so a locale switch never falls through to a raw key — and the
+ * interpolators must still splice their arguments, not drop them.
+ */
+
+import { describe, expect, it } from 'vitest'
+
+import { BOTS_LOCALES } from './i18n'
+
+type Leaf = string | ((...args: never[]) => string)
+
+function leafEntries(node: unknown, prefix = ''): Array<[string, Leaf]> {
+  if (typeof node === 'function' || typeof node === 'string') {
+    return [[prefix, node as Leaf]]
+  }
+
+  return Object.entries(node as Record<string, unknown>).flatMap(([key, value]) =>
+    leafEntries(value, prefix ? `${prefix}.${key}` : key)
+  )
+}
+
+const en = BOTS_LOCALES.en
+const ja = BOTS_LOCALES.ja
+const zh = BOTS_LOCALES.zh
+const zhHant = BOTS_LOCALES['zh-hant']
+
+describe('BOTS_LOCALES', () => {
+  it('covers the English key tree in every shipped locale', () => {
+    expect(ja).toBeDefined()
+    expect(zh).toBeDefined()
+    expect(zhHant).toBeDefined()
+
+    const enPaths = leafEntries(en).map(([path]) => path)
+
+    expect(leafEntries(ja).map(([path]) => path)).toEqual(enPaths)
+    expect(leafEntries(zh).map(([path]) => path)).toEqual(enPaths)
+    expect(leafEntries(zhHant).map(([path]) => path)).toEqual(enPaths)
+  })
+
+  it('translates user-visible chrome instead of echoing English', () => {
+    const samples = ['roster.emptyTitle', 'bot.newTitle', 'group.manageTitle', 'tools.skillsHub'] as const
+    const enByPath = Object.fromEntries(leafEntries(en))
+
+    for (const locale of [ja, zh, zhHant]) {
+      const byPath = Object.fromEntries(leafEntries(locale))
+
+      for (const path of samples) {
+        expect(byPath[path]).not.toBe(enByPath[path])
+      }
+    }
+  })
+
+  it('keeps interpolator arguments in the translated string', () => {
+    const sentinel = 'QUERY_SENTINEL'
+    const gateway = 'GATEWAY_SENTINEL'
+
+    for (const locale of [en, ja, zh, zhHant]) {
+      const byPath = Object.fromEntries(leafEntries(locale))
+      const queryFn = byPath['roster.noMatchQuery'] as (query: string) => string
+      const bothFn = byPath['roster.noMatchQueryOn'] as (query: string, gateway: string) => string
+      const reasonFn = byPath['roster.rosterUnavailable'] as (reason: string) => string
+
+      expect(queryFn(sentinel)).toContain(sentinel)
+      expect(bothFn(sentinel, gateway)).toContain(sentinel)
+      expect(bothFn(sentinel, gateway)).toContain(gateway)
+      expect(reasonFn(sentinel)).toContain(sentinel)
+    }
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/i18n.ts b/apps/desktop/src/plugins/hermes-bots/i18n.ts
new file mode 100644
index 000000000000..5d25afa6cdc4
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/i18n.ts
@@ -0,0 +1,1066 @@
+/**
+ * Plugin-scoped i18n for Bot Mode — bundles registered under the plugin id via
+ * `ctx.i18n.register`, never touching core `en.ts`. Mirrors the kanban plugin:
+ * `usePluginI18n` returns a stringly-typed `t(key, …)`, and `useBots()` binds it
+ * to the message SHAPE so components keep typed `b.roster.search` access.
+ *
+ * Only strings Bot Mode OWNS live here. Generic verbs (Cancel, Delete, Remove,
+ * Retry, Close, Loading…) and shared vocabulary core already ships in every
+ * locale — weekday names, Daily/Hourly, Scheduled jobs — resolve against core
+ * via `useI18n()` / `translateNow()`. Duplicating those here would be a
+ * second, worse translation that drifts.
+ *
+ * Three kinds of literal deliberately stay hardcoded, and none of them is a
+ * missed key:
+ *
+ *  - **Prompts sent to a model**, not shown as chrome: the room-picture image
+ *    prompt and the scheduled-routine instruction. They are addressed to the
+ *    model, which reads English best.
+ *  - **Syntax and identifiers**: cron expressions and their examples, React
+ *    keys, workspace ids.
+ *  - **`'You'`**, the author marker on room-log entries. It is persisted into
+ *    the log and compared as a sentinel (`group-activity.ts`), so translating
+ *    it in place would break both. Localizing it needs the marker and its
+ *    rendering split apart — worth doing, not doable as a rename.
+ *
+ * Locales follow kanban: `en` / `ja` / `zh` / `zh-hant`. Arabic falls through
+ * the resolution chain (active locale → this plugin's `en` → the key) the
+ * same way a missing string in any locale does. Nouns match core: ボット /
+ * 机器人 / 機器人, プロファイル / 配置档案 / 設定檔, ゲートウェイ / 网关 / 閘道.
+ */
+
+import { type PluginLocaleBundles, type PluginTranslate, usePluginI18n } from '@hermes/plugin-sdk'
+import { useMemo } from 'react'
+
+import { getPluginCtx } from './shared'
+
+type BotsMessages = {
+  /** Left rail: the bot + group-chat roster. */
+  roster: {
+    search: string
+    searchPlaceholder: string
+    newBotOrGroup: string
+    groupChats: string
+    emptyTitle: string
+    emptyDesc: string
+    noMatchQuery: (query: string) => string
+    noMatchQueryOn: (query: string, gateway: string) => string
+    noMatchFiltersOn: (gateway: string) => string
+    noMatchFilters: string
+    clearFilters: string
+    allHidden: string
+    allHiddenDesc: string
+    showHidden: string
+    noHiddenMatch: string
+    hiddenFromRoster: string
+    pinned: string
+    needsAttention: string
+    needsInput: string
+    /** The kind filter's three options, in menu order. */
+    botsAndGroups: string
+    botsOnly: string
+    groupsOnly: string
+    /** The activity filter's four options, in menu order. */
+    anyActivity: string
+    activeNow: string
+    recentlyActive: string
+    older: string
+    /** How a row's owning gateway is doing — see `botSourceStatus`. */
+    gatewayRemoved: string
+    onDemand: string
+    ready: string
+    statusUnknown: string
+    unavailable: string
+    retryNow: string
+    rosterUnavailable: (reason: string) => string
+    waitingForGateway: string
+  }
+  /** Creating, editing and removing a bot. */
+  bot: {
+    newTitle: string
+    editTitle: string
+    helpPromptPlaceholder: string
+    descriptionHint: string
+    newChatWith: string
+    /** Re-opens the forever-chat on purpose. A plain row click only returns to
+     *  the tabs already open, so a closed Bot Chat needs an explicit ask. */
+    openBotChat: string
+    duplicate: string
+    duplicateFailed: string
+    deleteTitle: string
+    removeFromAllGroups: string
+    createFirstHint: string
+    createFailed: string
+    advanced: string
+    advancedHint: string
+    advancedFailed: string
+    openAnotherChatUnsupported: string
+    remoteConnectionsUnsupported: string
+    /** Stands under the bot's name in a chat it has not spoken in yet. */
+    chatEmpty: string
+    /** First line of a brand-new bot's forever-chat — see `kickoffText`. */
+    kickoff: string
+  }
+  /** Avatar picker: shapes, blobs, pets, uploads, generation. */
+  avatar: {
+    classicShapes: string
+    blobFromName: string
+    unlockFollowsName: string
+    randomize: string
+    /** The picker's four tabs, in order. */
+    tabBot: string
+    tabGenerate: string
+    upload: string
+    tabPet: string
+    removeImage: string
+    removeBackToShape: string
+    describePlaceholder: string
+    describeHint: string
+    matchTheName: string
+    pickPet: string
+    petLoadFailed: string
+    imageTooLarge: string
+    generationFailed: string
+    savedLocally: string
+    savedLocallyDescriptionFailed: string
+    generate: string
+    generating: string
+  }
+  /** Group chats: the room, its composer, threads and activity feed. */
+  group: {
+    newTitle: string
+    manageDesc: string
+    manageTitle: string
+    settingsTitle: string
+    settingsDesc: string
+    nameLabel: string
+    searchToAdd: string
+    searchToAddPlaceholder: string
+    removeFromSelection: string
+    disbandTitle: string
+    deleteTitle: string
+    deleteAction: string
+    composerPlaceholder: string
+    attachHint: string
+    newThread: string
+    reply: string
+    replyInThread: string
+    replyInThreadPlaceholder: string
+    openThread: string
+    collapseThread: string
+    collapseThreadLabel: string
+    activity: string
+    noActivityYet: string
+    showActivity: string
+    hideActivity: string
+    stop: string
+    stopHint: string
+    needsYourInput: string
+    pictureGenerationFailed: string
+    nameTaken: (name: string) => string
+    memberCount: (count: number) => string
+    settingsHint: (group: string) => string
+    settingsLabel: (group: string) => string
+    disbandHint: (group: string) => string
+    disbandLabel: (group: string) => string
+    disbandAction: string
+    disbanding: string
+    disbandDone: string
+    disbanded: (group: string) => string
+    /** Wraps the bolded group name, so the name can lead the sentence in
+     *  languages that put it there — see core's cron.deleteDesc* pair. */
+    disbandDescPrefix: string
+    disbandDescSuffix: (count: number) => string
+    stopped: (group: string) => string
+    removeAttachment: string
+    threadFallback: string
+    replyCount: (replies: number) => string
+    dropToThread: string
+    dropToRoom: string
+    waitingForAnswer: string
+    memberThinking: (name: string) => string
+    roomWorking: string
+    messageRoom: (group: string) => string
+    newThreadPlaceholder: (group: string) => string
+    everyoneMeta: string
+    commandApproval: string
+    answerFailed: (handle: string, error: string) => string
+    wantsToRunCommand: (handle: string) => string
+    asks: (handle: string) => string
+    answerTo: (member: string) => string
+  }
+  /** Skills hub + MCP setup surfaces embedded in the bot editor. */
+  tools: {
+    skillsHub: string
+    filterSkills: string
+    searchHub: string
+    noMcpServers: string
+  }
+
+  /** Bot-scoped scheduled jobs. Generic scheduling chrome (weekday names,
+   *  Daily/Hourly, the job verbs) resolves against core's `cron` section. */
+  cron: {
+    filterHint: string
+    needsRosterFirst: string
+    staleNotice: string
+    readFailure: string
+    createDesc: (bot: string) => string
+    instruction: string
+    whenToRun: string
+    dayOfMonth: string
+    sendResultsTo: string
+    runHistoryOnly: string
+    botChatTarget: (bot: string) => string
+    continuity: string
+    onceIn: (when: string) => string
+    everyNDays: (days: number) => string
+    everyNHours: (hours: number) => string
+    everyNMinutes: (minutes: number) => string
+    /** The frequency picker's eight options, in menu order. */
+    freqOnce: string
+    freqHourly: string
+    freqDaily: string
+    freqWeekdays: string
+    freqWeekly: string
+    freqMonthly: string
+    freqInterval: string
+    freqAdvanced: string
+    unitMinutes: string
+    unitHours: string
+    unitDays: string
+    /** One-line plain-language read-back of the picker's current state. */
+    runsOnce: (count: number, unit: string) => string
+    runsHourly: string
+    runsDaily: (time: string) => string
+    runsWeekdays: (time: string) => string
+    runsWeekly: (day: string, time: string) => string
+    runsMonthly: (day: string, time: string) => string
+    runsInterval: (count: number, unit: string) => string
+    runsRaw: string
+    timesTotal: (count: number) => string
+  }
+}
+
+const en: BotsMessages = {
+  roster: {
+    search: 'Search bots and group chats',
+    searchPlaceholder: 'Search bots and group chats…',
+    newBotOrGroup: 'New bot or group chat',
+    groupChats: 'Group chats',
+    emptyTitle: 'No bots yet',
+    emptyDesc: 'Create your first bot.',
+    noMatchQuery: query => `No bots or group chats match “${query}”`,
+    noMatchQueryOn: (query, gateway) => `No bots or group chats match “${query}” on ${gateway}`,
+    noMatchFiltersOn: gateway => `No bots or group chats match these filters on ${gateway}`,
+    noMatchFilters: 'No bots or group chats match these filters.',
+    clearFilters: 'Clear filters',
+    allHidden: 'All bots are hidden',
+    allHiddenDesc: 'They keep working and retain their history.',
+    showHidden: 'Show hidden bots',
+    noHiddenMatch: 'No hidden bots match these filters.',
+    hiddenFromRoster: 'Hidden from the roster',
+    pinned: 'Pinned',
+    needsAttention: 'needs attention',
+    needsInput: 'Needs your input',
+    botsAndGroups: 'Bots and group chats',
+    botsOnly: 'Bots only',
+    groupsOnly: 'Group chats only',
+    anyActivity: 'Any activity',
+    activeNow: 'Active now',
+    recentlyActive: 'Recently active',
+    older: 'Older',
+    gatewayRemoved: 'Gateway removed',
+    onDemand: 'On demand',
+    ready: 'Ready',
+    statusUnknown: 'Status unknown',
+    unavailable: 'Unavailable',
+    retryNow: 'Retry now',
+    rosterUnavailable: reason =>
+      `Roster unavailable: ${reason}. If your gateway predates profiles.list, update Hermes and restart the gateway.`,
+    waitingForGateway:
+      'Waiting for the gateway connection… (remote gateways can take a few seconds; retries automatically)'
+  },
+  bot: {
+    newTitle: 'New Bot',
+    editTitle: 'Edit Profile',
+    helpPromptPlaceholder: 'What should this bot help with?',
+    descriptionHint: 'Leave blank to generate from the bot’s name and description.',
+    newChatWith: 'New chat with this bot',
+    openBotChat: 'Open Bot Chat',
+    duplicate: 'Duplicate',
+    duplicateFailed: 'Duplicate failed',
+    deleteTitle: 'Delete bot and profile?',
+    removeFromAllGroups: 'Remove from all groups',
+    createFirstHint: 'Open the Bots pane and hit “New Bot”.',
+    createFailed: 'Could not create the profile yet',
+    advanced: 'Advanced',
+    advancedHint: 'Advanced — model, skills, toolsets, SOUL.md',
+    advancedFailed: 'Advanced configuration failed',
+    openAnotherChatUnsupported: 'Update Hermes Desktop to open another Bot chat.',
+    remoteConnectionsUnsupported: 'Update Hermes Desktop to chat with bots on other connections.',
+    chatEmpty: 'Say something to get started.',
+    kickoff: 'Hey, tell me about yourself!'
+  },
+  avatar: {
+    classicShapes: 'Classic shapes',
+    blobFromName: 'Blob face — drawn from the bot’s name',
+    unlockFollowsName: 'Unlock — the face follows the bot’s name again',
+    randomize: 'Randomize',
+    tabBot: 'Bot',
+    tabGenerate: 'Generate',
+    upload: 'Upload',
+    tabPet: 'Pet',
+    removeImage: 'Remove image — use shape',
+    removeBackToShape: 'Remove — back to shape avatar',
+    describePlaceholder: 'Describe your avatar…',
+    describeHint: 'Leave blank to auto-generate from name/title/description + agent-messaging roster.',
+    matchTheName: 'Match the name',
+    pickPet: 'Pick a pet as this bot’s profile picture.',
+    petLoadFailed: 'Could not load that pet — try another.',
+    imageTooLarge: 'Image too large (max 15MB).',
+    generationFailed: 'Avatar generation failed',
+    savedLocally: 'Saved look locally; remote persistence failed',
+    savedLocallyDescriptionFailed: 'Saved look locally; description update failed',
+    generate: 'Generate',
+    generating: 'Generating…'
+  },
+  group: {
+    newTitle: 'New Group Chat',
+    manageDesc: 'A bot can join multiple group chats. Memberships sync to every machine.',
+    manageTitle: 'Manage groups',
+    settingsTitle: 'Group settings',
+    settingsDesc: 'Rename the group or set a room picture. Members and history are kept.',
+    nameLabel: 'Group name',
+    searchToAdd: 'Search bots to add',
+    searchToAddPlaceholder: 'Search bots to add…',
+    removeFromSelection: 'Remove from selection',
+    disbandTitle: 'Disband group chat?',
+    deleteTitle: 'Delete group chat?',
+    deleteAction: 'Delete Group',
+    composerPlaceholder: 'Say something — every bot in this group hears the room.',
+    attachHint: 'Attach files — every responding bot sees them',
+    newThread: 'New Thread',
+    reply: 'Reply',
+    replyInThread: 'Reply in thread',
+    replyInThreadPlaceholder: 'Reply in thread…',
+    openThread: 'Open this thread',
+    collapseThread: 'Collapse thread',
+    collapseThreadLabel: 'Collapse this thread',
+    activity: 'Activity',
+    noActivityYet: 'No activity in this turn yet.',
+    showActivity: 'Show room activity',
+    hideActivity: 'Hide room activity',
+    stop: 'Stop',
+    stopHint: 'Stop this run — interrupts the member on turn and holds the rest',
+    needsYourInput: 'A bot in this group chat needs your input',
+    pictureGenerationFailed: 'Group picture generation failed',
+    nameTaken: name => `A group named “${name}” already exists.`,
+    memberCount: count => `${count} bots`,
+    settingsHint: group => `Group settings — rename ${group} or set a room picture`,
+    settingsLabel: group => `Group settings for ${group}`,
+    disbandHint: group => `Disband the ${group} group chat`,
+    disbandLabel: group => `Disband ${group}`,
+    disbandAction: 'Disband',
+    disbanding: 'Disbanding…',
+    disbandDone: 'Disbanded',
+    disbanded: group => `Disbanded “${group}”`,
+    disbandDescPrefix: 'This removes the ',
+    disbandDescSuffix: count =>
+      ` grouping from its ${count} bots and clears the shared room log. The bots themselves and their per-group sessions are kept.`,
+    stopped: group => `Stopped ${group} — remaining turns are held until you resume`,
+    removeAttachment: 'Remove attachment',
+    threadFallback: 'Thread',
+    replyCount: replies => `${replies} ${replies === 1 ? 'reply' : 'replies'}`,
+    dropToThread: 'Drop to attach to this thread reply',
+    dropToRoom: 'Drop to attach — every responding bot sees it',
+    waitingForAnswer: 'Waiting for your answer…',
+    memberThinking: name => `${name} is thinking…`,
+    roomWorking: 'The room is working…',
+    messageRoom: group => `Message ${group}`,
+    newThreadPlaceholder: group => `New thread in ${group}… (@name to direct, @everyone for all)`,
+    everyoneMeta: 'Every bot in the room',
+    commandApproval: 'command approval',
+    answerFailed: (handle, error) => `Could not send the answer to @${handle}: ${error}`,
+    wantsToRunCommand: handle => `@${handle} wants to run a command:`,
+    asks: handle => `@${handle} asks:`,
+    answerTo: member => `Answer @${member}`
+  },
+  tools: {
+    skillsHub: 'Hermes Skills Hub',
+    filterSkills: 'Filter skills…',
+    searchHub: 'Search the hub (community + well-known sources)…',
+    noMcpServers: 'No MCP servers configured or in the catalog.'
+  },
+  cron: {
+    filterHint:
+      'Scheduled jobs exist in this profile but none are tagged for this bot. Name a job "[bot:<name>] …" to show it here, or see them in Cron below.',
+    needsRosterFirst: 'This bot has to appear in the roster first.',
+    staleNotice: 'Could not refresh scheduled jobs. Showing the last list we had.',
+    readFailure: 'The list may still be there — this was a read failure, not a delete.',
+    createDesc: bot => `A recurring task ${bot} runs on a schedule. Runs land in its own chat history.`,
+    instruction: 'Instruction',
+    whenToRun: 'When to run',
+    dayOfMonth: 'Day of month',
+    sendResultsTo: 'Send results to',
+    runHistoryOnly: 'Run history only',
+    botChatTarget: bot => `${bot}’s chat (bot responds)`,
+    continuity: 'Continuity: each run sees the previous run’s output (dedupe, continue where it left off)',
+    onceIn: when => `Once (${when})`,
+    everyNDays: days => `Every ${days} days`,
+    everyNHours: hours => `Every ${hours}h`,
+    everyNMinutes: minutes => `Every ${minutes}m`,
+    freqOnce: 'Once, in…',
+    freqHourly: 'Every hour',
+    freqDaily: 'Every day',
+    freqWeekdays: 'Weekdays',
+    freqWeekly: 'Every week',
+    freqMonthly: 'Every month',
+    freqInterval: 'Interval',
+    freqAdvanced: 'Advanced…',
+    unitMinutes: 'minute(s)',
+    unitHours: 'hour(s)',
+    unitDays: 'day(s)',
+    runsOnce: (count, unit) => `Runs once, ${count} ${unit} from now`,
+    runsHourly: 'Runs at the top of every hour',
+    runsDaily: time => `Runs every day at ${time}`,
+    runsWeekdays: time => `Runs Monday–Friday at ${time}`,
+    runsWeekly: (day, time) => `Runs every ${day} at ${time}`,
+    runsMonthly: (day, time) => `Runs on day ${day} of each month at ${time}`,
+    runsInterval: (count, unit) => `Runs every ${count} ${unit}`,
+    runsRaw: 'Raw schedule — every Nm/Nh/Nd or 5-field cron',
+    timesTotal: count => `, ${count} time(s) total`
+  }
+}
+
+const ja: BotsMessages = {
+  roster: {
+    search: 'ボットとグループチャットを検索',
+    searchPlaceholder: 'ボットとグループチャットを検索…',
+    newBotOrGroup: '新しいボットまたはグループチャット',
+    groupChats: 'グループチャット',
+    emptyTitle: 'ボットはまだありません',
+    emptyDesc: '最初のボットを作成しましょう。',
+    noMatchQuery: query => `「${query}」に一致するボットやグループチャットはありません`,
+    noMatchQueryOn: (query, gateway) => `${gateway} に「${query}」に一致するボットやグループチャットはありません`,
+    noMatchFiltersOn: gateway => `${gateway} にこれらのフィルタに一致するボットやグループチャットはありません`,
+    noMatchFilters: 'これらのフィルタに一致するボットやグループチャットはありません。',
+    clearFilters: 'フィルタをクリア',
+    allHidden: 'すべてのボットが非表示です',
+    allHiddenDesc: '非表示でも動作を続け、履歴も残ります。',
+    showHidden: '非表示のボットを表示',
+    noHiddenMatch: 'これらのフィルタに一致する非表示ボットはありません。',
+    hiddenFromRoster: '名簿から非表示',
+    pinned: 'ピン留め',
+    needsAttention: '要対応',
+    needsInput: '入力が必要です',
+    botsAndGroups: 'ボットとグループチャット',
+    botsOnly: 'ボットのみ',
+    groupsOnly: 'グループチャットのみ',
+    anyActivity: 'すべてのアクティビティ',
+    activeNow: '現在アクティブ',
+    recentlyActive: '最近アクティブ',
+    older: '以前',
+    gatewayRemoved: 'ゲートウェイが削除されました',
+    onDemand: 'オンデマンド',
+    ready: '準備完了',
+    statusUnknown: '状態不明',
+    unavailable: '利用できません',
+    retryNow: '今すぐ再試行',
+    rosterUnavailable: reason =>
+      `名簿を取得できません: ${reason}。ゲートウェイが profiles.list より前の場合は、Hermes を更新してゲートウェイを再起動してください。`,
+    waitingForGateway: 'ゲートウェイ接続を待っています…（リモートは数秒かかることがあります。自動で再試行します）'
+  },
+  bot: {
+    newTitle: '新しいボット',
+    editTitle: 'プロファイルを編集',
+    helpPromptPlaceholder: 'このボットは何を手伝いますか？',
+    descriptionHint: '空欄のままにすると、ボットの名前と説明から生成します。',
+    newChatWith: 'このボットと新しいチャット',
+    openBotChat: 'ボットチャットを開く',
+    duplicate: '複製',
+    duplicateFailed: '複製に失敗しました',
+    deleteTitle: 'ボットとプロファイルを削除しますか？',
+    removeFromAllGroups: 'すべてのグループから外す',
+    createFirstHint: 'ボットパネルを開いて「新しいボット」を押してください。',
+    createFailed: 'プロファイルをまだ作成できませんでした',
+    advanced: '詳細設定',
+    advancedHint: '詳細設定 — モデル、スキル、ツールセット、SOUL.md',
+    advancedFailed: '詳細設定に失敗しました',
+    openAnotherChatUnsupported: '別のボットチャットを開くには Hermes Desktop を更新してください。',
+    remoteConnectionsUnsupported: '他の接続上のボットとチャットするには Hermes Desktop を更新してください。',
+    chatEmpty: '何か書いて始めましょう。',
+    kickoff: 'こんにちは、自己紹介をしてください！'
+  },
+  avatar: {
+    classicShapes: 'クラシックシェイプ',
+    blobFromName: 'ブロブ顔 — ボットの名前から描画',
+    unlockFollowsName: 'ロック解除 — 顔がボットの名前に再び追従します',
+    randomize: 'ランダム',
+    tabBot: 'ボット',
+    tabGenerate: '生成',
+    upload: 'アップロード',
+    tabPet: 'ペット',
+    removeImage: '画像を削除してシェイプを使う',
+    removeBackToShape: '削除 — シェイプアバターに戻す',
+    describePlaceholder: 'アバターを説明…',
+    describeHint: '空欄のままにすると、名前・タイトル・説明と agent-messaging の名簿から自動生成します。',
+    matchTheName: '名前に合わせる',
+    pickPet: 'このボットのプロフィール画像としてペットを選びます。',
+    petLoadFailed: 'そのペットを読み込めませんでした。別のペットを試してください。',
+    imageTooLarge: '画像が大きすぎます（最大 15MB）。',
+    generationFailed: 'アバターの生成に失敗しました',
+    savedLocally: '見た目はローカルに保存されましたが、リモートへの保存に失敗しました',
+    savedLocallyDescriptionFailed: '見た目はローカルに保存されましたが、説明の更新に失敗しました',
+    generate: '生成',
+    generating: '生成中…'
+  },
+  group: {
+    newTitle: '新しいグループチャット',
+    manageDesc: 'ボットは複数のグループチャットに参加できます。メンバーシップはすべてのマシンに同期されます。',
+    manageTitle: 'グループを管理',
+    settingsTitle: 'グループ設定',
+    settingsDesc: 'グループ名の変更や部屋の画像の設定ができます。メンバーと履歴は保持されます。',
+    nameLabel: 'グループ名',
+    searchToAdd: '追加するボットを検索',
+    searchToAddPlaceholder: '追加するボットを検索…',
+    removeFromSelection: '選択から外す',
+    disbandTitle: 'グループチャットを解散しますか？',
+    deleteTitle: 'グループチャットを削除しますか？',
+    deleteAction: 'グループを削除',
+    composerPlaceholder: '何か書いてください — このグループのすべてのボットが部屋の内容を受け取ります。',
+    attachHint: 'ファイルを添付 — 応答するすべてのボットが見ます',
+    newThread: '新しいスレッド',
+    reply: '返信',
+    replyInThread: 'スレッドで返信',
+    replyInThreadPlaceholder: 'スレッドで返信…',
+    openThread: 'このスレッドを開く',
+    collapseThread: 'スレッドを折りたたむ',
+    collapseThreadLabel: 'このスレッドを折りたたむ',
+    activity: 'アクティビティ',
+    noActivityYet: 'このターンのアクティビティはまだありません。',
+    showActivity: '部屋のアクティビティを表示',
+    hideActivity: '部屋のアクティビティを隠す',
+    stop: '停止',
+    stopHint: 'この実行を停止 — ターン中のメンバーを中断し、残りを保留します',
+    needsYourInput: 'このグループチャットのボットが入力を待っています',
+    pictureGenerationFailed: 'グループ画像の生成に失敗しました',
+    nameTaken: name => `「${name}」という名前のグループはすでに存在します。`,
+    memberCount: count => `ボット${count}体`,
+    settingsHint: group => `グループ設定 — ${group}の名前変更やルーム画像の設定`,
+    settingsLabel: group => `${group}のグループ設定`,
+    disbandHint: group => `${group}グループチャットを解散`,
+    disbandLabel: group => `${group}を解散`,
+    disbandAction: '解散',
+    disbanding: '解散中…',
+    disbandDone: '解散しました',
+    disbanded: group => `「${group}」を解散しました`,
+    disbandDescPrefix: '',
+    disbandDescSuffix: count =>
+      `のグループ分けをボット${count}体から解除し、共有ルームログを消去します。ボット自体と各グループのセッションは保持されます。`,
+    stopped: group => `${group}を停止しました — 残りのターンは再開するまで保留されます`,
+    removeAttachment: '添付を削除',
+    threadFallback: 'スレッド',
+    replyCount: replies => `返信${replies}件`,
+    dropToThread: 'ドロップしてこのスレッド返信に添付',
+    dropToRoom: 'ドロップして添付 — 応答するすべてのボットが見られます',
+    waitingForAnswer: 'あなたの回答を待っています…',
+    memberThinking: name => `${name}が考えています…`,
+    roomWorking: 'ルームが作業中です…',
+    messageRoom: group => `${group}にメッセージ`,
+    newThreadPlaceholder: group => `${group}で新しいスレッド…（@名前で個別、@everyoneで全員）`,
+    everyoneMeta: 'ルーム内のすべてのボット',
+    commandApproval: 'コマンドの承認',
+    answerFailed: (handle, error) => `@${handle}に回答を送信できませんでした: ${error}`,
+    wantsToRunCommand: handle => `@${handle}がコマンドを実行しようとしています:`,
+    asks: handle => `@${handle}からの質問:`,
+    answerTo: member => `@${member}に回答`
+  },
+  tools: {
+    skillsHub: 'Hermes スキルハブ',
+    filterSkills: 'スキルを絞り込み…',
+    searchHub: 'ハブを検索（コミュニティと既知のソース）…',
+    noMcpServers: '設定済みまたはカタログ内の MCP サーバーはありません。'
+  },
+  cron: {
+    filterHint:
+      'このプロファイルには定期実行ジョブがありますが、このボット向けのタグが付いたものはありません。ジョブ名を「[bot:<名前>] …」にするとここに表示されます。下のCronでも確認できます。',
+    needsRosterFirst: 'このボットは先に名簿に表示される必要があります。',
+    staleNotice: '定期実行ジョブを更新できませんでした。最後に取得したリストを表示しています。',
+    readFailure: 'リストはまだ存在している可能性があります — これは読み取りの失敗で、削除ではありません。',
+    createDesc: bot => `${bot}がスケジュールに沿って実行する定期タスクです。実行結果は専用のチャット履歴に残ります。`,
+    instruction: '指示',
+    whenToRun: '実行するタイミング',
+    dayOfMonth: '日付',
+    sendResultsTo: '結果の送信先',
+    runHistoryOnly: '実行履歴のみ',
+    botChatTarget: bot => `${bot}のチャット（ボットが応答）`,
+    continuity: '継続: 各実行が前回の出力を参照します（重複を避け、続きから実行）',
+    onceIn: when => `1回のみ（${when}）`,
+    everyNDays: days => `${days}日ごと`,
+    everyNHours: hours => `${hours}時間ごと`,
+    everyNMinutes: minutes => `${minutes}分ごと`,
+    freqOnce: '1回のみ、…後',
+    freqHourly: '毎時',
+    freqDaily: '毎日',
+    freqWeekdays: '平日',
+    freqWeekly: '毎週',
+    freqMonthly: '毎月',
+    freqInterval: '間隔',
+    freqAdvanced: '詳細…',
+    unitMinutes: '分',
+    unitHours: '時間',
+    unitDays: '日',
+    runsOnce: (count, unit) => `今から${count}${unit}後に1回実行します`,
+    runsHourly: '毎時0分に実行します',
+    runsDaily: time => `毎日${time}に実行します`,
+    runsWeekdays: time => `月曜〜金曜の${time}に実行します`,
+    runsWeekly: (day, time) => `毎週${day}の${time}に実行します`,
+    runsMonthly: (day, time) => `毎月${day}日の${time}に実行します`,
+    runsInterval: (count, unit) => `${count}${unit}ごとに実行します`,
+    runsRaw: '生のスケジュール — Nm/Nh/Nd または5フィールドのcron',
+    timesTotal: count => `、合計${count}回`
+  }
+}
+
+const zh: BotsMessages = {
+  roster: {
+    search: '搜索机器人和群聊',
+    searchPlaceholder: '搜索机器人和群聊…',
+    newBotOrGroup: '新建机器人或群聊',
+    groupChats: '群聊',
+    emptyTitle: '还没有机器人',
+    emptyDesc: '创建你的第一个机器人。',
+    noMatchQuery: query => `没有机器人或群聊匹配“${query}”`,
+    noMatchQueryOn: (query, gateway) => `${gateway} 上没有机器人或群聊匹配“${query}”`,
+    noMatchFiltersOn: gateway => `${gateway} 上没有机器人或群聊匹配这些筛选条件`,
+    noMatchFilters: '没有机器人或群聊匹配这些筛选条件。',
+    clearFilters: '清除筛选',
+    allHidden: '所有机器人都已隐藏',
+    allHiddenDesc: '它们会继续运行，并保留各自的历史。',
+    showHidden: '显示已隐藏的机器人',
+    noHiddenMatch: '没有已隐藏的机器人匹配这些筛选条件。',
+    hiddenFromRoster: '已从名单中隐藏',
+    pinned: '已置顶',
+    needsAttention: '需要处理',
+    needsInput: '需要你输入',
+    botsAndGroups: '机器人和群聊',
+    botsOnly: '仅机器人',
+    groupsOnly: '仅群聊',
+    anyActivity: '任何活动',
+    activeNow: '正在活动',
+    recentlyActive: '最近活跃',
+    older: '更早',
+    gatewayRemoved: '网关已移除',
+    onDemand: '按需',
+    ready: '就绪',
+    statusUnknown: '状态未知',
+    unavailable: '不可用',
+    retryNow: '立即重试',
+    rosterUnavailable: reason => `无法获取名单：${reason}。如果网关早于 profiles.list，请更新 Hermes 并重启网关。`,
+    waitingForGateway: '正在等待网关连接…（远程网关可能需要几秒；会自动重试）'
+  },
+  bot: {
+    newTitle: '新建机器人',
+    editTitle: '编辑配置档案',
+    helpPromptPlaceholder: '这个机器人应该帮你做什么？',
+    descriptionHint: '留空则根据机器人的名称和描述生成。',
+    newChatWith: '与此机器人开新聊天',
+    openBotChat: '打开机器人聊天',
+    duplicate: '复制',
+    duplicateFailed: '复制失败',
+    deleteTitle: '删除机器人和配置档案？',
+    removeFromAllGroups: '从所有群组中移除',
+    createFirstHint: '打开机器人面板，点击“新建机器人”。',
+    createFailed: '暂时无法创建配置档案',
+    advanced: '高级',
+    advancedHint: '高级 — 模型、技能、工具集、SOUL.md',
+    advancedFailed: '高级配置失败',
+    openAnotherChatUnsupported: '请更新 Hermes Desktop 以打开另一个机器人聊天。',
+    remoteConnectionsUnsupported: '请更新 Hermes Desktop 以与其他连接上的机器人聊天。',
+    chatEmpty: '说点什么开始吧。',
+    kickoff: '你好，介绍一下你自己吧！'
+  },
+  avatar: {
+    classicShapes: '经典形状',
+    blobFromName: '斑点脸 — 根据机器人名称绘制',
+    unlockFollowsName: '解锁 — 面孔再次跟随机器人名称',
+    randomize: '随机',
+    tabBot: '机器人',
+    tabGenerate: '生成',
+    upload: '上传',
+    tabPet: '宠物',
+    removeImage: '移除图片，改用形状',
+    removeBackToShape: '移除 — 回到形状头像',
+    describePlaceholder: '描述你的头像…',
+    describeHint: '留空则根据名称/标题/描述和 agent-messaging 名册自动生成。',
+    matchTheName: '匹配名称',
+    pickPet: '选择一只宠物作为此机器人的头像。',
+    petLoadFailed: '无法加载该宠物 — 请换一只试试。',
+    imageTooLarge: '图片过大（最大 15MB）。',
+    generationFailed: '头像生成失败',
+    savedLocally: '外观已保存在本地；远程持久化失败',
+    savedLocallyDescriptionFailed: '外观已保存在本地；描述更新失败',
+    generate: '生成',
+    generating: '生成中…'
+  },
+  group: {
+    newTitle: '新建群聊',
+    manageDesc: '一个机器人可以加入多个群聊。成员关系会同步到每台设备。',
+    manageTitle: '管理群组',
+    settingsTitle: '群组设置',
+    settingsDesc: '重命名群组或设置房间图片。成员和历史都会保留。',
+    nameLabel: '群组名称',
+    searchToAdd: '搜索要添加的机器人',
+    searchToAddPlaceholder: '搜索要添加的机器人…',
+    removeFromSelection: '从选择中移除',
+    disbandTitle: '解散群聊？',
+    deleteTitle: '删除群聊？',
+    deleteAction: '删除群组',
+    composerPlaceholder: '说点什么 — 这个群里的每个机器人都会听到。',
+    attachHint: '附加文件 — 每个回应的机器人都能看到',
+    newThread: '新帖子',
+    reply: '回复',
+    replyInThread: '在帖子中回复',
+    replyInThreadPlaceholder: '在帖子中回复…',
+    openThread: '打开此帖子',
+    collapseThread: '收起帖子',
+    collapseThreadLabel: '收起此帖子',
+    activity: '活动',
+    noActivityYet: '本回合还没有活动。',
+    showActivity: '显示房间活动',
+    hideActivity: '隐藏房间活动',
+    stop: '停止',
+    stopHint: '停止本次运行 — 中断当前回合的成员，并暂停其余成员',
+    needsYourInput: '此群聊中有机器人需要你输入',
+    pictureGenerationFailed: '群组图片生成失败',
+    nameTaken: name => `已存在名为“${name}”的群聊。`,
+    memberCount: count => `${count} 个机器人`,
+    settingsHint: group => `群聊设置 — 重命名 ${group} 或设置房间图片`,
+    settingsLabel: group => `${group} 的群聊设置`,
+    disbandHint: group => `解散 ${group} 群聊`,
+    disbandLabel: group => `解散 ${group}`,
+    disbandAction: '解散',
+    disbanding: '正在解散…',
+    disbandDone: '已解散',
+    disbanded: group => `已解散“${group}”`,
+    disbandDescPrefix: '',
+    disbandDescSuffix: count =>
+      ` 的分组将从 ${count} 个机器人中移除，并清空共享房间日志。机器人本身及其各群聊会话都会保留。`,
+    stopped: group => `已停止 ${group} — 其余轮次将保留到你恢复为止`,
+    removeAttachment: '移除附件',
+    threadFallback: '讨论串',
+    replyCount: replies => `${replies} 条回复`,
+    dropToThread: '拖放以附加到此讨论串回复',
+    dropToRoom: '拖放以附加 — 每个回应的机器人都能看到',
+    waitingForAnswer: '等待你的回答…',
+    memberThinking: name => `${name} 正在思考…`,
+    roomWorking: '房间正在处理…',
+    messageRoom: group => `发消息给 ${group}`,
+    newThreadPlaceholder: group => `在 ${group} 中开启新讨论串…（@名称指定，@everyone 全体）`,
+    everyoneMeta: '房间里的所有机器人',
+    commandApproval: '命令批准',
+    answerFailed: (handle, error) => `无法将回答发送给 @${handle}：${error}`,
+    wantsToRunCommand: handle => `@${handle} 想执行一个命令：`,
+    asks: handle => `@${handle} 的提问：`,
+    answerTo: member => `回答 @${member}`
+  },
+  tools: {
+    skillsHub: 'Hermes 技能中心',
+    filterSkills: '筛选技能…',
+    searchHub: '搜索技能中心（社区和常见来源）…',
+    noMcpServers: '未配置 MCP 服务器，目录中也没有。'
+  },
+  cron: {
+    filterHint:
+      '此配置档案中有定时任务，但没有一个标记给这个机器人。将任务命名为“[bot:<名称>] …”即可显示在这里，也可以在下方的 Cron 中查看。',
+    needsRosterFirst: '这个机器人需要先出现在名册中。',
+    staleNotice: '无法刷新定时任务。显示的是上一次获取的列表。',
+    readFailure: '列表可能仍然存在 — 这是一次读取失败，不是删除。',
+    createDesc: bot => `由 ${bot} 按计划运行的重复任务。运行结果会保存在它自己的聊天记录中。`,
+    instruction: '指令',
+    whenToRun: '运行时间',
+    dayOfMonth: '每月日期',
+    sendResultsTo: '结果发送到',
+    runHistoryOnly: '仅运行历史',
+    botChatTarget: bot => `${bot} 的聊天（机器人会回应）`,
+    continuity: '连续性：每次运行都能看到上次的输出（去重，从上次的地方继续）',
+    onceIn: when => `一次（${when}）`,
+    everyNDays: days => `每 ${days} 天`,
+    everyNHours: hours => `每 ${hours} 小时`,
+    everyNMinutes: minutes => `每 ${minutes} 分钟`,
+    freqOnce: '一次，在…之后',
+    freqHourly: '每小时',
+    freqDaily: '每天',
+    freqWeekdays: '工作日',
+    freqWeekly: '每周',
+    freqMonthly: '每月',
+    freqInterval: '间隔',
+    freqAdvanced: '高级…',
+    unitMinutes: '分钟',
+    unitHours: '小时',
+    unitDays: '天',
+    runsOnce: (count, unit) => `从现在起 ${count} ${unit}后运行一次`,
+    runsHourly: '每小时整点运行',
+    runsDaily: time => `每天 ${time} 运行`,
+    runsWeekdays: time => `周一至周五 ${time} 运行`,
+    runsWeekly: (day, time) => `每${day} ${time} 运行`,
+    runsMonthly: (day, time) => `每月 ${day} 日 ${time} 运行`,
+    runsInterval: (count, unit) => `每 ${count} ${unit}运行`,
+    runsRaw: '原始计划 — every Nm/Nh/Nd 或 5 段 cron',
+    timesTotal: count => `，共 ${count} 次`
+  }
+}
+
+const zhHant: BotsMessages = {
+  roster: {
+    search: '搜尋機器人和群組聊天',
+    searchPlaceholder: '搜尋機器人和群組聊天…',
+    newBotOrGroup: '新增機器人或群組聊天',
+    groupChats: '群組聊天',
+    emptyTitle: '還沒有機器人',
+    emptyDesc: '建立你的第一個機器人。',
+    noMatchQuery: query => `沒有機器人或群組聊天符合「${query}」`,
+    noMatchQueryOn: (query, gateway) => `${gateway} 上沒有機器人或群組聊天符合「${query}」`,
+    noMatchFiltersOn: gateway => `${gateway} 上沒有機器人或群組聊天符合這些篩選條件`,
+    noMatchFilters: '沒有機器人或群組聊天符合這些篩選條件。',
+    clearFilters: '清除篩選',
+    allHidden: '所有機器人都已隱藏',
+    allHiddenDesc: '它們會繼續運作，並保留各自的歷史。',
+    showHidden: '顯示已隱藏的機器人',
+    noHiddenMatch: '沒有已隱藏的機器人符合這些篩選條件。',
+    hiddenFromRoster: '已從名單中隱藏',
+    pinned: '已釘選',
+    needsAttention: '需要處理',
+    needsInput: '需要您的輸入',
+    botsAndGroups: '機器人和群組聊天',
+    botsOnly: '僅機器人',
+    groupsOnly: '僅群組聊天',
+    anyActivity: '任何活動',
+    activeNow: '目前活躍',
+    recentlyActive: '最近活躍',
+    older: '更早',
+    gatewayRemoved: '閘道已移除',
+    onDemand: '隨需',
+    ready: '就緒',
+    statusUnknown: '狀態未知',
+    unavailable: '不可用',
+    retryNow: '立即重試',
+    rosterUnavailable: reason => `無法取得名單：${reason}。如果閘道早於 profiles.list，請更新 Hermes 並重新啟動閘道。`,
+    waitingForGateway: '正在等待閘道連線…（遠端閘道可能需要幾秒；會自動重試）'
+  },
+  bot: {
+    newTitle: '新增機器人',
+    editTitle: '編輯設定檔',
+    helpPromptPlaceholder: '這個機器人應該幫你做什麼？',
+    descriptionHint: '留空則依機器人的名稱和描述產生。',
+    newChatWith: '與此機器人開新聊天',
+    openBotChat: '開啟機器人聊天',
+    duplicate: '複製',
+    duplicateFailed: '複製失敗',
+    deleteTitle: '刪除機器人和設定檔？',
+    removeFromAllGroups: '從所有群組中移除',
+    createFirstHint: '開啟機器人面板，點「新增機器人」。',
+    createFailed: '暫時無法建立設定檔',
+    advanced: '進階',
+    advancedHint: '進階 — 模型、技能、工具集、SOUL.md',
+    advancedFailed: '進階設定失敗',
+    openAnotherChatUnsupported: '請更新 Hermes Desktop 以開啟另一個機器人聊天。',
+    remoteConnectionsUnsupported: '請更新 Hermes Desktop 以與其他連線上的機器人聊天。',
+    chatEmpty: '說點什麼開始吧。',
+    kickoff: '你好，介紹一下你自己吧！'
+  },
+  avatar: {
+    classicShapes: '經典形狀',
+    blobFromName: '斑點臉 — 依機器人名稱繪製',
+    unlockFollowsName: '解鎖 — 面孔再次跟隨機器人名稱',
+    randomize: '隨機',
+    tabBot: '機器人',
+    tabGenerate: '生成',
+    upload: '上傳',
+    tabPet: '寵物',
+    removeImage: '移除圖片，改用形狀',
+    removeBackToShape: '移除 — 回到形狀頭像',
+    describePlaceholder: '描述你的頭像…',
+    describeHint: '留空則依名稱／標題／描述與 agent-messaging 名冊自動產生。',
+    matchTheName: '符合名稱',
+    pickPet: '選擇一隻寵物作為此機器人的頭像。',
+    petLoadFailed: '無法載入該寵物 — 請換一隻試試。',
+    imageTooLarge: '圖片過大（最大 15MB）。',
+    generationFailed: '頭像產生失敗',
+    savedLocally: '外觀已儲存在本機；遠端持久化失敗',
+    savedLocallyDescriptionFailed: '外觀已儲存在本機；描述更新失敗',
+    generate: '生成',
+    generating: '生成中…'
+  },
+  group: {
+    newTitle: '新增群組聊天',
+    manageDesc: '一個機器人可以加入多個群組聊天。成員關係會同步到每台裝置。',
+    manageTitle: '管理群組',
+    settingsTitle: '群組設定',
+    settingsDesc: '重新命名群組或設定房間圖片。成員和歷史都會保留。',
+    nameLabel: '群組名稱',
+    searchToAdd: '搜尋要加入的機器人',
+    searchToAddPlaceholder: '搜尋要加入的機器人…',
+    removeFromSelection: '從選取中移除',
+    disbandTitle: '解散群組聊天？',
+    deleteTitle: '刪除群組聊天？',
+    deleteAction: '刪除群組',
+    composerPlaceholder: '說點什麼 — 這個群組裡的每個機器人都會聽到。',
+    attachHint: '附加檔案 — 每個回應的機器人都能看到',
+    newThread: '新討論串',
+    reply: '回覆',
+    replyInThread: '在討論串中回覆',
+    replyInThreadPlaceholder: '在討論串中回覆…',
+    openThread: '開啟此討論串',
+    collapseThread: '收合討論串',
+    collapseThreadLabel: '收合此討論串',
+    activity: '活動',
+    noActivityYet: '本回合還沒有活動。',
+    showActivity: '顯示房間活動',
+    hideActivity: '隱藏房間活動',
+    stop: '停止',
+    stopHint: '停止本次執行 — 中斷目前回合的成員，並暫停其餘成員',
+    needsYourInput: '此群組聊天中有機器人需要您的輸入',
+    pictureGenerationFailed: '群組圖片產生失敗',
+    nameTaken: name => `已存在名為「${name}」的群組聊天。`,
+    memberCount: count => `${count} 個機器人`,
+    settingsHint: group => `群組設定 — 重新命名 ${group} 或設定房間圖片`,
+    settingsLabel: group => `${group} 的群組設定`,
+    disbandHint: group => `解散 ${group} 群組聊天`,
+    disbandLabel: group => `解散 ${group}`,
+    disbandAction: '解散',
+    disbanding: '正在解散…',
+    disbandDone: '已解散',
+    disbanded: group => `已解散「${group}」`,
+    disbandDescPrefix: '',
+    disbandDescSuffix: count =>
+      ` 的分組將從 ${count} 個機器人中移除，並清空共享房間日誌。機器人本身及其各群組工作階段都會保留。`,
+    stopped: group => `已停止 ${group} — 其餘回合將保留到你恢復為止`,
+    removeAttachment: '移除附件',
+    threadFallback: '討論串',
+    replyCount: replies => `${replies} 則回覆`,
+    dropToThread: '拖放以附加到此討論串回覆',
+    dropToRoom: '拖放以附加 — 每個回應的機器人都能看到',
+    waitingForAnswer: '等待你的回答…',
+    memberThinking: name => `${name} 正在思考…`,
+    roomWorking: '房間正在處理…',
+    messageRoom: group => `傳訊息給 ${group}`,
+    newThreadPlaceholder: group => `在 ${group} 中開啟新討論串…（@名稱指定，@everyone 全體）`,
+    everyoneMeta: '房間裡的所有機器人',
+    commandApproval: '命令核准',
+    answerFailed: (handle, error) => `無法將回答傳送給 @${handle}：${error}`,
+    wantsToRunCommand: handle => `@${handle} 想執行一個命令：`,
+    asks: handle => `@${handle} 的提問：`,
+    answerTo: member => `回覆 @${member}`
+  },
+  tools: {
+    skillsHub: 'Hermes 技能中心',
+    filterSkills: '篩選技能…',
+    searchHub: '搜尋技能中心（社群和常見來源）…',
+    noMcpServers: '未設定 MCP 伺服器，目錄中也沒有。'
+  },
+  cron: {
+    filterHint:
+      '此設定檔中有排程工作，但沒有任何一個標記給這個機器人。將工作命名為「[bot:<名稱>] …」即可顯示在這裡，也可以在下方的 Cron 中查看。',
+    needsRosterFirst: '這個機器人需要先出現在名冊中。',
+    staleNotice: '無法重新整理排程工作。顯示的是上一次取得的清單。',
+    readFailure: '清單可能仍然存在 — 這是一次讀取失敗，不是刪除。',
+    createDesc: bot => `由 ${bot} 按排程執行的重複工作。執行結果會保存在它自己的聊天紀錄中。`,
+    instruction: '指示',
+    whenToRun: '執行時間',
+    dayOfMonth: '每月日期',
+    sendResultsTo: '結果傳送到',
+    runHistoryOnly: '僅執行紀錄',
+    botChatTarget: bot => `${bot} 的聊天（機器人會回應）`,
+    continuity: '連續性：每次執行都能看到上次的輸出（去重，從上次的地方繼續）',
+    onceIn: when => `一次（${when}）`,
+    everyNDays: days => `每 ${days} 天`,
+    everyNHours: hours => `每 ${hours} 小時`,
+    everyNMinutes: minutes => `每 ${minutes} 分鐘`,
+    freqOnce: '一次，在…之後',
+    freqHourly: '每小時',
+    freqDaily: '每天',
+    freqWeekdays: '工作日',
+    freqWeekly: '每週',
+    freqMonthly: '每月',
+    freqInterval: '間隔',
+    freqAdvanced: '進階…',
+    unitMinutes: '分鐘',
+    unitHours: '小時',
+    unitDays: '天',
+    runsOnce: (count, unit) => `從現在起 ${count} ${unit}後執行一次`,
+    runsHourly: '每小時整點執行',
+    runsDaily: time => `每天 ${time} 執行`,
+    runsWeekdays: time => `週一至週五 ${time} 執行`,
+    runsWeekly: (day, time) => `每${day} ${time} 執行`,
+    runsMonthly: (day, time) => `每月 ${day} 日 ${time} 執行`,
+    runsInterval: (count, unit) => `每 ${count} ${unit}執行`,
+    runsRaw: '原始排程 — every Nm/Nh/Nd 或 5 段 cron',
+    timesTotal: count => `，共 ${count} 次`
+  }
+}
+
+/** Registered via `ctx.i18n.register` at plugin load (disposer tracked). */
+export const BOTS_LOCALES: PluginLocaleBundles = { en, ja, zh, 'zh-hant': zhHant }
+
+// Bind the message SHAPE to a plugin translator: string leaves resolve now,
+// function leaves forward their args through t(path, …).
+type Bound<T> = {
+  [K in keyof T]: T[K] extends (...args: infer A) => string
+    ? (...args: A) => string
+    : T[K] extends object
+      ? Bound<T[K]>
+      : string
+}
+
+function bind<T extends object>(t: PluginTranslate, template: T, prefix = ''): Bound<T> {
+  const out = {} as Record<string, unknown>
+
+  for (const [key, value] of Object.entries(template)) {
+    const path = prefix ? `${prefix}.${key}` : key
+    out[key] =
+      typeof value === 'function'
+        ? (...args: unknown[]) => t(path, ...args)
+        : value && typeof value === 'object'
+          ? bind(t, value as object, path)
+          : t(path)
+  }
+
+  return out as Bound<T>
+}
+
+export type BotsText = Bound<BotsMessages>
+
+/** The Bot Mode strings for the active locale — one hook every component reads. */
+export function useBots(): BotsText {
+  const t = usePluginI18n('hermes-bots')
+
+  return useMemo(() => bind(t, en), [t])
+}
+
+/** Resolve a dotted path against the English bundle — the floor for a read
+ *  that beats `ctx.i18n` into existence, so an unresolved key never ships as
+ *  the literal `cron.runsHourly`. */
+function english(key: string, ...args: unknown[]): string {
+  const leaf = key.split('.').reduce<unknown>((node, part) => (node as Record<string, unknown>)?.[part], en)
+
+  return typeof leaf === 'function' ? (leaf as (...a: unknown[]) => string)(...args) : String(leaf ?? key)
+}
+
+let bound: { text: BotsText; translate: PluginTranslate } | null = null
+
+/** `useBots` for the module-level functions a hook can't reach — the schedule
+ *  summarizers and label helpers that render inside components but aren't
+ *  components. Non-reactive on its own; every caller is invoked during a
+ *  render that a core `useI18n()` already subscribes to, so a locale switch
+ *  still repaints. Cached on translator identity: `bind` walks the whole tree,
+ *  and these run per row. */
+export function botsText(): BotsText {
+  const translate = getPluginCtx()?.i18n?.t ?? english
+
+  if (bound?.translate !== translate) {
+    bound = { text: bind(translate, en), translate }
+  }
+
+  return bound.text
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/labels.ts b/apps/desktop/src/plugins/hermes-bots/labels.ts
new file mode 100644
index 000000000000..39de2166e5a6
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/labels.ts
@@ -0,0 +1,90 @@
+/**
+ * The presentation leaves every Bot Mode surface reads: the name a row shows,
+ * the flattened one-line preview beside it, and the slug that identifies a
+ * workspace tile.
+ *
+ * They sit below the surfaces rather than inside any one of them — the roster,
+ * the bot row and the group-chat room all render the same identity, and none
+ * of them can own it without the others importing a sibling surface.
+ */
+
+import { aliasIdentityFor } from './routing'
+import type { BotMeta, RosterRow } from './types'
+
+export function displayName(bot: Partial<RosterRow>, meta?: BotMeta | null): string {
+  // A configured alias route claiming this row overrides source-derived
+  // identity: the friendly alias name must survive hosted-session
+  // activation and Cloud-only rosters (#89131).
+  const alias = aliasIdentityFor(bot)
+
+  // Only THIN rows from another source trade the friendly name for their
+  // connection label — the active gateway's own default must keep reading
+  // "Hermes". Annotated active rows carry sourceScoped too, and keying this
+  // off sourceScoped renamed the user's main agent to an IP-derived label
+  // (community report, Aug 17 2026).
+  if (
+    bot?.remoteSource &&
+    (bot.name || '').trim().toLowerCase() === 'default' &&
+    bot.connectionLabel &&
+    !alias &&
+    !meta?.title?.trim()
+  ) {
+    return bot.connectionLabel
+  }
+
+  if (meta?.title?.trim()) {
+    return meta.title.trim()
+  }
+
+  // Core-profile display name (profile.yaml, set via `hermes profile rename
+  // default <name>` or the dashboard) — the CLI-level equivalent of a Bot
+  // Mode title. Rides the profiles.list row; presentation-only.
+  if (typeof bot?.display_name === 'string' && bot.display_name.trim()) {
+    return bot.display_name.trim()
+  }
+
+  // An untitled backend row claimed by an alias reads as the alias name —
+  // never generic "Hermes" or a hostname-derived label.
+  if (alias) {
+    const raw = alias.name.replace(/[-_]+/g, ' ').trim()
+
+    return raw.replace(/\b\w/g, ch => ch.toUpperCase())
+  }
+
+  // The primary profile is literally named "default" — as a bot identity
+  // that reads like nobody bothered. Present it as Hermes (the agent it is)
+  // unless the user gives it a real title.
+  if ((bot.name || '').trim().toLowerCase() === 'default' && !bot.title) {
+    return 'Hermes'
+  }
+
+  const raw = (bot.title || bot.name || '').replace(/[-_]+/g, ' ').trim()
+
+  return raw.replace(/\b\w/g, ch => ch.toUpperCase())
+}
+
+export function slugify(value: string) {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64)
+}
+
+/** Flatten markdown syntax out of a one-line roster preview so rows read
+ *  like Discord's — no raw **bold**, `code`, > quotes, or [link](url)
+ *  characters in the preview line. */
+export function stripPreviewMarkdown(text: unknown) {
+  return String(text || '')
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/`([^`\n]*)`/g, '$1')
+    .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+    .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+    .replace(/(\*\*|__)(.*?)\1/g, '$2')
+    .replace(/(^|\s)[*_](\S(?:.*?\S)?)[*_](?=\s|$|[.,;:!?])/g, '$1$2')
+    .replace(/~~(.*?)~~/g, '$1')
+    .replace(/^\s{0,3}#{1,6}\s+/gm, '')
+    .replace(/^\s{0,3}>\s?/gm, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/legacy-sdk-compat.test.ts b/apps/desktop/src/plugins/hermes-bots/legacy-sdk-compat.test.ts
new file mode 100644
index 000000000000..acbf19c8ce4d
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/legacy-sdk-compat.test.ts
@@ -0,0 +1,77 @@
+/**
+ * Bot Mode has to keep linking against an OLDER desktop SDK.
+ *
+ * `McpTab`, `ToolsetConfigPanel` and `SkillsView` are capability exports: the
+ * shell that hosts the plugin may predate any of them. Every use site is
+ * therefore guarded, and the plugin module graph must evaluate — and still
+ * hand back a registrable plugin — when all three are missing. A bare
+ * top-level use of one of them turns a missing export into a blank Bots pane
+ * on an older build, which is exactly the failure this pins.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+/** Names an older SDK is allowed not to export. */
+const OPTIONAL_CAPABILITY_EXPORTS = new Set(['McpTab', 'SkillsView', 'ToolsetConfigPanel'])
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  // Everything an older SDK DOES export answers as a callable stand-in, so
+  // module-level `host.state.x.get()` / `foo()` evaluation succeeds without
+  // pinning the real surface.
+  const stub: unknown = new Proxy(function stubbed() {}, {
+    apply: () => stub,
+    get: (_target, key) => {
+      if (key === Symbol.iterator) {
+        return function* () {}
+      }
+
+      if (key === Symbol.toPrimitive) {
+        return () => 0
+      }
+
+      // Never look thenable: an awaited stub would hang the import.
+      if (key === 'then' || OPTIONAL_CAPABILITY_EXPORTS.has(String(key))) {
+        return undefined
+      }
+
+      return stub
+    }
+  })
+
+  return new Proxy({ atom } as Record<string, unknown>, {
+    get: (target, key) => {
+      if (typeof key === 'symbol' || key in target) {
+        return target[key as string]
+      }
+
+      // The namespace itself is awaited by the loader: a callable `then`
+      // would make it look thenable and never settle.
+      return key === 'then' || OPTIONAL_CAPABILITY_EXPORTS.has(key) ? undefined : stub
+    },
+    // The loader validates namespace access against the mock, so the
+    // capability names must READ as undefined rather than be absent —
+    // absent would throw where an older bundled SDK simply gives undefined.
+    has: () => true
+  })
+})
+
+describe('an SDK without the optional capability exports', () => {
+  it('still links Bot Mode into a registrable plugin', async () => {
+    const plugin = (await import('./plugin')).default
+
+    expect(plugin.id).toBe('hermes-bots')
+    expect(typeof plugin.register).toBe('function')
+  })
+
+  it('leaves the SkillsView connection-routing capability off', async () => {
+    // `skillsViewRoutesConnections` gates whether a source-scoped bot may open
+    // the Capabilities tab at all — with no SkillsView it must read false, not
+    // throw on the missing export.
+    const { SkillsView, skillsViewRoutesConnections } = await import('./profile-config')
+
+    expect(SkillsView).toBeUndefined()
+    expect(skillsViewRoutesConnections).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/mcp-setup.tsx b/apps/desktop/src/plugins/hermes-bots/mcp-setup.tsx
new file mode 100644
index 000000000000..16d280ae64d7
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/mcp-setup.tsx
@@ -0,0 +1,421 @@
+/**
+ * Inline per-profile MCP setup: the `mcp.servers.*` RPC wrapper, its
+ * feature-detect, and the button a capability row renders.
+ *
+ * Shared leaf: the advanced profile editor and the create dialog both render
+ * the button, so it lives below both.
+ */
+
+import { Button, host, Input, useI18n } from '@hermes/plugin-sdk'
+import { useEffect, useRef, useState } from 'react'
+
+// -- inline MCP setup (per-profile), driven by the mcp.servers.* gateway RPCs --
+// Feature-detected: if the gateway predates those RPCs the setup button hides
+// and the row falls back to the "run hermes mcp / Settings" hint. profile is
+// the target bot's profile name (its config is what we write).
+
+/** Body of an `mcp.servers.*` reply. Some gateway builds wrap it in a second
+ *  `result` envelope, which every call site below unwraps — hence the
+ *  self-reference. */
+interface McpServerPayload {
+  auth_url?: string
+  error?: string
+  error_message?: string
+  ok?: boolean
+  result?: McpServerPayload
+  session_id?: string
+  status?: string
+  verification_url?: string
+}
+
+/** `mcpRpc`'s outcome. `unsupported` separates an older gateway that doesn't
+ *  know the method from a real failure. */
+interface McpRpcResult {
+  error?: string
+  ok: boolean
+  result?: McpServerPayload
+  unsupported?: boolean
+}
+
+async function mcpRpc(method: string, params: Record<string, unknown>): Promise<McpRpcResult> {
+  // Returns { ok, result } or { ok:false, unsupported:true } when the gateway
+  // doesn't know the method (older backend) vs a real error.
+  try {
+    const res = await host.request<McpServerPayload>(method, params)
+
+    return {
+      ok: true,
+      result: res
+    }
+  } catch (err: any) {
+    const msg = String((err && err.message) || err || '')
+
+    if (/unknown method/i.test(msg)) {
+      return {
+        ok: false,
+        unsupported: true
+      }
+    }
+
+    return {
+      ok: false,
+      error: msg
+    }
+  }
+}
+
+// Probe whether the new lifecycle RPCs exist on this gateway (cached per session).
+let _mcpRpcSupported: boolean | null = null
+
+async function mcpSetupSupported(): Promise<boolean> {
+  if (_mcpRpcSupported !== null) {
+    return _mcpRpcSupported
+  }
+
+  const r = await mcpRpc('mcp.servers.list', {})
+  _mcpRpcSupported = !(r.ok === false && r.unsupported)
+
+  return _mcpRpcSupported
+}
+
+/** One row of the capability pane's MCP list (catalog entry or installed server). */
+interface McpCatalogEntry {
+  auth?: null | string
+  fromCatalog?: boolean
+  installed?: boolean
+  name: string
+  requires?: string[]
+}
+
+/** The capability scope the Edit Profile / New Bot panes hand down — the SDK's
+ *  `ProfileScope`: a bare profile name, or a connection-qualified scope for a
+ *  source-scoped bot. */
+type McpSetupScope = null | string | undefined | { connectionId?: null | string; profile?: null | string }
+
+interface McpSetupButtonProps {
+  ensureProfile?: () => Promise<null | string>
+  entry: McpCatalogEntry
+  onDone?: () => void
+  // TODO(bot-mode-types): Edit Profile passes `botBackendProfileScope(...)`, which
+  // is a `{ connectionId, profile }` OBJECT for every source-scoped bot. That
+  // object is forwarded verbatim as the `profile` param of mcp.servers.add /
+  // set_api_key / test / oauth.*, where the gateway expects a profile NAME
+  // string — and mcpRpc goes through host.request, so the connection isn't
+  // routed either. Typed as-written.
+  profile: McpSetupScope
+}
+
+export function McpSetupButton({ profile, entry, onDone, ensureProfile }: McpSetupButtonProps) {
+  const { t } = useI18n()
+  // entry: { name, requires:[env keys], auth?, fromCatalog, installed }
+  // profile may be null at first (New Bot: the profile isn't created yet).
+  // ensureProfile() lazily creates it on the first setup action and returns the
+  // slug, so OAuth / API-key setup works DURING creation, not only in Edit.
+  const [phase, setPhase] = useState<'busy' | 'done' | 'error' | 'idle' | 'keys' | 'oauth'>('idle') // idle | keys | oauth | busy | done | error
+  const [supported, setSupported] = useState<boolean | null>(null)
+  const [keyValues, setKeyValues] = useState<Record<string, string>>({})
+  const [message, setMessage] = useState('')
+  const pollRef = useRef<ReturnType<typeof setInterval> | null>(null)
+  // Holds ONLY the profile this component created on demand. The live prop
+  // wins wherever both exist, so there is nothing to mirror into the ref and
+  // no render of lag between the parent supplying a profile and us using it.
+  const createdProfileRef = useRef<McpSetupScope>(null)
+
+  // Resolve the target profile, creating it on demand for the New Bot flow.
+  const resolveProfile = async () => {
+    const known = profile || createdProfileRef.current
+
+    if (known) {
+      return known
+    }
+
+    if (ensureProfile) {
+      const created = await ensureProfile()
+
+      if (created) {
+        createdProfileRef.current = created
+      }
+
+      return created
+    }
+
+    return null
+  }
+
+  // eslint-disable-next-line no-restricted-syntax -- clears a timer handle on unmount, not an atom mirror
+  useEffect(() => {
+    let alive = true
+    mcpSetupSupported().then(ok => {
+      if (alive) {
+        setSupported(ok)
+      }
+    })
+
+    return () => {
+      alive = false
+
+      if (pollRef.current) {
+        clearInterval(pollRef.current)
+        pollRef.current = null
+      }
+    }
+  }, [])
+  const isOAuth = (entry.auth || '').toLowerCase() === 'oauth'
+  const requires = entry.requires || []
+
+  const beginKeys = async () => {
+    // Ensure the server exists in the target profile first (add from catalog).
+    setPhase('busy')
+    setMessage('')
+    const profile = await resolveProfile()
+
+    if (!profile) {
+      setPhase('idle')
+
+      return
+    }
+
+    if (entry.fromCatalog && !entry.installed) {
+      const add = await mcpRpc('mcp.servers.add', {
+        profile,
+        name: entry.name,
+        preset: entry.name
+      })
+
+      if (!add.ok) {
+        setPhase('error')
+        setMessage(add.error || 'Could not add server')
+
+        return
+      }
+    }
+
+    setPhase(isOAuth ? 'oauth' : 'keys')
+  }
+
+  const submitKeys = async () => {
+    setPhase('busy')
+    const target = profile || createdProfileRef.current
+
+    if (!target) {
+      setPhase('error')
+      setMessage('No target profile')
+
+      return
+    }
+
+    for (const k of requires) {
+      const val = (keyValues[k] || '').trim()
+
+      if (!val) {
+        continue
+      }
+
+      const r = await mcpRpc('mcp.servers.set_api_key', {
+        profile: target,
+        name: entry.name,
+        env_var: k,
+        value: val
+      })
+
+      if (!r.ok) {
+        setPhase('error')
+        setMessage(r.error || 'Failed to set ' + k)
+
+        return
+      }
+    }
+
+    // Verify via test.
+    const t = await mcpRpc('mcp.servers.test', {
+      profile: target,
+      name: entry.name
+    })
+
+    if (t.ok && t.result && (t.result.ok || (t.result.result && t.result.result.ok))) {
+      setPhase('done')
+      host.notify({
+        kind: 'success',
+        message: entry.name + ' configured'
+      })
+      onDone && onDone()
+    } else {
+      setPhase('error')
+      setMessage(
+        (t.result && (t.result.error || (t.result.result && t.result.result.error))) || 'Server test failed after setup'
+      )
+    }
+  }
+
+  const beginOAuth = async () => {
+    // A second click (retry, impatient double-click) must not orphan the
+    // previous poll interval — an overwritten pollRef leaks a 2s poller that
+    // runs until unmount and can flip phase from a stale OAuth session.
+    if (pollRef.current) {
+      clearInterval(pollRef.current)
+      pollRef.current = null
+    }
+
+    setPhase('busy')
+    setMessage('')
+    const profile = await resolveProfile()
+
+    if (!profile) {
+      setPhase('idle')
+
+      return
+    }
+
+    if (entry.fromCatalog && !entry.installed) {
+      const add = await mcpRpc('mcp.servers.add', {
+        profile,
+        name: entry.name,
+        preset: entry.name
+      })
+
+      if (!add.ok) {
+        setPhase('error')
+        setMessage(add.error || 'Could not add server')
+
+        return
+      }
+    }
+
+    const start = await mcpRpc('mcp.servers.oauth.start', {
+      profile,
+      name: entry.name
+    })
+
+    const payload = start.result && (start.result.result || start.result)
+    const authUrl = payload && (payload.auth_url || payload.verification_url)
+    const sessionId = payload && payload.session_id
+
+    if (!start.ok || !authUrl || !sessionId) {
+      setPhase('error')
+      setMessage(start.error || 'Could not start OAuth')
+
+      return
+    }
+
+    // Open the auth URL in the native browser, same as provider OAuth.
+    // TODO(bot-mode-types): the plugin SDK's `host` has no `openExternal`, so this
+    // branch is dead and the window bridge / window.open fallbacks are the only
+    // live paths. `ctx.os.openExternal` is the real verb. Kept as-written under
+    // ts-expect-error, which reports itself as unused the day the SDK grows one.
+    try {
+      // @ts-expect-error TODO(bot-mode-types): not on the SDK host, branch is dead
+      if (host.openExternal) {
+        // @ts-expect-error TODO(bot-mode-types): not on the SDK host, branch is dead
+        host.openExternal(authUrl)
+      } else if (typeof window !== 'undefined' && window.hermesDesktop && window.hermesDesktop.openExternal) {
+        window.hermesDesktop.openExternal(authUrl)
+      } else {
+        window.open(authUrl, '_blank')
+      }
+    } catch {
+      /* fall through to poll; user can open the URL from the toast */
+    }
+
+    setPhase('oauth')
+    setMessage('Complete sign-in in your browser...')
+    pollRef.current = setInterval(async () => {
+      const poll = await mcpRpc('mcp.servers.oauth.poll', {
+        profile,
+        name: entry.name,
+        session_id: sessionId
+      })
+
+      const pd = poll.result && (poll.result.result || poll.result)
+      const status = pd && pd.status
+
+      if (status === 'approved') {
+        clearInterval(pollRef.current!)
+        pollRef.current = null
+        setPhase('done')
+        host.notify({
+          kind: 'success',
+          message: entry.name + ' authenticated'
+        })
+        onDone && onDone()
+      } else if (status === 'error') {
+        clearInterval(pollRef.current!)
+        pollRef.current = null
+        setPhase('error')
+        setMessage((pd && pd.error_message) || 'OAuth failed')
+      }
+    }, 2000)
+  }
+
+  if (supported === false) {
+    return (
+      <span className="ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)">
+        {'needs setup (' + requires.join(', ') + ') \u2014 restart the gateway to enable in-app setup'}
+      </span>
+    )
+  }
+
+  if (phase === 'done') {
+    return <span className="ml-1.5 text-[0.65rem] text-(--ui-success)">set up ✓</span>
+  }
+
+  if (phase === 'keys') {
+    return (
+      <div className="mt-1 grid gap-1">
+        {requires.map(k => (
+          <Input
+            className="h-6 text-[0.7rem]"
+            key={k}
+            onChange={e =>
+              setKeyValues(prev => ({
+                ...prev,
+                [k]: e.target.value
+              }))
+            }
+            placeholder={k}
+            type="password"
+            value={keyValues[k] || ''}
+          />
+        ))}
+        <div className="flex gap-1">
+          <Button onClick={() => void submitKeys()} size="xs" variant="secondary">
+            Save & test
+          </Button>
+          <Button onClick={() => setPhase('idle')} size="xs" variant="ghost">
+            {t.common.cancel}
+          </Button>
+        </div>
+      </div>
+    )
+  }
+
+  if (phase === 'oauth') {
+    return <span className="ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)">{message || 'Authorizing\u2026'}</span>
+  }
+
+  if (phase === 'busy') {
+    return <span className="ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)">Working…</span>
+  }
+
+  if (phase === 'error') {
+    return (
+      <span className="ml-1.5 text-[0.65rem] text-(--ui-danger,#f87171)">
+        {(message || 'Setup failed') + ' '}
+        <Button className="underline" onClick={() => setPhase('idle')} size="inline" variant="link">
+          retry
+        </Button>
+      </span>
+    )
+  }
+
+  // idle
+  return (
+    <Button
+      className="ml-1.5 text-[0.65rem] text-(--ui-accent) underline"
+      onClick={() => void (isOAuth ? beginOAuth() : beginKeys())}
+      size="inline"
+      variant="link"
+    >
+      {isOAuth ? 'Sign in\u2026' : 'Set up\u2026'}
+    </Button>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/model-picker.test.tsx b/apps/desktop/src/plugins/hermes-bots/model-picker.test.tsx
new file mode 100644
index 000000000000..8c88b61688a6
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/model-picker.test.tsx
@@ -0,0 +1,159 @@
+/**
+ * #95279: the Bot Mode model picker's catalog read must always SETTLE, and it
+ * must not churn the network on every surface remount.
+ *
+ * The read rides the BOT's own socket — a second, lazily dialed pool backend
+ * that can wedge (cold pool spawn, dropped remote hop) without the primary
+ * socket noticing. Two defects made the picker unusable while Bots was active:
+ *
+ *   1. The RPC had no deadline, so a wedged dial left it pending forever and
+ *      the spinner never settled ("model picker never settles").
+ *   2. Every fetch forced `refresh: true`, bypassing the react-query cache, so
+ *      each Bots view remount (tab re-front, dialog reopen, pane visibility
+ *      flip) knocked the picker back into loading and discarded the staged
+ *      selection mid-edit.
+ *
+ * Pinned here through the real component: bounded settlement into the
+ * free-text fallback, one cached unforced read across remounts, and no
+ * dispatch at all for a row whose connection is gone.
+ */
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { render, waitFor } from '@testing-library/react'
+import type { ReactNode } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { ModelPicker } from './model-picker'
+import type { RosterRow } from './types'
+
+const { hostMock } = vi.hoisted(() => ({
+  hostMock: {
+    request: vi.fn(),
+    requestProfile: vi.fn(),
+    state: { connectionId: { get: () => 'local' }, gateway: { get: () => 'open' }, profile: { get: () => 'default' } }
+  }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { useQuery } = await import('@tanstack/react-query')
+
+  return {
+    Button: (props: React.ComponentProps<'button'>) => <button {...props} />,
+    GlyphSpinner: () => <span data-testid="spinner" />,
+    host: hostMock,
+    Input: (props: React.ComponentProps<'input'>) => <input {...props} />,
+    Select: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+    SelectContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+    SelectItem: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+    SelectTrigger: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+    SelectValue: () => null,
+    useQuery
+  }
+})
+
+vi.mock('./shared', () => ({ ID: 'hermes-bots' }))
+
+const remoteBot = {
+  connectionId: 'remote-a',
+  name: 'default',
+  remoteSource: true,
+  route: { connectionId: 'remote-a', mode: 'remote', profile: 'default', targetProfile: 'backend-default' },
+  sourceScoped: true,
+  targetProfile: 'backend-default'
+} as RosterRow
+
+/** One client per render group, so "did the remount refetch?" is a real
+ *  question about the cache rather than about a fresh store. */
+let client: QueryClient
+
+function mount(bot: null | RosterRow) {
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>{children}</QueryClientProvider>
+  )
+
+  return render(<ModelPicker bot={bot} onChange={vi.fn()} value={{ model: '', provider: '' }} />, { wrapper })
+}
+
+/** The fallback the picker paints when the catalog is unavailable. */
+const isFreeText = (container: HTMLElement) =>
+  Boolean(container.querySelector('input[placeholder*="omnirouter"]')) &&
+  !container.querySelector('[data-testid="spinner"]')
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('a bot gateway that never answers', () => {
+  it('settles into the free-text fallback instead of spinning forever', async () => {
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+    hostMock.requestProfile.mockReturnValue(new Promise(() => undefined))
+
+    const { container } = mount(remoteBot)
+
+    expect(container.querySelector('[data-testid="spinner"]')).toBeTruthy()
+
+    await vi.advanceTimersByTimeAsync(30_000)
+    await waitFor(() => expect(isFreeText(container)).toBe(true))
+  })
+})
+
+describe('the catalog read', () => {
+  it('rides the bot’s own route, unforced, and survives a remount from cache', async () => {
+    hostMock.requestProfile.mockResolvedValue({ providers: [{ models: ['m1'], name: 'Prov', slug: 'prov' }] })
+
+    const first = mount(remoteBot)
+
+    await waitFor(() => expect(hostMock.requestProfile).toHaveBeenCalledTimes(1))
+
+    expect(hostMock.requestProfile).toHaveBeenCalledWith(remoteBot.route, 'model.options', {
+      explicit_only: false,
+      include_unconfigured: true
+    })
+    // A forced refresh here is what re-entered the loading state on every
+    // remount and wiped the user's in-progress pick.
+    expect(hostMock.requestProfile.mock.calls[0][2]).not.toHaveProperty('refresh')
+
+    first.unmount()
+
+    const second = mount(remoteBot)
+
+    await waitFor(() => expect(second.container.querySelector('[data-testid="spinner"]')).toBeNull())
+    expect(hostMock.requestProfile).toHaveBeenCalledTimes(1)
+  })
+
+  it('never dispatches for a row whose connection was removed', async () => {
+    const orphan = { name: 'ghost', remoteSource: true } as RosterRow
+    const { container } = mount(orphan)
+
+    await waitFor(() => expect(isFreeText(container)).toBe(true))
+    expect(hostMock.request).not.toHaveBeenCalled()
+    expect(hostMock.requestProfile).not.toHaveBeenCalled()
+  })
+
+  it('reads the ambient gateway for a local bot', async () => {
+    hostMock.request.mockResolvedValue({ providers: [] })
+
+    mount({ name: 'default' } as RosterRow)
+
+    await waitFor(() => expect(hostMock.request).toHaveBeenCalledTimes(1))
+    expect(hostMock.request).toHaveBeenCalledWith('model.options', {
+      explicit_only: false,
+      include_unconfigured: true
+    })
+  })
+
+  it('shares one cache entry between two bots on the same route', async () => {
+    hostMock.requestProfile.mockResolvedValue({ providers: [{ models: ['m1'], slug: 'prov' }] })
+
+    mount(remoteBot)
+    await waitFor(() => expect(hostMock.requestProfile).toHaveBeenCalledTimes(1))
+
+    mount({ ...remoteBot, name: 'default' } as RosterRow)
+    await waitFor(() => expect(hostMock.requestProfile).toHaveBeenCalledTimes(1))
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/model-picker.tsx b/apps/desktop/src/plugins/hermes-bots/model-picker.tsx
new file mode 100644
index 000000000000..b9645b81c1ae
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/model-picker.tsx
@@ -0,0 +1,292 @@
+/**
+ * Provider + model dropdowns backed by the gateway's `model.options`
+ * inventory, plus the bounded fetch that keeps a wedged bot socket from
+ * spinning the picker forever.
+ *
+ * Shared by the advanced profile editor and the create dialog.
+ */
+
+import {
+  Button,
+  GlyphSpinner,
+  Input,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  useQuery
+} from '@hermes/plugin-sdk'
+import { useState } from 'react'
+
+import { labeled } from './dialog-parts'
+import { botRouteKey, requestForBot, resolveBotConnectionRoute } from './routing'
+import { ID } from './shared'
+import type { RosterRow } from './types'
+
+// ── model picker (provider/model dropdowns via model.options) ───────────────
+
+// #95279: the picker's catalog read rides the BOT's own socket — a lazily
+// dialed second backend that can wedge (cold pool spawn, dropped remote hop)
+// without the primary socket ever noticing. An unbounded RPC there left the
+// query pending forever and the picker spinning ("never settles"). Bound every
+// attempt: past the budget the query rejects and ModelPicker falls back to its
+// free-text inputs instead of an eternal GlyphSpinner.
+const MODEL_OPTIONS_SETTLE_MS = 20000
+
+function boundedModelOptionsFetch<T>(fetch: Promise<T>, settleMs = MODEL_OPTIONS_SETTLE_MS): Promise<T> {
+  // window.setTimeout (not bare setTimeout): bare vm test harnesses expose
+  // timers only through the window shim. With no scheduler at all, degrade to
+  // the old unbounded behavior rather than not fetching.
+  const scope = typeof window === 'undefined' ? null : window
+
+  if (!scope || typeof scope.setTimeout !== 'function') {
+    return fetch
+  }
+
+  // `any`: the timer id is assigned synchronously by the executor below, but
+  // it is still `null` on the declaration TypeScript sees from the closure,
+  // and clearTimeout's signature takes `number | undefined`.
+  let timerId: any = null
+
+  const deadline = new Promise<never>((_, reject) => {
+    timerId = scope.setTimeout(() => {
+      reject(new Error(`model.options did not answer within ${Math.round(settleMs / 1000)}s (#95279 settle guard)`))
+    }, settleMs)
+  })
+
+  return Promise.race([fetch, deadline]).finally(() => scope.clearTimeout(timerId))
+}
+
+/** One provider row of the gateway's `model.options` inventory. Entries in
+ *  `models` are bare slugs on current gateways and objects on older ones. */
+interface ModelProviderOption {
+  models?: Array<string | { id?: string; name?: string }>
+  name?: string
+  slug: string
+}
+interface ModelOptionsResponse {
+  providers?: ModelProviderOption[]
+}
+
+function useModelOptions(bot: null | RosterRow = null) {
+  // Hook body runs during render: an orphaned row must paint the picker
+  // disabled/erroring, not throw into the pane's error boundary.
+  const resolved = bot ? resolveBotConnectionRoute(bot) : null
+  const route = resolved?.status === 'resolved' ? resolved.route : null
+  const orphaned = resolved?.status === 'owner_removed'
+
+  return useQuery<ModelOptionsResponse>({
+    queryKey: [ID, 'model-options', route ? botRouteKey(route) : 'active'],
+    // No forced `refresh`: forcing a network read on EVERY mount bypassed the
+    // staleTime cache, so each Bots view remount (tab re-front, dialog reopen,
+    // pane visibility flip) knocked the picker back into its loading state and
+    // discarded the user's staged selection mid-edit (#95279). The cached read
+    // still refreshes per staleTime like every other surface's catalog.
+    queryFn: () =>
+      boundedModelOptionsFetch(
+        requestForBot(bot, 'model.options', {
+          include_unconfigured: true,
+          explicit_only: false
+        }) as Promise<ModelOptionsResponse>
+      ),
+    enabled: !orphaned,
+    staleTime: 120000,
+    retry: false
+  })
+}
+
+/**
+ * Provider + model dropdowns from the gateway's configured inventory — the
+ * same data the core model picker shows. `value = {provider, model}`;
+ * onChange receives the merged patch.
+ */
+/** The two fields a profile pins for its model. */
+interface ModelSelection {
+  model: string
+  provider: string
+}
+/** ModelPicker only ever emits the field(s) it just changed, so consumers can
+ *  test membership with `in` and leave the rest of their state untouched. */
+type ModelSelectionPatch = { model: string } | { model: string; provider: string } | { provider: string }
+interface ModelPickerProps {
+  bot?: null | RosterRow
+  onChange: (patch: ModelSelectionPatch) => void
+  placeholderModel?: string
+  value: ModelSelection
+}
+
+export function ModelPicker({ bot = null, value, onChange, placeholderModel = 'gateway default' }: ModelPickerProps) {
+  const { data, isLoading, error } = useModelOptions(bot)
+
+  // Hooks are ALWAYS declared up front, before any conditional return.
+  // Declaring them after a return trips React error #310.
+  const NONE = '__default__'
+  const CUSTOM = '__custom__'
+  const providers = (data?.providers || []).filter(p => p && p.slug)
+  const isKnown = !value.provider || value.provider === NONE || providers.some(p => p.slug === value.provider)
+  const [useFreeText, setUseFreeText] = useState(!isKnown)
+
+  if (isLoading) {
+    return (
+      <div className="flex justify-center py-2">
+        <GlyphSpinner className="text-(--ui-text-tertiary)" spinner="breathe" />
+      </div>
+    )
+  }
+
+  if (error || !providers.length) {
+    // Fallback: free text (older gateway or empty inventory).
+    return (
+      <div className="grid grid-cols-2 gap-2.5">
+        {labeled(
+          'Provider',
+          <Input
+            onChange={event =>
+              onChange({
+                provider: event.target.value
+              })
+            }
+            placeholder="omnirouter / 9router / nous …"
+            value={value.provider}
+          />
+        )}
+        {labeled(
+          'Model',
+          <Input
+            onChange={event =>
+              onChange({
+                model: event.target.value
+              })
+            }
+            placeholder="antigravity/gemini-3.6-flash-high"
+            value={value.model}
+          />
+        )}
+      </div>
+    )
+  }
+
+  if (useFreeText) {
+    return (
+      <div className="flex flex-col gap-2">
+        <div className="grid grid-cols-2 gap-2.5">
+          {labeled(
+            'Provider (Custom)',
+            <Input
+              onChange={event =>
+                onChange({
+                  provider: event.target.value
+                })
+              }
+              placeholder="e.g. omnirouter, inferx, 9router"
+              value={value.provider}
+            />
+          )}
+          {labeled(
+            'Model (Custom)',
+            <Input
+              onChange={event =>
+                onChange({
+                  model: event.target.value
+                })
+              }
+              placeholder="e.g. antigravity/gemini-3.6-flash-high"
+              value={value.model}
+            />
+          )}
+        </div>
+        <Button
+          className="h-6 self-start text-xs text-(--ui-text-tertiary)"
+          onClick={() => setUseFreeText(false)}
+          size="sm"
+          variant="ghost"
+        >
+          ← Back to dropdowns
+        </Button>
+      </div>
+    )
+  }
+
+  const activeProvider = providers.find(p => p.slug === value.provider) || null
+
+  const models = activeProvider
+    ? (activeProvider.models || []).map(m => (typeof m === 'string' ? m : m.id || m.name || ''))
+    : []
+
+  return (
+    <div className="grid grid-cols-[1fr_1.4fr] gap-2.5">
+      {labeled(
+        'Provider',
+        <Select
+          onValueChange={v => {
+            if (v === NONE) {
+              onChange({
+                provider: '',
+                model: ''
+              })
+            } else if (v === CUSTOM) {
+              setUseFreeText(true)
+            } else {
+              const prov = providers.find(p => p.slug === v)
+              const provModels = (prov?.models || []).map(m => (typeof m === 'string' ? m : m.id || m.name || ''))
+              const first = provModels[0] || ''
+              onChange({
+                provider: v,
+                model: prov && provModels.includes(value.model) ? value.model : first
+              })
+            }
+          }}
+          value={value.provider || NONE}
+        >
+          <SelectTrigger className="h-8 rounded-md">
+            <SelectValue />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value={NONE}>Inherit (launch profile)</SelectItem>
+            {providers.map(p => (
+              <SelectItem key={p.slug} value={p.slug}>
+                {p.name ? `${p.name} (${p.slug})` : p.slug}
+              </SelectItem>
+            ))}
+            <SelectItem value={CUSTOM}>✏️ Enter manually…</SelectItem>
+          </SelectContent>
+        </Select>
+      )}
+      {labeled(
+        'Model',
+        activeProvider && models.length > 0 ? (
+          <Select
+            onValueChange={v =>
+              onChange({
+                model: v
+              })
+            }
+            value={value.model || (models[0] ?? '')}
+          >
+            <SelectTrigger className="h-8 rounded-md">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              {models.map(m => (
+                <SelectItem key={m} value={m}>
+                  {m}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        ) : (
+          <Input
+            onChange={event =>
+              onChange({
+                model: event.target.value
+              })
+            }
+            placeholder={placeholderModel || 'e.g. model name'}
+            value={value.model}
+          />
+        )
+      )}
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/new-compact-guard.test.ts b/apps/desktop/src/plugins/hermes-bots/new-compact-guard.test.ts
new file mode 100644
index 000000000000..600e2e99bc69
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/new-compact-guard.test.ts
@@ -0,0 +1,82 @@
+/**
+ * The /new → /compact guard's identity check.
+ *
+ * `/new` inside a bot's canonical forever-chat would fork the relationship
+ * into a scratch session — the one thing Bots mode promises never happens. The
+ * composer middleware reroutes it to `/compact` (same felt effect: fresh
+ * working context, SAME conversation), but only when the chat on screen really
+ * is the forever-chat.
+ *
+ * Identity is the NAME — the profile's session titled "Bot Chat" — reported by
+ * the gateway as `canonical_session` on every roster row. No stored meta.chat
+ * pointer is consulted: pointers dangle, the registry row cannot.
+ *
+ * Its predecessor could only regex the guard's source text for the strings
+ * `canonical_session` / `canonical?.id`, which is precisely why it never
+ * noticed the guard was dead in production: the id it compared against came
+ * from `host.activeSessionId`, a property that does not exist. The comparison
+ * ran against null on every turn, so `/new` reset forever-chats for as long as
+ * the guard shipped. These tests drive the comparison itself.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+vi.mock('@hermes/plugin-sdk', () => ({
+  BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS: 15_000,
+  host: {}
+}))
+vi.mock('./routing', () => ({
+  backendTargetProfile: (_route: unknown, name: string) => name,
+  botConnectionRoute: () => null,
+  botRosterMeta: () => ({}),
+  botWorkspaceOwnerKey: () => '',
+  requestForBot: vi.fn()
+}))
+vi.mock('./data', () => ({
+  $botMeta: { get: () => ({}), set: vi.fn() },
+  botMetaKey: () => '',
+  botOwner: (owner: string) => ({ bot: { name: owner }, key: owner, name: owner, route: null }),
+  persistBotMetaSnapshot: vi.fn()
+}))
+vi.mock('./shared', () => ({ getPluginCtx: () => null }))
+
+const { isCanonicalChatOnScreen } = await import('./canonical-chat')
+
+function bot(canonical: null | { id?: string; resolved_id?: string }): RosterRow {
+  return { canonical_session: canonical, name: 'ops' } as RosterRow
+}
+
+describe('isCanonicalChatOnScreen', () => {
+  it('matches the durable registry row', () => {
+    expect(isCanonicalChatOnScreen(bot({ id: 'forever-chat' }), 'forever-chat')).toBe(true)
+  })
+
+  it('matches the compression-lineage tip', () => {
+    // A compacted Bot Chat is on screen under its tip id while the registry
+    // still names it by the root — both are the same forever-chat.
+    const compacted = bot({ id: 'root-1', resolved_id: 'tip-9' })
+
+    expect(isCanonicalChatOnScreen(compacted, 'tip-9')).toBe(true)
+    expect(isCanonicalChatOnScreen(compacted, 'root-1')).toBe(true)
+  })
+
+  it('leaves an ordinary session alone', () => {
+    // Sessions-mode scratchpads on the same profile keep full /new freedom.
+    expect(isCanonicalChatOnScreen(bot({ id: 'forever-chat' }), 'scratch')).toBe(false)
+  })
+
+  it('declines when the bot has no registry row yet', () => {
+    expect(isCanonicalChatOnScreen(bot(null), 'anything')).toBe(false)
+  })
+
+  it('declines on a missing id rather than matching everything', () => {
+    // The regression itself: a null id must never satisfy the guard, and must
+    // never be read as "no canonical chat, so let /new through" by accident of
+    // a loose comparison.
+    expect(isCanonicalChatOnScreen(bot({ id: 'forever-chat' }), null)).toBe(false)
+    expect(isCanonicalChatOnScreen(bot({ id: 'forever-chat' }), '')).toBe(false)
+    expect(isCanonicalChatOnScreen(undefined, 'forever-chat')).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/pet.test.tsx b/apps/desktop/src/plugins/hermes-bots/pet.test.tsx
new file mode 100644
index 000000000000..6e913cb28b09
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/pet.test.tsx
@@ -0,0 +1,155 @@
+/**
+ * Pet tiles: frame 0 of a petdex spritesheet, extracted once and cached.
+ *
+ * A "spritesheet" is the FULL animation sheet (1536×1872 webp, ~2MB, an 8×9
+ * grid) — using it directly as an <img> downloads megabytes per tile and shows
+ * the sheet squashed. So each sheet is fetched once, cropped to frame 0,
+ * downscaled, and the resulting data URL is cached per URL.
+ *
+ * The regression the cache created: a FAILED fetch was left parked in the
+ * cache as a resolved-null promise, so one network blip poisoned that pet for
+ * the rest of the session — the tile never recovered, not even on reopen. A
+ * failure must be evicted; a success must not be refetched.
+ */
+
+import { render, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { hostMock, UnboundedCache, useQueryMock } = vi.hoisted(() => ({
+  hostMock: { notify: vi.fn(), request: vi.fn() },
+  // Stand-in for the SDK's LruCache. Its ceiling has its own unit test and no
+  // fixture here approaches it, so the double just drops the bound.
+  UnboundedCache: class extends Map {
+    constructor(_max: number) {
+      super()
+    }
+  },
+  useQueryMock: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', () => ({
+  Button: (props: React.ComponentProps<'button'>) => <button {...props} />,
+  cn: (...parts: unknown[]) => parts.filter(Boolean).join(' '),
+  GlyphSpinner: () => <span />,
+  host: hostMock,
+  Input: (props: React.ComponentProps<'input'>) => <input {...props} />,
+  LruCache: UnboundedCache,
+  RowButton: (props: React.ComponentProps<'button'>) => <button {...props} />,
+  useQuery: useQueryMock
+}))
+
+vi.mock('./i18n', () => ({
+  useBots: () => ({
+    avatar: { petLoadFailed: 'Could not load that pet.', pickPet: 'Pick a pet', removeBackToShape: 'Remove' }
+  })
+}))
+
+vi.mock('./shared', () => ({ ID: 'hermes-bots' }))
+
+const SHEET = 'https://pets.example/a.webp'
+
+/** Record every fetch so the cache behaviour is observable. */
+const fetches: Array<{ init?: RequestInit; url: string }> = []
+
+function stubFetch(handler: () => Promise<unknown>) {
+  vi.stubGlobal('fetch', async (url: string, init?: RequestInit) => {
+    fetches.push({ init, url })
+
+    return handler()
+  })
+}
+
+async function loadPetTab() {
+  vi.resetModules()
+
+  return (await import('./pet')).PetTab
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  fetches.length = 0
+  useQueryMock.mockReturnValue({ data: { pets: [{ displayName: 'Axolotl', slug: 'axolotl', spritesheetUrl: SHEET }] } })
+  vi.stubGlobal('createImageBitmap', async () => ({ close: () => undefined }))
+  vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue({
+    drawImage: () => undefined
+  } as unknown as CanvasRenderingContext2D)
+  vi.spyOn(HTMLCanvasElement.prototype, 'toDataURL').mockReturnValue('data:image/png;base64,ok')
+})
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+describe('the sprite-frame cache', () => {
+  it('never leaves a failed fetch parked in the cache', async () => {
+    stubFetch(async () => {
+      throw new Error('network')
+    })
+
+    const PetTab = await loadPetTab()
+    const first = render(<PetTab image={null} onImage={vi.fn()} />)
+
+    await waitFor(() => expect(fetches).toHaveLength(1))
+    // The fetch is abortable: a hung sheet must not hold a slot forever.
+    expect(fetches[0].init?.signal).toBeTruthy()
+
+    first.unmount()
+
+    const second = render(<PetTab image={null} onImage={vi.fn()} />)
+
+    // Reopening retries rather than serving the poisoned null.
+    await waitFor(() => expect(fetches).toHaveLength(2))
+    expect(second.container.querySelector('img')).toBeNull()
+  })
+
+  it('fetches a successful sheet once and reuses the extracted frame', async () => {
+    stubFetch(async () => ({ blob: async () => new Blob() }))
+
+    const PetTab = await loadPetTab()
+    const first = render(<PetTab image={null} onImage={vi.fn()} />)
+
+    await waitFor(() =>
+      expect(first.container.querySelector('img')?.getAttribute('src')).toBe('data:image/png;base64,ok')
+    )
+    expect(fetches).toHaveLength(1)
+
+    first.unmount()
+
+    const second = render(<PetTab image={null} onImage={vi.fn()} />)
+
+    await waitFor(() =>
+      expect(second.container.querySelector('img')?.getAttribute('src')).toBe('data:image/png;base64,ok')
+    )
+    expect(fetches).toHaveLength(1)
+  })
+
+  it('shares one fetch between tiles that point at the same sheet', async () => {
+    useQueryMock.mockReturnValue({
+      data: {
+        pets: [
+          { displayName: 'Axolotl', slug: 'axolotl', spritesheetUrl: SHEET },
+          { displayName: 'Axolotl (shiny)', slug: 'axolotl-shiny', spritesheetUrl: SHEET }
+        ]
+      }
+    })
+    stubFetch(async () => ({ blob: async () => new Blob() }))
+
+    const PetTab = await loadPetTab()
+    const { container } = render(<PetTab image={null} onImage={vi.fn()} />)
+
+    await waitFor(() => expect(container.querySelectorAll('img')).toHaveLength(2))
+    expect(fetches).toHaveLength(1)
+  })
+
+  it('does not fetch for a pet with no spritesheet', async () => {
+    useQueryMock.mockReturnValue({ data: { pets: [{ displayName: 'Ghost', slug: 'ghost', spritesheetUrl: null }] } })
+    stubFetch(async () => ({ blob: async () => new Blob() }))
+
+    const PetTab = await loadPetTab()
+    const { findByText } = render(<PetTab image={null} onImage={vi.fn()} />)
+
+    await findByText('Ghost')
+    expect(fetches).toHaveLength(0)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/pet.tsx b/apps/desktop/src/plugins/hermes-bots/pet.tsx
new file mode 100644
index 000000000000..700e1b98f46b
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/pet.tsx
@@ -0,0 +1,276 @@
+/**
+ * The Pet tab: browse the petdex gallery and use a companion's first sprite
+ * frame as the bot's profile picture.
+ */
+
+import { Button, cn, GlyphSpinner, host, Input, LruCache, RowButton, useQuery } from '@hermes/plugin-sdk'
+import { useEffect, useState } from 'react'
+
+import { useBots } from './i18n'
+import { ID } from './shared'
+
+// ── pet tab: attach a petdex companion that lives beside the avatar ─────────
+
+// A petdex "spritesheet" is the FULL animation sheet (1536×1872 webp, ~2MB;
+// 8×9 grid of 192×208 frames). Using it as an <img> both downloads megabytes
+// per tile and shows the whole sheet squashed. Extract frame 0 once per slug
+// via canvas, downscale to 96px, and cache the data URL. Concurrency-capped
+// so opening the tab doesn't fire dozens of 2MB fetches at once.
+const PET_FRAME_W = 192
+const PET_FRAME_H = 208
+// The gallery is 4500+ pets browsed 24 at a time, and each entry is a decoded
+// PNG data URL — an unbounded cache holds every pet the user ever scrolled
+// past for the life of the window. Five pages' worth keeps scrolling back up
+// instant; past that a revisit pays the fetch and crop again.
+const PET_FRAME_CACHE_MAX = 120
+const petFrameCache = new LruCache<string, Promise<null | string>>(PET_FRAME_CACHE_MAX)
+let petFetchActive = 0
+const petFetchQueue: Array<() => Promise<void>> = []
+
+function pumpPetQueue() {
+  while (petFetchActive < 4 && petFetchQueue.length) {
+    const job = petFetchQueue.shift()!
+    petFetchActive++
+    job().finally(() => {
+      petFetchActive--
+      pumpPetQueue()
+    })
+  }
+}
+
+function petFrameIcon(spriteUrl: null | string | undefined): Promise<null | string> {
+  if (!spriteUrl) {
+    return Promise.resolve(null)
+  }
+
+  if (!petFrameCache.has(spriteUrl)) {
+    petFrameCache.set(
+      spriteUrl,
+      new Promise(resolve => {
+        petFetchQueue.push(async () => {
+          try {
+            const resp = await fetch(spriteUrl, {
+              signal: AbortSignal.timeout(15000)
+            })
+
+            const blob = await resp.blob()
+            // Crop frame 0 during decode — never materialize the full sheet.
+            const bitmap = await createImageBitmap(blob, 0, 0, PET_FRAME_W, PET_FRAME_H)
+            const canvas = document.createElement('canvas')
+            canvas.width = 96
+            canvas.height = 104
+            canvas.getContext('2d')!.drawImage(bitmap, 0, 0, 96, 104)
+            bitmap.close()
+            resolve(canvas.toDataURL('image/png'))
+          } catch {
+            petFrameCache.delete(spriteUrl)
+            resolve(null)
+          }
+        })
+        pumpPetQueue()
+      })
+    )
+  }
+
+  return petFrameCache.get(spriteUrl)!
+}
+
+interface PetThumbProps {
+  size?: number
+  spriteUrl?: null | string
+}
+
+/** One pet tile image: frame 0 only, resolved lazily through the cache. */
+function PetThumb({ spriteUrl, size = 40 }: PetThumbProps) {
+  const [icon, setIcon] = useState<null | string>(null)
+  useEffect(() => {
+    let alive = true
+    petFrameIcon(spriteUrl).then(url => {
+      if (alive) {
+        setIcon(url)
+      }
+    })
+
+    return () => {
+      alive = false
+    }
+  }, [spriteUrl])
+
+  if (!icon) {
+    return (
+      <div
+        style={{
+          width: size,
+          height: size,
+          borderRadius: 6,
+          background: 'var(--chrome-action-hover, rgba(255,255,255,0.06))'
+        }}
+      />
+    )
+  }
+
+  return (
+    <img
+      alt=""
+      src={icon}
+      style={{
+        width: size,
+        height: size,
+        objectFit: 'contain',
+        imageRendering: 'pixelated',
+        borderRadius: 6
+      }}
+    />
+  )
+}
+
+/** One petdex companion as `pet.gallery` reports it. */
+interface PetGalleryEntry {
+  curated?: boolean
+  displayName?: string
+  installed?: boolean
+  slug: string
+  /** Full animation sheet (1536×1872 webp); frame 0 is cropped out of it. */
+  spritesheetUrl?: null | string
+}
+
+interface PetTabProps {
+  image: null | string
+  onImage: (image: null | string) => void
+}
+
+export function PetTab({ image, onImage }: PetTabProps) {
+  const b = useBots()
+  // Selection is dialog-local: committed by the dialog's Save like any
+  // uploaded/generated image (a direct meta write here gets clobbered by
+  // Save's own image state).
+  const [selectedSlug, setSelectedSlug] = useState<null | string>(null)
+
+  const { data, isLoading } = useQuery({
+    queryKey: [ID, 'pet-gallery'],
+    queryFn: () => host.request<{ pets?: PetGalleryEntry[] }>('pet.gallery', {}),
+    staleTime: 300000
+  })
+
+  const [query, setQuery] = useState('')
+  // Windowed rendering: the gallery is 4500+ pets — mounting an <img> per pet
+  // froze the dialog. Render `limit` at a time and grow on scroll-to-bottom.
+  const [limit, setLimit] = useState(24)
+  const pets = data?.pets ?? []
+
+  if (isLoading) {
+    return (
+      <div className="flex justify-center py-4">
+        <GlyphSpinner className="text-(--ui-text-tertiary)" spinner="breathe" />
+      </div>
+    )
+  }
+
+  if (!pets.length) {
+    return (
+      <div className="px-2 py-3 text-center text-xs text-(--ui-text-tertiary)">
+        No pets in the petdex gallery. Run `hermes pets` to explore.
+      </div>
+    )
+  }
+
+  const q = query.trim().toLowerCase()
+
+  const filtered = q
+    ? pets.filter(pet => (pet.displayName || '').toLowerCase().includes(q) || (pet.slug || '').includes(q))
+    : pets
+
+  // Installed and curated pets surface first — they're the likeliest picks.
+  const ranked = filtered.slice().sort((a, b) => {
+    const rank = (pet: PetGalleryEntry) => (pet.installed ? 0 : pet.curated ? 1 : 2)
+
+    return rank(a) - rank(b)
+  })
+
+  const visible = ranked.slice(0, limit)
+
+  const onScroll = (event: { currentTarget: HTMLDivElement }) => {
+    const el = event.currentTarget
+
+    if (el.scrollTop + el.clientHeight >= el.scrollHeight - 120 && limit < ranked.length) {
+      setLimit(prev => Math.min(prev + 24, ranked.length))
+    }
+  }
+
+  return (
+    <div className="grid w-full gap-2">
+      <div className="text-center text-[0.65rem] text-(--ui-text-quaternary)">{b.avatar.pickPet}</div>
+      <Input
+        className="h-7 text-xs"
+        onChange={event => {
+          setQuery(event.target.value)
+          setLimit(24)
+        }}
+        placeholder={`Search ${pets.length} pets…`}
+        value={query}
+      />
+      {image && selectedSlug ? (
+        <Button
+          className="justify-center"
+          onClick={() => {
+            setSelectedSlug(null)
+            onImage(null)
+          }}
+          size="sm"
+          type="button"
+          variant="ghost"
+        >
+          {b.avatar.removeBackToShape}
+        </Button>
+      ) : null}
+      {filtered.length === 0 ? (
+        <div className="py-3 text-center text-xs text-(--ui-text-quaternary)">No pets match.</div>
+      ) : (
+        <div
+          className="overflow-y-auto"
+          onScroll={onScroll}
+          style={{
+            maxHeight: 220
+          }}
+        >
+          <div className="grid grid-cols-3 gap-1.5">
+            {visible.map(pet => (
+              <RowButton
+                className={cn(
+                  'grid justify-items-center gap-1 rounded-md p-1.5 transition-colors hover:bg-(--chrome-action-hover)',
+                  selectedSlug === pet.slug && 'ring-1 ring-(--ui-accent)'
+                )}
+                key={pet.slug}
+                onClick={() => {
+                  // The pet IS the profile picture: extract frame 0
+                  // and hand it to the dialog as the avatar image.
+                  // Persisted when the user hits Save.
+                  setSelectedSlug(pet.slug)
+                  void petFrameIcon(pet.spritesheetUrl).then(icon => {
+                    if (icon) {
+                      onImage(icon)
+                    } else {
+                      setSelectedSlug(null)
+                      host.notify({
+                        kind: 'error',
+                        message: b.avatar.petLoadFailed
+                      })
+                    }
+                  })
+                }}
+              >
+                <PetThumb size={40} spriteUrl={pet.spritesheetUrl} />
+                <span className="w-full truncate text-center text-[0.6rem] text-(--ui-text-tertiary)">
+                  {pet.displayName}
+                </span>
+              </RowButton>
+            ))}
+          </div>
+          {limit < ranked.length ? (
+            <div className="py-2 text-center text-[0.65rem] text-(--ui-text-quaternary)">{`Scroll for more (${limit} of ${ranked.length})`}</div>
+          ) : null}
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/plugin-panes.test.tsx b/apps/desktop/src/plugins/hermes-bots/plugin-panes.test.tsx
new file mode 100644
index 000000000000..38fd1a883a5c
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/plugin-panes.test.tsx
@@ -0,0 +1,283 @@
+/**
+ * Bot Mode's pane layout contract, asserted by running the real `register()`
+ * against a recording plugin context:
+ *
+ *  - the Bots pane center-stacks into the sessions zone (a SESSIONS | BOTS tab
+ *    strip), never splits below it, and carries the ENFORCED dock invariant so
+ *    every boot re-homes a stacked install. No heal token, no user-placed
+ *    exemption — the retired one-shot heal burned its token even when its
+ *    guards skipped the move, so exactly the users who had dragged their panes
+ *    stayed stacked forever;
+ *  - the Scheduled jobs (internally `routines`) pane only exists while a BOT
+ *    CHAT owns the main workspace and the Bots pane is on screen. It is
+ *    registered and unregistered through the contribution disposer, driven by
+ *    the feature-detected `host.paneVisibility` export, with the
+ *    always-registered fallback kept for older desktops. Cron jobs are
+ *    bot-scoped, so the tile must not sit beside a group chat.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import type { PluginContext } from '@hermes/plugin-sdk'
+import { atom } from 'nanostores'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type * as DataModule from './data'
+import type * as RoutingModule from './routing'
+
+const mocks = vi.hoisted(() => ({
+  botChatOwnsWorkspace: vi.fn(() => false),
+  paneVisibility: vi.fn(),
+  sessionOwnsWorkspace: vi.fn(() => false),
+  setWorkspaceScope: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const original = await importOriginal<typeof HermesSdk>()
+
+  return {
+    ...original,
+    host: {
+      ...original.host,
+      onEvent: undefined,
+      paneVisibility: mocks.paneVisibility,
+      setWorkspaceScope: mocks.setWorkspaceScope
+    }
+  }
+})
+
+// Everything below is a boundary this test does not exercise: clocks, sockets,
+// storage sweeps and the panes' own render trees.
+vi.mock('./avatar', () => ({ startFaceClock: vi.fn(), stopFaceClock: vi.fn() }))
+vi.mock('./relay', () => ({ startBotRelay: vi.fn(), stopBotRelay: vi.fn() }))
+vi.mock('./session-sweep', () => ({ startHideSweepScheduler: vi.fn() }))
+vi.mock('./canonical-chat', () => ({ openBotCanonicalChat: vi.fn() }))
+vi.mock('./chat-empty', () => ({ BotChatEmpty: () => null }))
+vi.mock('./hygiene', () => ({ annotateOrphanedGroupChatMembers: () => ({ changed: false, rooms: {} }) }))
+vi.mock('./cron', () => ({ bindProfileSync: () => () => undefined, RoutinesPane: () => null }))
+vi.mock('./roster-pane', () => ({
+  botChatOwnsWorkspace: mocks.botChatOwnsWorkspace,
+  BotsPane: () => null,
+  releaseStaleOpenBotChat: vi.fn(),
+  selectedRosterBot: () => null,
+  sessionOwnsWorkspace: mocks.sessionOwnsWorkspace
+}))
+vi.mock('./group-chat', async () => {
+  const { atom: nanoAtom } = await import('nanostores')
+
+  return {
+    $groupChats: nanoAtom({}),
+    $groupChatWorkspace: nanoAtom(null),
+    assignLegacyThreads: (log: unknown[]) => log,
+    handleSessionsGatewayTransition: vi.fn(),
+    pullGroupChatServerState: async () => false,
+    scheduleGroupChatServerSync: vi.fn(),
+    setGroupChatSyncDisposed: vi.fn(),
+    stopGroupChatServerSync: vi.fn(),
+    sweepGroupChatMembersForRemovedConnection: vi.fn(),
+    updateGroupChat: vi.fn()
+  }
+})
+vi.mock('./data', async importOriginal => {
+  const original = await importOriginal<typeof DataModule>()
+
+  return { ...original, migrateBotMeta: async () => undefined }
+})
+vi.mock('./routing', async importOriginal => {
+  const original = await importOriginal<typeof RoutingModule>()
+
+  return { ...original, setBotsWorkspaceOwner: vi.fn() }
+})
+
+const plugin = (await import('./plugin')).default
+
+interface Registration {
+  area: string
+  data?: Record<string, unknown>
+  id: string
+}
+
+/** A recording `PluginContext`: registrations, their disposers, teardown. */
+function recordingContext() {
+  const disposers: (() => void)[] = []
+  const registrations: Registration[] = []
+  const unregisters = new Map<string, () => void>()
+
+  const ctx = {
+    i18n: { register: () => () => undefined, t: (key: string) => key },
+    onDispose: (fn: () => void) => disposers.push(fn),
+    register: (registration: Registration) => {
+      registrations.push(registration)
+
+      const unregister = vi.fn(() => {
+        registrations.splice(registrations.indexOf(registration), 1)
+      })
+
+      unregisters.set(registration.id, unregister)
+
+      return unregister
+    },
+    storage: { get: async () => undefined, set: async () => undefined }
+  }
+
+  return {
+    ctx: ctx as unknown as PluginContext,
+    dispose: () => disposers.forEach(fn => fn()),
+    find: (id: string) => registrations.find(registration => registration.id === id),
+    unregisters
+  }
+}
+
+/** Nanostore stand-ins for the SDK's per-pane visibility stores. */
+function paneStores() {
+  const stores = new Map<string, ReturnType<typeof atom<boolean>>>()
+
+  mocks.paneVisibility.mockImplementation((id: string) => {
+    if (!stores.has(id)) {
+      stores.set(id, atom(false))
+    }
+
+    return stores.get(id)
+  })
+
+  return (id: string) => {
+    mocks.paneVisibility(id)
+
+    return stores.get(id)!
+  }
+}
+
+/** The plugin defers one reconcile to a macrotask so it never re-enters the
+ *  tree store mid-mutation. */
+const settle = () => new Promise(resolve => setTimeout(resolve, 0))
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mocks.botChatOwnsWorkspace.mockReturnValue(false)
+  mocks.sessionOwnsWorkspace.mockReturnValue(false)
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('the Bots pane dock', () => {
+  it('center-stacks into the sessions zone as a standing invariant', () => {
+    paneStores()
+
+    const harness = recordingContext()
+
+    plugin.register(harness.ctx)
+
+    const data = harness.find('pane')!.data!
+
+    expect(data.dock).toEqual({ enforce: true, pane: 'sessions', pos: 'center' })
+    // A 'bottom' split was the old workaround for the lone-pane auto-hide trap.
+    expect((data.dock as { pos: string }).pos).not.toBe('bottom')
+    // No heal token: the invariant runs at every adoption, unconditionally.
+    expect(data).not.toHaveProperty('heal')
+
+    harness.dispose()
+  })
+})
+
+describe('the Scheduled jobs pane', () => {
+  it('stays unregistered until a bot chat owns the workspace', async () => {
+    const store = paneStores()
+    const harness = recordingContext()
+
+    plugin.register(harness.ctx)
+    await settle()
+
+    expect(harness.find('routines')).toBeUndefined()
+
+    mocks.botChatOwnsWorkspace.mockReturnValue(true)
+    store(`hermes-bots:pane`).set(true)
+
+    const routines = harness.find('routines')!
+
+    expect(routines.data).toMatchObject({
+      // Repairs persisted layouts that stranded the tile in the Bots tab strip.
+      dock: { enforce: true, pane: 'workspace', pos: 'right' },
+      placement: 'main'
+    })
+    // Glanceable, not something you sit in: it arrives as the right edge's
+    // vertical tab and takes no width off the chat until the user opens it.
+    expect(routines.data!.defaultCollapsed).toBe(true)
+
+    harness.dispose()
+  })
+
+  it('unregisters when Bot Mode leaves the screen', async () => {
+    const store = paneStores()
+    const harness = recordingContext()
+
+    mocks.botChatOwnsWorkspace.mockReturnValue(true)
+    plugin.register(harness.ctx)
+    await settle()
+
+    expect(harness.find('routines')).toBeTruthy()
+
+    mocks.botChatOwnsWorkspace.mockReturnValue(false)
+    store(`hermes-bots:pane`).set(true)
+    store(`hermes-bots:pane`).set(false)
+
+    expect(harness.unregisters.get('routines')).toHaveBeenCalled()
+    expect(harness.find('routines')).toBeUndefined()
+
+    harness.dispose()
+  })
+
+  it('keeps the tile alive while the tile itself holds focus', async () => {
+    const store = paneStores()
+    const harness = recordingContext()
+
+    mocks.botChatOwnsWorkspace.mockReturnValue(true)
+    plugin.register(harness.ctx)
+    await settle()
+
+    // Clicking the tile drops bot-chat workspace ownership for a beat. A pane
+    // must never unregister itself out from under its own click.
+    store(`hermes-bots:routines`).set(true)
+    mocks.botChatOwnsWorkspace.mockReturnValue(false)
+    store(`hermes-bots:pane`).set(true)
+
+    expect(harness.unregisters.get('routines')).not.toHaveBeenCalled()
+    expect(harness.find('routines')).toBeTruthy()
+
+    harness.dispose()
+  })
+
+  it('stops every lifecycle listener when the plugin is disabled', async () => {
+    const store = paneStores()
+    const harness = recordingContext()
+
+    plugin.register(harness.ctx)
+    await settle()
+    harness.dispose()
+
+    // A disable → re-enable cycle used to stack a duplicate listener per cycle.
+    mocks.botChatOwnsWorkspace.mockReturnValue(true)
+    store(`hermes-bots:pane`).set(true)
+
+    expect(harness.find('routines')).toBeUndefined()
+  })
+})
+
+describe('a desktop without host.paneVisibility', () => {
+  it('keeps the always-registered pane', async () => {
+    const { host } = await import('@hermes/plugin-sdk')
+    const restore = host.paneVisibility
+
+    // @ts-expect-error modelling an older SDK that lacks the export entirely
+    host.paneVisibility = undefined
+
+    const harness = recordingContext()
+
+    plugin.register(harness.ctx)
+
+    expect(harness.find('routines')).toBeTruthy()
+
+    harness.dispose()
+    host.paneVisibility = restore
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/plugin.js b/apps/desktop/src/plugins/hermes-bots/plugin.js
deleted file mode 100644
index 11a8301d779d..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/plugin.js
+++ /dev/null
@@ -1,16305 +0,0 @@
-/**
- * Hermes Bot Mode — a "one chat per agent" roster for the Hermes desktop.
- *
- * Left pane "Bots": one row per Hermes profile (a bot = an agent profile) with
- * a customizable avatar (shape + color + eyes, image, or pet). Click opens that
- * bot's chat; right-click → Edit Profile (avatar, title, description).
- * "New Bot" creates a profile — Name / Title / Description with an
- * "Advanced" disclosure for full profile config.
- *
- * Right tile "Routines": scheduled tasks (Hermes cron jobs) scoped to the
- * bot you're currently chatting with — follows the live gateway profile.
- *
- * Bots message each other straight into each bot's ONE canonical "Bot
- * Chat" — @-mentions deliver over gateway RPCs (no CLI relay), and
- * bot-initiated sends use `hermes -p <bot> chat --in ~ -c "Bot Chat"`.
- */
-
-import * as sdk from '@hermes/plugin-sdk'
-import {
-  atom,
-  Button,
-  Checkbox,
-  cn,
-  Codicon,
-  COMPOSER_AREAS,
-  ContextMenu,
-  ContextMenuContent,
-  ContextMenuItem,
-  ContextMenuSeparator,
-  ContextMenuTrigger,
-  ConfirmDialog,
-  CopyButton,
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-  EmptyState,
-  GlyphSpinner,
-  haptic,
-  host,
-  Input,
-  PALETTE_AREA,
-  profileColor,
-  queryClient,
-  relativeTime,
-  ScrollArea,
-  SearchField,
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-  Switch,
-  surfaceModelSwitchConfirm,
-  Textarea,
-  Tip,
-  useQuery,
-  useValue
-} from '@hermes/plugin-sdk'
-import { useEffect, useMemo, useRef, useState } from 'react'
-import { jsx, jsxs } from 'react/jsx-runtime'
-
-const { McpTab, ToolsetConfigPanel } = sdk
-// Keep optional exports feature-detected; test harnesses may strip the SDK namespace.
-const SkillsView = typeof sdk === 'undefined' ? undefined : sdk.SkillsView
-// TRUE only on builds whose SkillsView routes `fixedConnection` to the pinned
-// registry connection's backend. Older builds export SkillsView WITHOUT the
-// prop — rendering it for a remote-target draft there would read/write the
-// ACTIVE gateway's skills under the remote bot's name (the wrong machine),
-// so those builds keep the staged checklists for remote targets.
-const skillsViewRoutesConnections = Boolean(SkillsView && SkillsView.supportsFixedConnection)
-const Streamdown = typeof sdk === 'undefined' ? undefined : sdk.Streamdown
-// Deterministic blob avatars (name → face). Feature-detected: older SDKs
-// without the export fall back to the legacy math-face shapes below.
-const blobatarSvg = typeof sdk === 'undefined' ? undefined : sdk.blobatarSvg
-// Budgeted render loop (fps cap + observability pause + dormancy + teardown).
-// Feature-detected: older desktops fall back to the hand-rolled clock below.
-const createBudgetedLoop = typeof sdk === 'undefined' ? undefined : sdk.createBudgetedLoop
-
-const ID = 'hermes-bots'
-/** Tree pane id of the Bots home workspace tab (openWorkspace prefixes
- *  `plugin-workspace:`). Tab visibility — not session focus — is what says
- *  who owns the CENTER once tabs exist; session focus only vetoes passive
- *  opens and, on its rising edge, yields the center to the chat. */
-const BOTS_HOME_PANE_ID = `plugin-workspace:${ID}:home`
-const ROSTER_KEY = [ID, 'roster']
-// Bounded retries. `retry: true` keeps React Query in isLoading until the
-// first success, so a stalled profiles.list (live state.db write lock, SSH
-// flap) leaves the Bots sidebar on a spinner with no error card. The 5s
-// refetchInterval and the gateway-open effect already recover drops.
-const ROSTER_QUERY_RETRY = 2
-const ROUTINES_KEY = [ID, 'routines']
-const NAME_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/
-const BOT_META_V1_KEY = 'bot-meta'
-const BOT_META_V2_KEY = 'bot-meta-v2'
-const BOT_META_MIGRATION_KEY = 'bot-meta-v2-migrated'
-let botMetaV2Active = false
-let botMetaV2Commit = Promise.resolve()
-const migratedLocalRoutes = new Map()
-
-/** Captured in register() so components can reach plugin storage. */
-let pluginCtx = null
-
-/** Live roster snapshot for imperative handlers (context menus). */
-const $lastRoster = atom([])
-
-/** Last source inventory returned by the desktop-wide agent roster. */
-const $lastSources = atom([])
-
-/** Bots with chat activity the user hasn't seen yet (connectionId::profile -> true).
- *  Fed by the roster poll's activity watermark, so it catches EVERY
- *  delivery path: RPC, CLI (bot-to-bot), cron runs, other machines. */
-const $botUnread = atom({})
-
-// last_active watermark per source-qualified bot, seeded on first poll so a
-// fresh mount doesn't mark ancient history unread.
-const rosterWatermarks = new Map()
-let watermarksSeeded = false
-
-/** User pref: toast on every new bot activity. Default OFF — a busy roster
- *  (cron runs, bot-to-bot chatter) turns the toasts into a firehose, and the
- *  unread badge already carries the signal. Persisted via ctx.storage. */
-const $activityToasts = atom(false)
-
-/** Flip the activity-toast pref and persist it. */
-function setActivityToasts(enabled) {
-  $activityToasts.set(enabled)
-
-  try {
-    Promise.resolve(pluginCtx?.storage?.set?.('activity-toasts', enabled)).catch(() => undefined)
-  } catch {
-    /* storage unavailable — pref holds for this window only */
-  }
-}
-
-/** Detect new inbound activity from a fresh roster: last_active moved past
- *  the watermark for a bot whose chat isn't on screen -> unread + toast.
- *  Watermarks follow botActivitySession (canonical Bot Chat included) —
- *  last_session alone never sees the hidden Bot Chat, so DMs delivered
- *  there would neither badge nor toast. */
-function trackInboundActivity(roster) {
-  const seeding = !watermarksSeeded
-  watermarksSeeded = true
-
-  for (const bot of roster) {
-    const key = botSelectionKey(bot)
-    const activity = botActivitySession(bot)
-    const ts = activity?.last_active || 0
-    const prev = rosterWatermarks.get(key) || 0
-    rosterWatermarks.set(key, Math.max(prev, ts))
-
-    if (seeding || ts <= prev) {
-      continue
-    }
-
-    // Activity in the exact bot owner the user is currently looking at is
-    // already visible — never badge the open chat or its same-named twin.
-    if ($selectedBot.get() === key) {
-      continue
-    }
-
-    $botUnread.set({ ...$botUnread.get(), [key]: true })
-
-    // Roster-hidden bots stay quiet: the unread flag above accumulates
-    // silently (unhiding reveals the badge) but a hidden bot never toasts.
-    if (botRosterMeta(bot, $botMeta.get())?.hidden) {
-      continue
-    }
-
-    // Toasts are opt-in: the unread badge is always set above, but the
-    // per-message notification fires only when the user enabled it.
-    if ($activityToasts.get()) {
-      const meta = botRosterMeta(bot, $botMeta.get())
-      const label = displayName(bot, meta)
-      const preview = (activity?.preview || '').trim()
-      const inbound = /^Message from/i.test(preview)
-
-      host.notify({
-        kind: 'info',
-        title: inbound ? `\uD83E\uDD16 New message for ${label}` : `${label} has new activity`,
-        message: preview.slice(0, 140) || 'Open the chat to see it.'
-      })
-    }
-  }
-}
-
-// ── needs-attention badge (#93091 item 3) ───────────────────────────────────
-// Attention-worthy failure classes — matches the #93091 item-1 reason-code
-// enum (shipped separately). Until reason codes flow end-to-end,
-// attentionReasonFromError ALSO classifies raw error text as a fallback so
-// the badge works against current gateway error strings.
-const BOT_ATTENTION_CLASSES = new Set([
-  'agent_blocked',
-  'provider_auth_or_access',
-  'provider_quota_limit',
-  'missing_config'
-])
-
-/** One-line user hint per attention class (roster badge tooltip). */
-const BOT_ATTENTION_HINTS = {
-  provider_auth_or_access: 'Sign in again for this profile',
-  provider_quota_limit: 'Quota or balance exhausted',
-  missing_config: 'Provider not configured — run hermes model',
-  agent_blocked: 'Bot is blocked — see its last message'
-}
-
-/** Map an error (a #93091 reason code or raw error text) to an attention
- *  class, or null when the failure is transient (rate limit, server error,
- *  timeout) — transient classes must NEVER badge. Pure; tested directly. */
-function attentionReasonFromError(errorTextOrReason) {
-  const raw = String(errorTextOrReason || '').trim()
-
-  if (!raw) {
-    return null
-  }
-
-  if (BOT_ATTENTION_CLASSES.has(raw)) {
-    return raw
-  }
-
-  const text = raw.toLowerCase()
-
-  // Transient failures first, so a retryable error never sticks a badge.
-  if (/rate.?limit|too many requests|\b429\b|\b5\d\d\b|server error|overloaded|timed?.?out|timeout|temporar/.test(text)) {
-    return null
-  }
-
-  if (/no llm provider|no access token|not configured|no api key|missing api key/.test(text)) {
-    return 'missing_config'
-  }
-
-  if (/\b401\b|\b403\b|unauthorized|forbidden|authentication|invalid.?api.?key|credentials? (are )?(invalid|expired)/.test(text)) {
-    return 'provider_auth_or_access'
-  }
-
-  if (/quota|out of funds|insufficient (credits?|funds|balance)|payment required|\b402\b|billing/.test(text)) {
-    return 'provider_quota_limit'
-  }
-
-  if (/\bblocked\b/.test(text)) {
-    return 'agent_blocked'
-  }
-
-  return null
-}
-
-/** Per-bot needs-attention state: roster key -> {reason, at, message}.
- *  Display-only presentation state (never persisted, never alters delivery).
- *  Latest failure wins; the bot's next good turn clears it. Hidden bots keep
- *  their entry — hiding is a roster-DISPLAY concern only. */
-const $botAttention = atom({})
-
-/** Record attention for a bot after a failed turn/delivery. Transient errors
- *  classify to null and set nothing. Latest failure wins. */
-function noteBotAttention(key, errorTextOrReason) {
-  const reason = attentionReasonFromError(errorTextOrReason)
-
-  if (!key || !reason) {
-    return
-  }
-
-  $botAttention.set({
-    ...$botAttention.get(),
-    [key]: { reason, at: Date.now(), message: String(errorTextOrReason || '').trim().slice(0, 200) }
-  })
-}
-
-/** A good turn clears the badge. */
-function clearBotAttention(key) {
-  if (!key || !$botAttention.get()[key]) {
-    return
-  }
-
-  const next = { ...$botAttention.get() }
-  delete next[key]
-  $botAttention.set(next)
-}
-
-/** Last good cron list, same idea as the roster snapshot. */
-const $lastJobs = atom([])
-
-// Bot Mode sessions are ALWAYS hidden from the global Sessions sidebar:
-// canonical Bot Chats are plugin-owned forever-chats and group-chat member
-// sessions are room plumbing — neither is a scratch conversation, and a
-// 6-member room would otherwise dump six identical "Group: ..." rows into
-// recents. Backed by the core generic `hidden` session flag (session.create
-// hidden:true / session.set_hidden). Older gateways ignore the flag and the
-// sessions simply stay visible there.
-
-/** Bot the Routines tile is scoped to. Follows the live gateway profile
- *  (the bot you're actually chatting with) and roster clicks. */
-const $selectedBot = atom('default')
-
-/** Owner of the chat the user is LOOKING AT. Newer desktops expose a
- *  connection-qualified owner. Older builds synthesize the previous
- *  profile/gateway fallback and listen to both atoms when available. */
-/** Source-qualified Bot Mode selection. Restoring it is presentation-only:
- *  it never activates a gateway or creates a session. */
-const $selectedRosterKey = atom('')
-const $selectedRosterHydrated = atom(false)
-const $rosterHydrated = atom(false)
-/** Mirrors host.paneVisibility('hermes-bots:pane') — wired in register(). */
-const $botsPaneVisible = atom(false)
-/** An explicit open landed: {key, openedRegistryId, openedSessionId}. The
- *  registry id is empty for the legacy newChat draft fallback and for a click
- *  that came back to the bot's already-open tabs (only openedSessionId set —
- *  no canonical chat was resolved). This transient view observation is what
- *  releases the home; it is never an identity preference. */
-const $openBotChat = atom(null)
-/** A session owns the main workspace. The roster highlight and the home /
- *  Cronjobs lifecycles all key off this rather than reading host.state
- *  conditionally from render. */
-const $botChatFocused = atom(false)
-/** True only while the Bots home is the visible main-area surface. A focused
- *  chat can remain alive behind it, so session focus alone cannot decide which
- *  roster row owns the visible workspace. */
-const $botsHomeFronted = atom(false)
-
-let botsHomeClose = null
-let suppressBotsHomeReopen = false
-// Latched while a re-front attempt has not yet been answered with visibility.
-// Cleared the moment the home is actually fronted, and whenever the tab is
-// retired — a fresh open starts the budget over. See openBotsHomeWorkspace.
-let botsHomeRefrontTried = false
-
-function saveSelectedRosterBot(bot) {
-  const key = botRosterKey(bot)
-
-  $selectedBot.set(botSelectionKey(bot))
-  $selectedRosterKey.set(key)
-
-  try {
-    Promise.resolve(pluginCtx?.storage?.set?.('selected-roster-bot-v1', key)).catch(() => undefined)
-  } catch {
-    /* storage unavailable — selection lasts for this window */
-  }
-}
-
-function clearSelectedRosterBot(bot) {
-  clearSelectedRosterKey(botRosterKey(bot))
-}
-
-/** Drop the persisted selection when it is exactly this key — the caller has
- *  proven the owner is gone, not merely unreachable. An unreachable source
- *  KEEPS its key so the selection reconciles when the gateway returns. */
-function clearSelectedRosterKey(key) {
-  if ($selectedRosterKey.get() !== key) {
-    return
-  }
-
-  $selectedRosterKey.set('')
-
-  try {
-    Promise.resolve(pluginCtx?.storage?.set?.('selected-roster-bot-v1', '')).catch(() => undefined)
-  } catch {
-    /* storage unavailable — selection is cleared for this window */
-  }
-}
-
-/** Split a roster key back into its owner parts. Profile names cannot contain
- *  ':' (NAME_RE), so the first '::' is unambiguous. */
-function parseRosterKey(key) {
-  const raw = String(key || '')
-  const at = raw.indexOf('::')
-
-  if (at < 0) {
-    return { connectionId: '', name: '' }
-  }
-
-  return { connectionId: raw.slice(0, at), name: raw.slice(at + 2) }
-}
-
-const $focusedBotProfile = host.state.focusedSessionProfile || host.state.profile
-
-/** Profile that owns the chat currently on screen. Bot Mode opens another
- *  profile's session without moving the gateway socket, so mention filtering
- *  and sender identity must follow focus rather than host.state.profile. */
-function focusedMentionProfile() {
-  return String($focusedBotProfile.get?.() || '').trim() || 'default'
-}
-
-function fallbackFocusedBotOwner(profile = $focusedBotProfile.get?.()) {
-  const focusedProfile = String(profile || 'default').trim() || 'default'
-  const activeProfile = String(host.state.profile?.get?.() || 'default').trim() || 'default'
-
-  // focusedSessionProfile without focusedSessionOwner is a legacy half-shape:
-  // it carries no source identity. Only reuse the active connection when the
-  // focused profile is also the active profile; otherwise fail closed rather
-  // than manufacturing a cross-source owner from unrelated atoms.
-  if (host.state.focusedSessionProfile && focusedProfile !== activeProfile) {
-    return null
-  }
-
-  const connectionId = String(
-    host.state.connectionId?.get?.() ||
-    (typeof host.activeConnectionId === 'function' ? host.activeConnectionId() : '') ||
-    ''
-  ).trim()
-
-  return {
-    authoritative: false,
-    connectionId,
-    profile: focusedProfile
-  }
-}
-
-const $focusedBotOwner = host.state.focusedSessionOwner || {
-  get: () => fallbackFocusedBotOwner(),
-  listen: listener => {
-    const emit = profile => listener(fallbackFocusedBotOwner(profile))
-    const unbindProfile = $focusedBotProfile.listen(emit)
-    const unbindConnection = host.state.connectionId?.listen?.(() => emit($focusedBotProfile.get?.()))
-
-    return () => {
-      unbindProfile?.()
-      unbindConnection?.()
-    }
-  }
-}
-
-function focusedRosterOwner(owner) {
-  const name = String(owner?.profile || owner?.name || '').trim()
-
-  if (!owner || !name) {
-    return null
-  }
-
-  return {
-    authoritative: owner.authoritative !== false,
-    connectionId: String(owner.connectionId || '').trim(),
-    name
-  }
-}
-
-/** Optional secondary navigation inside the Bots pane (group-chat rooms). */
-
-/** Group-chat rooms: { [group]: { log: [{from:{kind,name},text,at}], watermarks:{[member]:idx}, epoch, running } }.
- *  Log + watermarks persist via plugin storage; epoch/running are runtime-only. */
-const $groupChats = atom({})
-/** Group whose room view is open in the Bots pane (secondary navigation
- *  inside the pane; a normal row click returns to the roster). */
-const $groupChatWorkspace = atom(null)
-/** Groups whose latest room activity mentions @user — the needs-you badge. */
-const $groupNeedsYou = atom({})
-// Pending prompts (clarify questions AND command approvals) raised inside
-// hidden group-member sessions, keyed `${group}::${memberKey}` (#90694).
-// Members run in invisible plumbing sessions, so a member's blocking prompt
-// used to park server-side with no surface to answer it — the user saw
-// "is thinking…" until the prompt timeout. The turn poll mirrors each
-// member's `pending_clarify` / `pending_approval` resume fields in here;
-// the room renders answer cards from it.
-const $groupClarify = atom({})
-
-// ── group activity feed ─────────────────────────────────────────────────────
-// Runtime-only, bounded per-room record of turn events that feeds the
-// collapsible Activity view. Never persisted — it is presentation state like
-// running/epoch, and the room transcript (log) stays the only durable record.
-// Every event is tagged with the room epoch it belongs to, so the view shows
-// only the CURRENT run: a newer send bumps the epoch (old-run events drop
-// away), and a rename re-keys the room (the feed starts clean under the new
-// name — stale events under the old key simply have no room to attach to).
-const GROUP_ACTIVITY_LIMIT = 50
-const $groupActivity = atom({})
-
-function recordGroupActivity(group, event) {
-  const room = $groupChats.get()[group]
-
-  if (!room) {
-    return null
-  }
-
-  const current = $groupActivity.get()[group] || { events: [] }
-  const entry = { at: Date.now(), epoch: room.epoch || 0, ...event }
-  const events = [...current.events, entry].slice(-GROUP_ACTIVITY_LIMIT)
-  $groupActivity.set({ ...$groupActivity.get(), [group]: { ...current, events } })
-
-  return entry
-}
-
-/** Events for the room's CURRENT run — superseded runs (epoch moved on)
- *  are dropped from view instead of describing work that already ended. */
-function currentGroupActivity(group) {
-  const epoch = ($groupChats.get()[group] || {}).epoch || 0
-  return ($groupActivity.get()[group] || {}).events?.filter(event => (event.epoch || 0) === epoch) || []
-}
-
-/** Human label for one activity event, used by the collapsed summary and
- *  the expanded rows. */
-function groupActivityLabel(event) {
-  const kind = event?.kind
-  const base = GROUP_ACTIVITY_LABELS[kind] || kind || 'did something'
-
-  if (kind === 'cancelled' || kind === 'settled' || kind === 'capped') {
-    return base
-  }
-
-  const who = event?.member === 'You' ? 'You' : groupSpeakerLabel(event?.member || 'A bot')
-
-  return `${who} ${base}`
-}
-
-const GROUP_ACTIVITY_LABELS = {
-  queued: 'sent a message',
-  working: 'is working…',
-  replied: 'replied',
-  passed: 'passed',
-  'timed-out': 'took too long',
-  failed: 'hit an error',
-  cancelled: 'turn interrupted by a newer message',
-  settled: 'turn settled',
-  capped: 'turn stopped at the round/message cap',
-  delivered: 'delivered a late reply',
-  held: 'is held (stopped by you) — @mention it or say resume to release',
-  stopped: 'stopped the room — remaining turns are held until resumed'
-}
-
-const GROUP_ACTIVITY_GLYPHS = {
-  queued: 'comment',
-  working: 'sync',
-  replied: 'check',
-  passed: 'circle-outline',
-  'timed-out': 'clock',
-  failed: 'error',
-  cancelled: 'close',
-  settled: 'check-all',
-  capped: 'debug-step-over',
-  delivered: 'mail-read',
-  held: 'debug-pause',
-  stopped: 'debug-stop'
-}
-
-/** Text tone for an activity row: quiet for pass/cancel/settle, accent for
- *  work and real replies, destructive for failures and timeouts. */
-function groupActivityTone(kind) {
-  if (kind === 'failed' || kind === 'timed-out') {
-    return 'text-destructive'
-  }
-
-  if (kind === 'working' || kind === 'replied' || kind === 'delivered') {
-    return 'text-(--ui-accent,#4f9cf9)'
-  }
-
-  return 'text-(--ui-text-tertiary)'
-}
-
-const GROUP_CHAT_SYNC_META_KEY = 'hermes-bots-groups'
-// Gateway ui_meta is capped after Python JSON serialization. Keep a healthy
-// margin below that limit because Python escapes Unicode while JS does not.
-const GROUP_CHAT_SYNC_MAX_BYTES = 48000
-const GROUP_CHAT_SYNC_MESSAGES = 16
-const GROUP_CHAT_SYNC_TEXT_CHARS = 1200
-const GROUP_CHAT_SYNC_IMAGE_CHARS = 24000
-let groupChatSyncTimer = null
-// Fan-out scheduler state, keyed by gateway connectionId ('' = active/local).
-// Every connected gateway carries the full projection so a room survives any
-// single gateway being removed and surfaces on every remote backend.
-const groupChatSyncPendingByConnection = new Map()
-const groupChatSyncInFlightConnections = new Set()
-const groupChatSyncRetryTimers = new Map()
-const groupChatSyncRetryCounts = new Map()
-let groupChatSyncDisposed = false
-
-/** Conservative byte count for the gateway's ensure_ascii JSON encoding.
- *  Python also inserts separator spaces, so reserve one extra byte per JS
- *  structural separator on top of escaped Unicode code-point widths. */
-function groupChatGatewayJsonSize(value) {
-  const json = JSON.stringify(value)
-  let bytes = 0
-
-  for (const character of json) {
-    const codePoint = character.codePointAt(0)
-
-    if (codePoint <= 0x7f) {
-      bytes += 1
-      if (character === ',' || character === ':') {
-        bytes += 1
-      }
-    } else {
-      bytes += codePoint <= 0xffff ? 6 : 12
-    }
-  }
-
-  return bytes
-}
-
-/** Durable room identity for the sync projection. Rooms minted on current
- *  builds carry an immutable roomId; the projection keys rooms by
- *  `id:<roomId>` so rename is a display-name edit, not a distributed
- *  delete+create, and disband tombstones follow the room itself. Legacy
- *  rooms (no roomId) fall back to `name:<name>` keys with the older
- *  revision-gated tombstone semantics. */
-function groupChatRoomKey(name, room) {
-  return typeof room?.roomId === 'string' && room.roomId
-    ? `id:${room.roomId}`
-    : `name:${String(name)}`
-}
-
-/** Lift any historical projection shape (v1 wall-clock, v2 name-keyed) to
- *  the v3 room-key shape so one merge path serves mixed-version fleets. */
-function normalizeGroupChatSyncSnapshot(snapshot) {
-  if (!snapshot || typeof snapshot !== 'object') {
-    return { version: 3, rooms: {}, deleted: {} }
-  }
-  if (Number(snapshot.version || 0) >= 3) {
-    return {
-      version: 3,
-      updatedAt: Number(snapshot.updatedAt || 0),
-      rooms: snapshot.rooms && typeof snapshot.rooms === 'object' ? snapshot.rooms : {},
-      deleted: snapshot.deleted && typeof snapshot.deleted === 'object' ? snapshot.deleted : {}
-    }
-  }
-  const rooms = {}
-  for (const [name, room] of Object.entries(snapshot.rooms || {})) {
-    if (!room || !Array.isArray(room.log)) {
-      continue
-    }
-    rooms[`name:${name}`] = { ...room, name }
-  }
-  const deleted = {}
-  for (const [name, at] of Object.entries(snapshot.deleted || {})) {
-    // v1 tombstones carried wall-clock ms, not gateway revisions — they must
-    // not outrank real revisions (same rule groupChatSyncDeletedRevision
-    // applied before v3).
-    deleted[`name:${name}`] = Number(snapshot.version || 0) >= 2 ? Math.max(0, Number(at || 0)) : 0
-  }
-  return { version: 3, updatedAt: Number(snapshot.updatedAt || 0), rooms, deleted }
-}
-
-/** Compact, display-oriented copy of Desktop's room log for gateway clients.
- *  The live orchestration state stays in plugin storage; this bounded mirror
- *  rides the default profile's ui_meta so mobile can show the same messages.
- *  Newest rooms/messages win when the profile metadata size cap is reached. */
-function groupChatSyncSnapshot(all = $groupChats.get(), deleted = {}) {
-  const ranked = Object.entries(all || {})
-    // Empty runtime tombstones are used to stop an in-flight room after
-    // disband. They are not real rooms and must never reappear on mobile.
-    .filter(([, room]) => room && Array.isArray(room.log) && room.log.length > 0)
-    .sort(([, left], [, right]) => {
-      const leftAt = Number(left.log[left.log.length - 1]?.at || 0)
-      const rightAt = Number(right.log[right.log.length - 1]?.at || 0)
-      return rightAt - leftAt
-    })
-  const rooms = {}
-  const boundedDeleted = Object.fromEntries(
-    Object.entries(deleted)
-      .sort(([, left], [, right]) => Number(right || 0) - Number(left || 0))
-      .slice(0, 64)
-  )
-  const envelope = {
-    version: 3,
-    updatedAt: Date.now(),
-    rooms,
-    ...(Object.keys(boundedDeleted).length ? { deleted: boundedDeleted } : {})
-  }
-
-  for (const [name, room] of ranked) {
-    const log = room.log.slice(-GROUP_CHAT_SYNC_MESSAGES).map(entry => ({
-      ...(entry?.id ? { id: String(entry.id).slice(0, 160) } : {}),
-      from: {
-        kind: entry?.from?.kind === 'member' ? 'member' : 'user',
-        name: String(entry?.from?.name || (entry?.from?.kind === 'member' ? 'Bot' : 'You')).slice(0, 128),
-        ...(entry?.from?.source ? { source: String(entry.from.source).slice(0, 128) } : {})
-      },
-      text: String(entry?.text || '').slice(0, GROUP_CHAT_SYNC_TEXT_CHARS),
-      at: Number(entry?.at || 0),
-      ...(entry?.thread ? { thread: String(entry.thread).slice(0, 128) } : {})
-    }))
-    const compact = {
-      name: String(name).slice(0, 64),
-      ...(typeof room?.roomId === 'string' && room.roomId ? { roomId: String(room.roomId).slice(0, 128) } : {}),
-      log,
-      revision: Math.max(0, Number(room?.syncRevision ?? room?.revision ?? 0)),
-      members: (Array.isArray(room.members) ? room.members : []).slice(0, GROUP_CHAT_MAX_MEMBERS).map(member => ({
-        name: String(member?.name || '').slice(0, 128),
-        ...(member?.handle ? { handle: String(member.handle).slice(0, 128) } : {}),
-        ...(member?.connectionId ? { connectionId: String(member.connectionId).slice(0, 128) } : {}),
-        ...(member?.connectionKind ? { connectionKind: String(member.connectionKind).slice(0, 64) } : {}),
-        ...(member?.connectionLabel ? { connectionLabel: String(member.connectionLabel).slice(0, 128) } : {}),
-        ...(member?.sourceScoped ? { sourceScoped: true } : {})
-      })),
-      ...(typeof room?.image === 'string' && room.image.length <= GROUP_CHAT_SYNC_IMAGE_CHARS
-        ? { image: room.image }
-        : {})
-    }
-
-    const key = groupChatRoomKey(name, room)
-    rooms[key] = compact
-    while (compact.log.length > 1 && groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
-      compact.log.shift()
-    }
-    if (compact.image && groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
-      delete compact.image
-    }
-    if (groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
-      delete rooms[key]
-    }
-  }
-
-  return envelope
-}
-
-function groupChatSyncEntryKey(entry) {
-  if (entry?.id) {
-    return `id:${String(entry.id)}`
-  }
-  return JSON.stringify([
-    Number(entry?.at || 0),
-    String(entry?.from?.kind || ''),
-    String(entry?.from?.name || ''),
-    String(entry?.from?.source || ''),
-    // Threadless entries (pre-thread rooms, older Desktop builds) get
-    // SYNTHETIC `legacy-N` ids from assignLegacyThreads. Those ids are
-    // position-derived — not stable across a gateway round-trip (the
-    // projection copy may be threadless or numbered differently). Collapse
-    // the whole synthetic family to one bucket, or the merge duplicates
-    // every id-less entry — shifting watermarks and manufacturing phantom
-    // member turns that re-submit into busy sessions.
-    String(entry?.thread || 'legacy').replace(/^legacy-\d+$/, 'legacy'),
-    String(entry?.text || '')
-  ])
-}
-
-function groupChatSyncMemberKey(member) {
-  return JSON.stringify([
-    String(member?.source || ''),
-    String(member?.connectionId || ''),
-    String(member?.connectionLabel || ''),
-    String(member?.handle || ''),
-    String(member?.name || '')
-  ])
-}
-
-function groupChatSyncDeletedRevision(source, value) {
-  return Number(source?.version || 0) >= 2 ? Math.max(0, Number(value || 0)) : 0
-}
-
-/** Merge two bounded projections without treating an absent room/message as
- *  deletion. Rooms are identified by durable room keys (id:<roomId> when the
- *  room carries one), so a rename is a same-key field update — never a
- *  distributed delete+create — and a disband tombstone follows the room
- *  itself. Gateway revisions order identity/membership/picture and
- *  tombstones; stable message ids make concurrent log union idempotent.
- *  `changedRooms`/`deletedRooms` accept display names or room keys. */
-function mergeGroupChatSyncSnapshots(
-  remote,
-  local,
-  { changedRooms = [], deletedRooms = [], writeRevision = 0 } = {}
-) {
-  const remoteNorm = normalizeGroupChatSyncSnapshot(remote)
-  const localNorm = normalizeGroupChatSyncSnapshot(local)
-  const keysFor = (label, norm) => {
-    const keys = new Set()
-    for (const [key, room] of Object.entries(norm.rooms || {})) {
-      if (key === label || String(room?.name || '') === label || key === `name:${label}`) {
-        keys.add(key)
-      }
-    }
-    if (String(label).startsWith('id:') || String(label).startsWith('name:')) {
-      keys.add(label)
-    } else if (!keys.size) {
-      keys.add(`name:${label}`)
-    }
-    return keys
-  }
-  const changed = new Set()
-  for (const label of changedRooms) {
-    for (const key of keysFor(label, localNorm)) {
-      changed.add(key)
-    }
-  }
-  const deleted = {}
-  for (const source of [remoteNorm, localNorm]) {
-    for (const [key, at] of Object.entries(source.deleted || {})) {
-      deleted[key] = Math.max(Number(deleted[key] || 0), Math.max(0, Number(at || 0)))
-    }
-  }
-  for (const label of deletedRooms) {
-    for (const key of new Set([...keysFor(label, remoteNorm), ...keysFor(label, localNorm)])) {
-      // Rename passes changedRooms:[newName] + deletedRooms:[oldName]. For an
-      // id-keyed room both labels resolve to the SAME durable key (the remote
-      // copy still carries the old display name), and id tombstones are
-      // final — so tombstoning here would kill the room being renamed. A key
-      // that is being written this cycle is a rename target, not a disband.
-      if (changed.has(key)) {
-        continue
-      }
-      deleted[key] = Math.max(Number(deleted[key] || 0), Number(writeRevision || 0))
-    }
-  }
-
-  const rooms = {}
-  const roomKeys = new Set([...Object.keys(remoteNorm.rooms || {}), ...Object.keys(localNorm.rooms || {})])
-  for (const key of roomKeys) {
-    const remoteRoom = remoteNorm.rooms?.[key]
-    const localRoom = localNorm.rooms?.[key]
-    if ((!remoteRoom || !Array.isArray(remoteRoom.log)) && (!localRoom || !Array.isArray(localRoom.log))) {
-      continue
-    }
-    const remoteRevision = Math.max(0, Number(remoteRoom?.revision || 0))
-    const localRevision = changed.has(key)
-      ? Math.max(0, Number(writeRevision || 0))
-      : Math.max(0, Number(localRoom?.revision || 0))
-    const entries = new Map()
-    for (const entry of [...(remoteRoom?.log || []), ...(localRoom?.log || [])]) {
-      entries.set(groupChatSyncEntryKey(entry), entry)
-    }
-
-    // Identity fields (display name, membership, picture) follow the higher
-    // revision; a tie unions members and prefers the local writer's fields.
-    let identity
-    let members
-    let image
-    if (localRevision > remoteRevision) {
-      identity = localRoom
-      members = [...(localRoom?.members || [])]
-      image = localRoom?.image
-    } else if (remoteRevision > localRevision) {
-      identity = remoteRoom
-      members = [...(remoteRoom?.members || [])]
-      image = remoteRoom?.image
-    } else {
-      identity = localRoom || remoteRoom
-      const byId = new Map()
-      for (const member of [...(remoteRoom?.members || []), ...(localRoom?.members || [])]) {
-        byId.set(groupChatSyncMemberKey(member), member)
-      }
-      members = [...byId.values()]
-      image = Object.prototype.hasOwnProperty.call(localRoom || {}, 'image') ? localRoom.image : remoteRoom?.image
-    }
-    rooms[key] = {
-      ...(identity?.name ? { name: identity.name } : {}),
-      ...(identity?.roomId || (key.startsWith('id:') ? key.slice(3) : '')
-        ? { roomId: identity?.roomId || key.slice(3) }
-        : {}),
-      log: [...entries.values()].sort((left, right) => {
-        const byTime = Number(left?.at || 0) - Number(right?.at || 0)
-        return byTime || groupChatSyncEntryKey(left).localeCompare(groupChatSyncEntryKey(right))
-      }),
-      members,
-      revision: Math.max(remoteRevision, localRevision),
-      ...(typeof image === 'string' && image ? { image } : {})
-    }
-  }
-
-  for (const [key, deletedRevision] of Object.entries(deleted)) {
-    if (key.startsWith('id:')) {
-      // Tombstones for id-keyed rooms are FINAL: the roomId is minted once
-      // and never reused (same-name recreation mints a fresh id), so a
-      // resurrect-by-revision race is structurally impossible. Keep the
-      // tombstone even when a lagging gateway's copy carries a higher
-      // revision — that copy is the resurrection this exists to prevent.
-      delete rooms[key]
-    } else if (Number(deletedRevision || 0) >= Number(rooms[key]?.revision || 0)) {
-      delete rooms[key]
-    } else {
-      delete deleted[key]
-    }
-  }
-
-  return groupChatSyncEnvelope(rooms, deleted)
-}
-
-/** Assemble + size-bound a v3 envelope from already-compacted rooms. */
-function groupChatSyncEnvelope(rooms, deleted = {}) {
-  const boundedDeleted = Object.fromEntries(
-    Object.entries(deleted)
-      .sort(([, left], [, right]) => Number(right || 0) - Number(left || 0))
-      .slice(0, 64)
-  )
-  const envelope = {
-    version: 3,
-    updatedAt: Date.now(),
-    rooms,
-    ...(Object.keys(boundedDeleted).length ? { deleted: boundedDeleted } : {})
-  }
-  const ranked = Object.entries(rooms).sort(([, left], [, right]) => {
-    const leftAt = Number(left?.log?.[left.log.length - 1]?.at || 0)
-    const rightAt = Number(right?.log?.[right.log.length - 1]?.at || 0)
-    return leftAt - rightAt
-  })
-  for (const [key, room] of ranked) {
-    while ((room.log?.length || 0) > 1 && groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
-      room.log.shift()
-    }
-    if (room.image && groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
-      delete room.image
-    }
-    if (groupChatGatewayJsonSize(envelope) > GROUP_CHAT_SYNC_MAX_BYTES) {
-      delete rooms[key]
-    }
-  }
-  return envelope
-}
-
-/** Merge the gateway's bounded display projection into Desktop's richer room
- *  state without discarding local session/watermark/runtime fields. Missing
- *  remote rooms/messages are not deletions; only explicit tombstones remove a
- *  room, and a genuinely newer local message wins over a stale tombstone. */
-function mergeRemoteGroupChatSnapshotIntoRooms(
-  remote,
-  current = $groupChats.get(),
-  { preserveRooms = [], deletedRooms = [] } = {}
-) {
-  const remoteNorm = normalizeGroupChatSyncSnapshot(remote)
-  const rooms = { ...(current || {}) }
-  const preserved = new Set(preserveRooms)
-  const locallyDeleted = new Set(deletedRooms)
-
-  // Local rooms indexed by durable identity so an id-keyed projection room
-  // finds its local twin even when the display name changed remotely.
-  const localByRoomId = new Map()
-  for (const [name, room] of Object.entries(rooms)) {
-    if (typeof room?.roomId === 'string' && room.roomId) {
-      localByRoomId.set(room.roomId, name)
-    }
-  }
-
-  for (const [key, projected] of Object.entries(remoteNorm.rooms || {})) {
-    if (!projected || !Array.isArray(projected.log)) {
-      continue
-    }
-    const projectedRoomId = projected.roomId || (key.startsWith('id:') ? key.slice(3) : null)
-    const localName = projectedRoomId && localByRoomId.has(projectedRoomId)
-      ? localByRoomId.get(projectedRoomId)
-      : (projected.name && rooms[projected.name] ? projected.name : null)
-    const displayName = String(projected.name || localName || (key.startsWith('name:') ? key.slice(5) : key))
-    if (locallyDeleted.has(displayName) || (localName && locallyDeleted.has(localName))) {
-      // Mid-rename guard: the remote copy may still be under the OLD display
-      // name while the local record was already re-keyed (same roomId, new
-      // name). That old name sits in deletedRooms, but the local record is
-      // the rename in flight — deleting it here would kill the renamed room.
-      if (localName && localName !== displayName && !locallyDeleted.has(localName)) {
-        continue
-      }
-      delete rooms[displayName]
-      if (localName) {
-        delete rooms[localName]
-      }
-      continue
-    }
-    const existing = (localName ? rooms[localName] : rooms[displayName]) || {}
-    const remoteRevision = Math.max(0, Number(projected.revision || 0))
-    const localRevision = Math.max(0, Number(existing.syncRevision || 0))
-    const entries = new Map(
-      (Array.isArray(existing.log) ? existing.log : []).map(entry => [groupChatSyncEntryKey(entry), entry])
-    )
-    const members = new Map(
-      (Array.isArray(existing.members) ? existing.members : []).map(member => [groupChatSyncMemberKey(member), member])
-    )
-
-    for (const entry of projected.log) {
-      const entryKey = groupChatSyncEntryKey(entry)
-      // The projection is COMPACT (truncated text, no images). When the same
-      // entry exists locally, the local rich copy is authoritative — merging
-      // the compact twin over it would strip attachments and retrigger
-      // watermark deltas for members that already saw it (phantom rounds).
-      if (!entries.has(entryKey)) {
-        entries.set(entryKey, entry)
-      }
-    }
-    const isPreserved = preserved.has(displayName) || (localName && preserved.has(localName))
-    if (!isPreserved) {
-      if (remoteRevision > localRevision) {
-        members.clear()
-      }
-      for (const member of Array.isArray(projected.members) ? projected.members : []) {
-        members.set(groupChatSyncMemberKey(member), { ...member, remoteSource: true })
-      }
-    }
-
-    const log = assignLegacyThreads(
-      [...entries.values()].sort((left, right) => {
-        const byTime = Number(left?.at || 0) - Number(right?.at || 0)
-        return byTime || groupChatSyncEntryKey(left).localeCompare(groupChatSyncEntryKey(right))
-      })
-    )
-    const bounded = trimGroupChatLog(log, existing.watermarks || {})
-
-    // A remote rename with a higher revision moves the local record to the
-    // new display name; local views keyed by the old name follow on the
-    // next repaint (roster derives from $groupChats keys).
-    const targetName = !isPreserved && remoteRevision > localRevision ? displayName : (localName || displayName)
-    if (localName && targetName !== localName) {
-      delete rooms[localName]
-    }
-
-    rooms[targetName] = {
-      ...existing,
-      log: bounded.log,
-      watermarks: bounded.watermarks,
-      sessions: existing.sessions && typeof existing.sessions === 'object' ? existing.sessions : {},
-      stranded: existing.stranded && typeof existing.stranded === 'object' ? existing.stranded : {},
-      members: [...members.values()],
-      ...(projectedRoomId || existing.roomId ? { roomId: existing.roomId || projectedRoomId } : {}),
-      image: isPreserved
-        ? existing.image || null
-        : remoteRevision >= localRevision && Object.prototype.hasOwnProperty.call(projected, 'image')
-          ? projected.image || null
-          : existing.image || null,
-      syncRevision: isPreserved ? localRevision : Math.max(remoteRevision, localRevision),
-      epoch: Number(existing.epoch || 0),
-      running: Boolean(existing.running)
-    }
-  }
-
-  for (const [key, deletedAt] of Object.entries(remoteNorm.deleted || {})) {
-    const deletedRoomId = key.startsWith('id:') ? key.slice(3) : null
-    const targetName = deletedRoomId && localByRoomId.has(deletedRoomId)
-      ? localByRoomId.get(deletedRoomId)
-      : key.startsWith('name:') ? key.slice(5) : null
-    if (!targetName || preserved.has(targetName)) {
-      continue
-    }
-    if (deletedRoomId) {
-      // Id tombstones are final — the id is never reused, so there is no
-      // legitimate higher-revision recreation to protect.
-      delete rooms[targetName]
-    } else {
-      const deletedRevision = Math.max(0, Number(deletedAt || 0))
-      if (deletedRevision >= Number(rooms[targetName]?.syncRevision || 0)) {
-        delete rooms[targetName]
-      }
-    }
-  }
-  for (const name of locallyDeleted) {
-    delete rooms[name]
-  }
-
-  return rooms
-}
-
-function durableGroupChatRooms(all = $groupChats.get()) {
-  const durable = {}
-
-  for (const [name, room] of Object.entries(all || {})) {
-    if (!room || !Array.isArray(room.log)) {
-      continue
-    }
-    // Disband tombstones are runtime-only coordination state (they hold the
-    // epoch bump for an in-flight drive). Persisting one would resurrect the
-    // room as an empty record on the next load AND keep its name "taken" for
-    // same-name recreates. Mirrors updateGroupChat's inline durable map.
-    if (room.tombstone) {
-      continue
-    }
-    durable[name] = {
-      log: room.log,
-      watermarks: room.watermarks || {},
-      sessions: room.sessions || {},
-      stranded: room.stranded || {},
-      members: Array.isArray(room.members) ? room.members : [],
-      // Immutable room identity: without this, a room merged in via the
-      // remote-sync path (the only caller of this function) loses its
-      // roomId on the next cold hydrate and falls back to legacy
-      // name-keyed identity — same field updateGroupChat's inline map
-      // already carries.
-      roomId: typeof room.roomId === 'string' && room.roomId ? room.roomId : null,
-      image: room.image || null,
-      syncRevision: Math.max(0, Number(room.syncRevision || 0))
-    }
-  }
-
-  return durable
-}
-
-function persistGroupChatRooms(all = $groupChats.get()) {
-  try {
-    return Promise.resolve(pluginCtx?.storage?.set?.('group-chats', durableGroupChatRooms(all))).catch(() => undefined)
-  } catch {
-    return Promise.resolve()
-  }
-}
-
-// ── deleted-connection roster hygiene (#93492 root cause) ───────────────────
-// Deleting a cloud/remote connection used to leave every persisted group-chat
-// member descriptor that referenced it behind untouched. Those orphaned rows
-// (remoteSource: true, connection gone) are exactly the shape that made
-// render-path route lookups throw "Bot X has no connection owner" on every
-// group open, permanently — the poisoned row lives in plugin storage. The
-// sweep below runs on the registry's 'removed' push (and its annotate helper
-// again at hydrate for rows orphaned before this build). It never hard-deletes
-// user data: the member row is kept and marked, so panes render the existing
-// degraded 'Gateway removed' botSourceStatus state instead of crashing.
-
-/** Keep the member's identity; mark it so botSourceStatus reads
- *  'Gateway removed' and no render-path route lookup can throw on it. */
-function markOrphanedGroupMemberDescriptor(member) {
-  return {
-    ...member,
-    sourceMissing: true,
-    sourceReachable: false
-  }
-}
-
-function groupMemberReferencesConnection(member, connectionId) {
-  const id = String(connectionId || '').trim()
-
-  if (!id) {
-    return false
-  }
-
-  return (
-    String(member?.connectionId || '').trim() === id ||
-    String(member?.route?.connectionId || '').trim() === id
-  )
-}
-
-/** Register-removed sweep: annotate (not delete) every persisted group-chat
- *  member owned by the deleted connection, in the atom AND plugin storage.
- *  Writes ride updateGroupChat so the durable record keeps its full shape
- *  (sessionOwners, holds — durableGroupChatRooms would drop them).
- *  Returns whether anything changed. */
-function sweepGroupChatMembersForRemovedConnection(connectionId) {
-  const id = String(connectionId || '').trim()
-
-  if (!id) {
-    return false
-  }
-
-  let changed = false
-
-  for (const [name, room] of Object.entries($groupChats.get())) {
-    const members = Array.isArray(room?.members) ? room.members : []
-
-    if (!members.some(member => groupMemberReferencesConnection(member, id) && !member?.sourceMissing)) {
-      continue
-    }
-
-    changed = true
-    updateGroupChat(name, current => ({
-      ...current,
-      members: (Array.isArray(current.members) ? current.members : []).map(member =>
-        groupMemberReferencesConnection(member, id) ? markOrphanedGroupMemberDescriptor(member) : member
-      )
-    }))
-  }
-
-  return changed
-}
-
-/** Hydrate-time pass for rows orphaned BEFORE this build (the poisoned rows
- *  that made #93492 survive app restarts). Two shapes are annotated, never
- *  deleted:
- *  - a descriptor that already lost its connectionId (route unresolvable —
- *    exactly what a stale row looks like once its connection was deleted);
- *  - a descriptor whose connectionId is absent from the live registry, when
- *    the caller could obtain one (liveConnectionIds === null means "registry
- *    unavailable", which must NOT read as "everything is orphaned").
- *  Pure on the rooms map; returns { rooms, changed }. */
-function annotateOrphanedGroupChatMembers(rooms, liveConnectionIds = null) {
-  // Duck-typed, not instanceof: callers (and vm-based tests) may hand a Set
-  // constructed in another realm.
-  const live = liveConnectionIds && typeof liveConnectionIds.has === 'function' ? liveConnectionIds : null
-  const next = {}
-  let changed = false
-
-  for (const [name, room] of Object.entries(rooms || {})) {
-    const members = Array.isArray(room?.members) ? room.members : []
-    const orphaned = member => {
-      if (!member || member.sourceMissing) {
-        return false
-      }
-
-      if (!member.sourceScoped && !member.remoteSource) {
-        return false
-      }
-
-      const id = String(member.route?.connectionId || member.connectionId || '').trim()
-
-      if (!id) {
-        // Route unresolvable: this is the row shape that threw on render.
-        return true
-      }
-
-      return live ? !live.has(id) : false
-    }
-
-    if (!members.some(orphaned)) {
-      next[name] = room
-      continue
-    }
-
-    changed = true
-    next[name] = {
-      ...room,
-      members: members.map(member => (orphaned(member) ? markOrphanedGroupMemberDescriptor(member) : member))
-    }
-  }
-
-  return { rooms: next, changed }
-}
-
-function groupChatSyncConnectionId() {
-  return String(host.state.connectionId?.get?.() || host.activeConnectionId?.() || '')
-}
-
-/** Route a sync job back to the gateway that was active when it was queued.
- *  A foreground switch during debounce must not write the old snapshot into
- *  the newly active gateway. */
-async function groupChatSyncRequest(job, method, params) {
-  if (job.connectionId && typeof host.profileRoutes === 'function' && typeof host.requestProfile === 'function') {
-    const routes = await host.profileRoutes()
-    const route = (Array.isArray(routes) ? routes : []).find(candidate => {
-      const profile = String(candidate?.targetProfile || candidate?.profile || '')
-      return String(candidate?.connectionId || '') === job.connectionId && profile === 'default'
-    })
-
-    if (route) {
-      return host.requestProfile(route, method, params)
-    }
-  }
-
-  const currentConnectionId = groupChatSyncConnectionId()
-  if (job.connectionId && currentConnectionId && job.connectionId !== currentConnectionId) {
-    throw new Error('Group chat gateway changed before sync')
-  }
-  return host.request(method, params)
-}
-
-async function groupChatRemoteSnapshot(job) {
-  const result = await groupChatSyncRequest(job, 'profiles.list', { include_sessions: false })
-  const profile = (Array.isArray(result?.profiles) ? result.profiles : []).find(row => row?.name === 'default')
-  const snapshot = profile?.ui_meta?.[GROUP_CHAT_SYNC_META_KEY]
-  const supportsCas = Boolean(profile && Object.prototype.hasOwnProperty.call(profile, 'ui_meta_revisions'))
-  return {
-    snapshot: snapshot && typeof snapshot === 'object' && !Array.isArray(snapshot) ? snapshot : null,
-    revision: Math.max(0, Number(profile?.ui_meta_revisions?.[GROUP_CHAT_SYNC_META_KEY] || 0)),
-    supportsCas
-  }
-}
-
-/** Pull the shared room projection into this Desktop before it publishes any
- *  local state. This is the receive half of the client-only sync contract. */
-async function pullGroupChatServerState(connectionId = groupChatSyncConnectionId()) {
-  const { snapshot: remote } = await groupChatRemoteSnapshot({ connectionId })
-
-  if (!remote) {
-    return false
-  }
-  const pending = groupChatSyncPendingByConnection.get(String(connectionId || ''))
-  const merged = mergeRemoteGroupChatSnapshotIntoRooms(remote, $groupChats.get(), {
-    preserveRooms: pending?.changedRooms || [],
-    deletedRooms: pending?.deletedRooms || []
-  })
-  $groupChats.set(merged)
-  await persistGroupChatRooms(merged)
-  return true
-}
-
-function groupChatSyncBackoff(connectionId) {
-  const count = Number(groupChatSyncRetryCounts.get(connectionId) || 0)
-  return Math.min(30000, 1000 * 2 ** Math.min(count, 5))
-}
-
-function mergeGroupChatSyncJobs(existing, incoming) {
-  if (!existing || existing.connectionId !== incoming.connectionId) {
-    return incoming
-  }
-  return {
-    connectionId: incoming.connectionId,
-    allowEmpty: Boolean(existing.allowEmpty || incoming.allowEmpty),
-    changedRooms: [...new Set([...(existing.changedRooms || []), ...(incoming.changedRooms || [])])],
-    deletedRooms: [...new Set([...(existing.deletedRooms || []), ...(incoming.deletedRooms || [])])]
-  }
-}
-
-function groupChatSyncPayloadEqual(left, right) {
-  return (
-    JSON.stringify(left?.rooms || {}) === JSON.stringify(right?.rooms || {}) &&
-    JSON.stringify(left?.deleted || {}) === JSON.stringify(right?.deleted || {})
-  )
-}
-
-/** Every default-profile gateway route this Desktop can currently reach.
- *  The projection fans out to ALL of them, so any single gateway can die or
- *  be removed without losing the shared room state, and gateway-only
- *  clients (Hermes Go, headless backends) see rooms regardless of which
- *  gateway a Desktop was foregrounding when the room was used. */
-async function groupChatSyncTargetConnections() {
-  const targets = new Set()
-  const active = groupChatSyncConnectionId()
-  targets.add(String(active || ''))
-  if (typeof host.profileRoutes === 'function' && typeof host.requestProfile === 'function') {
-    try {
-      const routes = await host.profileRoutes()
-      for (const route of Array.isArray(routes) ? routes : []) {
-        const profile = String(route?.targetProfile || route?.profile || '')
-        const connectionId = String(route?.connectionId || '')
-        if (profile === 'default' && connectionId) {
-          targets.add(connectionId)
-        }
-      }
-    } catch {
-      // Route inventory unavailable — the active gateway alone still syncs.
-    }
-  }
-  return [...targets]
-}
-
-async function flushGroupChatServerSync(connectionId) {
-  if (connectionId === undefined) {
-    // Drain every connection with pending work.
-    for (const pendingId of [...groupChatSyncPendingByConnection.keys()]) {
-      void flushGroupChatServerSync(pendingId)
-    }
-    return
-  }
-  const id = String(connectionId || '')
-  if (groupChatSyncDisposed || groupChatSyncInFlightConnections.has(id) || !groupChatSyncPendingByConnection.has(id)) {
-    return
-  }
-  const job = groupChatSyncPendingByConnection.get(id)
-  groupChatSyncPendingByConnection.delete(id)
-  groupChatSyncInFlightConnections.add(id)
-
-  try {
-    const remoteState = await groupChatRemoteSnapshot(job)
-    const local = groupChatSyncSnapshot($groupChats.get())
-    const writeRevision = remoteState.revision + 1
-    const snapshot = mergeGroupChatSyncSnapshots(remoteState.snapshot, local, {
-      changedRooms: job.changedRooms,
-      deletedRooms: job.deletedRooms,
-      writeRevision
-    })
-
-    // Reconnect/startup reconciliation often discovers that the gateway
-    // already holds the exact merged projection. Avoid advancing a revision
-    // merely because a view reopened.
-    if (!(job.changedRooms || []).length && !(job.deletedRooms || []).length && groupChatSyncPayloadEqual(snapshot, remoteState.snapshot)) {
-      if (remoteState.snapshot) {
-        const pending = groupChatSyncPendingByConnection.get(id)
-        const mergedRooms = mergeRemoteGroupChatSnapshotIntoRooms(remoteState.snapshot, $groupChats.get(), {
-          preserveRooms: pending?.changedRooms || [],
-          deletedRooms: pending?.deletedRooms || []
-        })
-        $groupChats.set(mergedRooms)
-        await persistGroupChatRooms(mergedRooms)
-      }
-      groupChatSyncRetryCounts.delete(id)
-      return
-    }
-
-    const configureParams = {
-      name: 'default',
-      ui_meta: { [GROUP_CHAT_SYNC_META_KEY]: snapshot }
-    }
-    if (remoteState.supportsCas) {
-      configureParams.ui_meta_expected_revisions = { [GROUP_CHAT_SYNC_META_KEY]: remoteState.revision }
-    }
-    const result = await groupChatSyncRequest(job, 'profiles.configure', configureParams)
-
-    if (result?.applied?.ui_meta !== true) {
-      throw new Error('Gateway rejected group chat ui_meta')
-    }
-    if (
-      remoteState.supportsCas &&
-      Number(result?.applied?.ui_meta_revisions?.[GROUP_CHAT_SYNC_META_KEY] || 0) !== writeRevision
-    ) {
-      throw new Error('Gateway did not advance group chat ui_meta revision')
-    }
-
-    const confirmedState = await groupChatRemoteSnapshot(job)
-    if (remoteState.supportsCas && confirmedState.revision < writeRevision) {
-      throw new Error('Group chat ui_meta revision missing after read-back')
-    }
-    if (confirmedState.snapshot) {
-      const pending = groupChatSyncPendingByConnection.get(id)
-      const mergedRooms = mergeRemoteGroupChatSnapshotIntoRooms(confirmedState.snapshot, $groupChats.get(), {
-        preserveRooms: pending?.changedRooms || [],
-        deletedRooms: pending?.deletedRooms || []
-      })
-      $groupChats.set(mergedRooms)
-      await persistGroupChatRooms(mergedRooms)
-    }
-    groupChatSyncRetryCounts.delete(id)
-  } catch {
-    if (!groupChatSyncDisposed) {
-      const retries = Number(groupChatSyncRetryCounts.get(id) || 0) + 1
-      // A gateway that was REMOVED (not just flaky) has no route anymore and
-      // would otherwise retry forever. Give up after the backoff ladder tops
-      // out; local storage remains authoritative and a future reconnect of
-      // that gateway re-seeds it via the gateway-transition pull/publish.
-      if (retries > 8) {
-        groupChatSyncRetryCounts.delete(id)
-        return
-      }
-      groupChatSyncPendingByConnection.set(id, mergeGroupChatSyncJobs(groupChatSyncPendingByConnection.get(id), job))
-      groupChatSyncRetryCounts.set(id, retries)
-      if (typeof setTimeout === 'function' && !groupChatSyncRetryTimers.has(id)) {
-        groupChatSyncRetryTimers.set(id, setTimeout(() => {
-          groupChatSyncRetryTimers.delete(id)
-          void flushGroupChatServerSync(id)
-        }, groupChatSyncBackoff(id)))
-      }
-    }
-  } finally {
-    groupChatSyncInFlightConnections.delete(id)
-    if (groupChatSyncPendingByConnection.has(id) && !groupChatSyncRetryTimers.has(id) && !groupChatSyncDisposed) {
-      void flushGroupChatServerSync(id)
-    }
-  }
-}
-
-function stopGroupChatServerSync() {
-  groupChatSyncDisposed = true
-  groupChatSyncPendingByConnection.clear()
-  if (groupChatSyncTimer !== null) {
-    clearTimeout(groupChatSyncTimer)
-    groupChatSyncTimer = null
-  }
-  for (const timer of groupChatSyncRetryTimers.values()) {
-    clearTimeout(timer)
-  }
-  groupChatSyncRetryTimers.clear()
-  groupChatSyncRetryCounts.clear()
-}
-
-/** Debounced, pull-merge-write server mirror, fanned out to every reachable
- *  default-profile gateway. Local storage keeps the complete orchestration
- *  log; ui_meta is a bounded cross-client projection per gateway, each with
- *  its own CAS revision stream. */
-function scheduleGroupChatServerSync(
-  all = $groupChats.get(),
-  { allowEmpty = false, changedRooms = [], deletedRooms = [] } = {}
-) {
-  // Browser shells provide timers; source-level VM tests and older embedded
-  // hosts may not. Room persistence must never break the surrounding gateway
-  // lifecycle when the optional mirror cannot be scheduled.
-  if (typeof setTimeout !== 'function') {
-    return
-  }
-  const snapshot = groupChatSyncSnapshot(all)
-  // A newly installed Desktop has no local room cache. Publishing that empty
-  // state on hydrate/reconnect would erase a valid mirror produced elsewhere.
-  // Only an explicit final-room disband is allowed to clear the projection.
-  if (Object.keys(snapshot.rooms).length === 0 && !allowEmpty) {
-    return
-  }
-  if (groupChatSyncTimer !== null) {
-    clearTimeout(groupChatSyncTimer)
-  }
-  // Queue on the ACTIVE gateway synchronously (tests and older hosts have no
-  // async route inventory), then widen to every reachable gateway before the
-  // debounce fires.
-  const activeId = String(groupChatSyncConnectionId() || '')
-  const queueFor = connectionId => {
-    const id = String(connectionId || '')
-    const retryTimer = groupChatSyncRetryTimers.get(id)
-    if (retryTimer !== undefined) {
-      clearTimeout(retryTimer)
-      groupChatSyncRetryTimers.delete(id)
-    }
-    groupChatSyncPendingByConnection.set(id, mergeGroupChatSyncJobs(groupChatSyncPendingByConnection.get(id), {
-      connectionId: id,
-      allowEmpty,
-      changedRooms,
-      deletedRooms
-    }))
-  }
-  queueFor(activeId)
-  groupChatSyncTimer = setTimeout(() => {
-    groupChatSyncTimer = null
-    void groupChatSyncTargetConnections()
-      .then(targets => {
-        for (const target of targets) {
-          if (String(target || '') !== activeId) {
-            queueFor(target)
-          }
-        }
-      })
-      .catch(() => undefined)
-      .then(() => flushGroupChatServerSync())
-  }, 350)
-}
-
-function handleSessionsGatewayTransition() {
-  // A gateway swap invalidates any in-flight room drive: bump every room's
-  // epoch so running loops bail at their next member boundary.
-  const rooms = { ...$groupChats.get() }
-
-  for (const name of Object.keys(rooms)) {
-    rooms[name] = { ...rooms[name], epoch: (rooms[name].epoch || 0) + 1, running: false }
-  }
-
-  $groupChats.set(rooms)
-  // Pull before re-publishing so a reconnect or source swap never lets this
-  // client's stale cache hide a room written by another Desktop/mobile client.
-  void pullGroupChatServerState()
-    .catch(() => false)
-    .then(() => scheduleGroupChatServerSync($groupChats.get()))
-}
-
-// ── cross-connection bot relay ────────────────────────────────────────────
-// Connections ARE the peer set: every gateway this Desktop holds a socket
-// to (local, remote URL, SSH, Hermes Cloud, docker) must be able to find
-// every other connection's agents and message them via message_agent. The
-// Desktop is the relay — it owns every socket. Two loops:
-//  - roster loop: pushes each gateway the union roster of agents on the
-//    OTHER connections (bot_relay.roster.sync), so message_agent resolves
-//    cross-connection targets and Bot Chat prompts list them;
-//  - drain loop: collects queued envelopes from every gateway
-//    (bot_relay.outbox.drain), delivers each on the target connection's
-//    own socket (bot_relay.deliver), and posts the reply back to the
-//    sender gateway (bot_relay.reply) where a waiter wakes the sender.
-// Older backends without the RPCs fail per-call and are skipped — the
-// relay degrades to whatever subset of connections supports it.
-const RELAY_ROSTER_INTERVAL_MS = 60_000
-// Backstop cadence only (#93594): the push path below carries envelope latency,
-// so the interval poll exists for older backends and missed events — 30s
-// matches LIVE_SESSION_STATUS_BACKSTOP_INTERVAL_MS. It was 4s back when the
-// poll WAS the delivery path, which (before route retention) also meant a
-// fresh WebSocket dial + teardown per registered connection every 4s.
-const RELAY_DRAIN_INTERVAL_MS = 30_000
-// Push path (#93091): the gateway broadcasts `bot_relay.outbox.pending` when
-// an envelope lands on disk; a burst of signals inside this window collapses
-// to ONE drain. The interval poll above stays as the backstop for older
-// backends (and connections whose events don't reach the tap).
-const RELAY_PUSH_DEBOUNCE_MS = 250
-let relayDisposed = false
-let relayRosterTimer = null
-let relayDrainTimer = null
-let relayRosterBusy = false
-let relayDrainBusy = false
-let relayPushUnsub = null
-let relayPushDebounceTimer = null
-// A push landing while a drain is ALREADY running would be lost forever —
-// the gateway signature is monotone (one event per new envelope, never
-// re-broadcast) — so remember it and re-schedule after the drain finishes.
-let relayDrainRerun = false
-// Relay-route socket retention (#93594): connection id → release fn. While
-// the relay is active each registered connection's pooled socket is pinned
-// open (host.retainProfileSocket) so drain RPCs reuse ONE persistent
-// WebSocket instead of dialing and tearing down a fresh one per tick.
-// Feature-detected — older shells lack the door and fall back to per-call
-// leases. Local routes get a no-op release inside the host (idle-reaper
-// exemption). stopBotRelay releases everything.
-const relayRouteRetentions = new Map()
-
-/** Reconcile retention with the CURRENT connection set: pin new connections,
- *  release removed ones. Runs on every drain/roster connection fetch. */
-function syncRelayRetention(connections) {
-  if (typeof host.retainProfileSocket !== 'function') {
-    return
-  }
-
-  const live = new Set(connections.map(connection => connection.id))
-
-  for (const [id, release] of [...relayRouteRetentions]) {
-    if (!live.has(id)) {
-      relayRouteRetentions.delete(id)
-      try {
-        release()
-      } catch {
-        // Never let a release failure break the relay loop.
-      }
-    }
-  }
-
-  if (relayDisposed) {
-    return
-  }
-
-  for (const connection of connections) {
-    if (!relayRouteRetentions.has(connection.id)) {
-      relayRouteRetentions.set(connection.id, host.retainProfileSocket(connection.route))
-    }
-  }
-}
-
-/** Drop every relay pin — stop/dispose path. */
-function releaseRelayRetention() {
-  for (const release of relayRouteRetentions.values()) {
-    try {
-      release()
-    } catch {
-      // Disposer from an older shell shape — never break teardown.
-    }
-  }
-
-  relayRouteRetentions.clear()
-}
-
-/** One representative route per reachable connection id. */
-async function relayConnections() {
-  if (typeof host.profileRoutes !== 'function' || typeof host.requestProfile !== 'function') {
-    return []
-  }
-
-  try {
-    const routes = await host.profileRoutes()
-    const byConnection = new Map()
-
-    for (const route of Array.isArray(routes) ? routes : []) {
-      const id = String(route?.connectionId || '')
-
-      if (id && !byConnection.has(id)) {
-        byConnection.set(id, route)
-      }
-    }
-
-    return [...byConnection.entries()].map(([id, route]) => ({ id, route }))
-  } catch {
-    return []
-  }
-}
-
-/** The agents living on one connection, as relay roster rows.
- *  Returns null on FAILURE (transient RPC blip, slow socket) — distinct from
- *  a genuine empty profile list. Conflating the two would push a fresh union
- *  roster missing a LIVE connection's agents, and the gateway-side liveness
- *  check (bot_relay._target_liveness) reads "absent from a fresh roster" as
- *  definitively offline → false runtime_offline refusals (#93091 item 2). */
-async function relayAgentsOn(connection) {
-  try {
-    const res = await host.requestProfile(connection.route, 'profiles.list', { include_sessions: false })
-    const profiles = Array.isArray(res?.profiles) ? res.profiles : []
-    const label = String(
-      connection.route?.connectionLabel || connection.route?.label || connection.id
-    )
-
-    return profiles
-      .map(profile => ({
-        profile: String(profile?.name || ''),
-        handle: botHandle(profile?.name, profile),
-        connection_id: connection.id,
-        connection_label: label,
-        title: String(profile?.ui_meta?.['hermes-bots']?.title || profile?.display_name || ''),
-        description: String(profile?.description || '')
-      }))
-      .filter(row => row.profile)
-  } catch {
-    return null
-  }
-}
-
-/** Last good agent rows per connection id — reused when a fetch blips so a
- *  transient failure never reads as "everyone on that machine went away". */
-const relayAgentsCache = new Map()
-
-/** Push every gateway the union roster of agents on the OTHER connections. */
-async function syncRelayRosters() {
-  if (relayDisposed || relayRosterBusy) {
-    return
-  }
-
-  relayRosterBusy = true
-
-  try {
-    const connections = await relayConnections()
-
-    if (connections.length < 2) {
-      return
-    }
-
-    const agentsByConnection = new Map()
-    await Promise.all(
-      connections.map(async connection => {
-        const agents = await relayAgentsOn(connection)
-
-        if (agents === null) {
-          // Transient fetch failure: reuse the last good rows for this
-          // connection (or contribute nothing this cycle) so the pushed
-          // roster never drops a live machine's agents — absence from a
-          // fresh roster means offline to the gateway-side fail-fast.
-          agentsByConnection.set(connection.id, relayAgentsCache.get(connection.id) || [])
-        } else {
-          relayAgentsCache.set(connection.id, agents)
-          agentsByConnection.set(connection.id, agents)
-        }
-      })
-    )
-
-    // Connections gone from profileRoutes are genuinely disconnected — drop
-    // their cache so a later reconnect starts from live data.
-    const liveIds = new Set(connections.map(connection => connection.id))
-    for (const id of [...relayAgentsCache.keys()]) {
-      if (!liveIds.has(id)) {
-        relayAgentsCache.delete(id)
-      }
-    }
-
-    await Promise.all(
-      connections.map(async connection => {
-        const others = []
-
-        for (const [id, agents] of agentsByConnection) {
-          if (id !== connection.id) {
-            others.push(...agents)
-          }
-        }
-
-        try {
-          await host.requestProfile(connection.route, 'bot_relay.roster.sync', { agents: others })
-        } catch {
-          // Older backend without the relay RPCs — skip this connection.
-        }
-      })
-    )
-  } finally {
-    relayRosterBusy = false
-  }
-}
-
-/** Drain every gateway's outbox and deliver each envelope on the target
- *  connection's own socket; the reply (or error) is posted back to the
- *  sender gateway for its waiter. */
-async function drainRelayOutboxes() {
-  if (relayDisposed) {
-    return
-  }
-
-  if (relayDrainBusy) {
-    // A push signal raced an in-flight drain. The gateway never re-sends it
-    // (monotone signature), so without this flag the envelope would wait out
-    // the full poll interval — exactly the latency the push path removes.
-    relayDrainRerun = true
-
-    return
-  }
-
-  relayDrainBusy = true
-
-  try {
-    const connections = await relayConnections()
-
-    // Retention follows the relay-eligible set: with fewer than two
-    // connections there is nothing to relay, so nothing stays pinned.
-    syncRelayRetention(connections.length >= 2 ? connections : [])
-
-    if (connections.length < 2) {
-      return
-    }
-
-    const byId = new Map(connections.map(connection => [connection.id, connection]))
-
-    for (const sender of connections) {
-      let envelopes = []
-
-      try {
-        const res = await host.requestProfile(sender.route, 'bot_relay.outbox.drain', {})
-        envelopes = Array.isArray(res?.envelopes) ? res.envelopes : []
-      } catch {
-        continue
-      }
-
-      for (const envelope of envelopes) {
-        if (relayDisposed) {
-          return
-        }
-
-        const envelopeId = String(envelope?.id || '')
-        const target = byId.get(String(envelope?.target_connection || ''))
-        const postReply = async payload => {
-          try {
-            await host.requestProfile(sender.route, 'bot_relay.reply', { id: envelopeId, ...payload })
-          } catch {
-            // Sender gateway unreachable — its waiter times out with guidance.
-          }
-        }
-
-        if (!envelopeId) {
-          continue
-        }
-
-        if (!target) {
-          await postReply({ error: `connection '${envelope?.target_connection}' is not connected to this Desktop right now` })
-          continue
-        }
-
-        // Needs-attention hook (#93091 item 3): a delivered background DM is
-        // this bot's "good turn"; a classified delivery failure badges it.
-        const attentionKey = `${target.id}::${String(envelope?.target_profile || '')}`
-
-        try {
-          const res = await host.requestProfile(target.route, 'bot_relay.deliver', {
-            profile: String(envelope?.target_profile || ''),
-            message: String(envelope?.message || '')
-          })
-          clearBotAttention(attentionKey)
-          await postReply({ reply: String(res?.reply || '') })
-        } catch (error) {
-          // #93091: bot_relay.deliver classifies the failed turn and ships the
-          // typed code in the JSON-RPC error's `data.reason`; forward it into
-          // the sender-side reply file so the waiter (and the sending agent)
-          // get the machine-readable cause, and prefer it for the badge —
-          // classified codes beat free-text re-parsing.
-          const reason = String(error?.data?.reason || '').trim()
-          noteBotAttention(attentionKey, reason || error?.message || error)
-          await postReply({
-            error: String(error?.message || error || 'delivery failed'),
-            ...(reason ? { reason } : {})
-          })
-        }
-      }
-    }
-  } finally {
-    relayDrainBusy = false
-
-    if (relayDrainRerun && !relayDisposed) {
-      // Envelopes signaled mid-drain: schedule one follow-up pass (debounced)
-      // instead of leaving them to the interval poll.
-      relayDrainRerun = false
-      scheduleRelayPushDrain()
-    }
-  }
-}
-
-/** Push-notified drain (#93091): collapse a burst of pending signals into
- *  one drain call ~RELAY_PUSH_DEBOUNCE_MS after the first signal. */
-function scheduleRelayPushDrain() {
-  if (relayDisposed || typeof setTimeout !== 'function') {
-    return
-  }
-
-  if (relayPushDebounceTimer !== null) {
-    return
-  }
-
-  relayPushDebounceTimer = setTimeout(() => {
-    relayPushDebounceTimer = null
-    void drainRelayOutboxes()
-  }, RELAY_PUSH_DEBOUNCE_MS)
-}
-
-function startBotRelay() {
-  relayDisposed = false
-
-  // Source-shape test harnesses evaluate plugin.js without DOM timers —
-  // the relay only runs where a real event loop exists.
-  if (typeof setInterval !== 'function' || typeof clearInterval !== 'function') {
-    return
-  }
-
-  if (relayRosterTimer === null) {
-    relayRosterTimer = setInterval(() => void syncRelayRosters(), RELAY_ROSTER_INTERVAL_MS)
-    void syncRelayRosters()
-  }
-
-  if (relayDrainTimer === null) {
-    relayDrainTimer = setInterval(() => void drainRelayOutboxes(), RELAY_DRAIN_INTERVAL_MS)
-  }
-
-  // Push path: the gateway change watcher broadcasts when an envelope hits
-  // the outbox; drain immediately (debounced) instead of waiting the poll
-  // out. Feature-detected — older shells have no host.onEvent — and the 4s
-  // poll above stays untouched as the backstop either way.
-  if (relayPushUnsub === null && typeof host.onEvent === 'function') {
-    relayPushUnsub = host.onEvent('bot_relay.outbox.pending', () => scheduleRelayPushDrain())
-  }
-}
-
-function stopBotRelay() {
-  relayDisposed = true
-  // A rerun remembered mid-drain must not leak into the next start —
-  // it would fire one stale drain after restart.
-  relayDrainRerun = false
-  // Unpin every relay-retained socket (#93594): with the relay stopped the
-  // pooled entries return to dispose-at-refcount-0 semantics.
-  releaseRelayRetention()
-
-  if (relayRosterTimer !== null) {
-    clearInterval(relayRosterTimer)
-    relayRosterTimer = null
-  }
-
-  if (relayDrainTimer !== null) {
-    clearInterval(relayDrainTimer)
-    relayDrainTimer = null
-  }
-
-  if (relayPushDebounceTimer !== null) {
-    clearTimeout(relayPushDebounceTimer)
-    relayPushDebounceTimer = null
-  }
-
-  if (relayPushUnsub !== null) {
-    try {
-      relayPushUnsub()
-    } catch {
-      // Disposer from an older shell shape — never break teardown.
-    }
-    relayPushUnsub = null
-  }
-}
-
-/** Per-bot appearance + display meta, persisted via ctx.storage:
- *  { [botName]: { shape, color, title } } */
-const $botMeta = atom({})
-
-function commitBotMetaV2(storage, snapshot) {
-  const commit = botMetaV2Commit.then(async () => {
-    if (typeof storage?.remove !== 'function' || typeof storage?.set !== 'function') {
-      throw new Error('bot metadata v2 storage is unavailable')
-    }
-
-    const [previousSnapshot, previousMarker] = typeof storage.get === 'function'
-      ? await Promise.all([
-          storage.get(BOT_META_V2_KEY),
-          storage.get(BOT_META_MIGRATION_KEY)
-        ])
-      : [null, null]
-    const hasCommittedPrevious = previousMarker === true &&
-      previousSnapshot &&
-      typeof previousSnapshot === 'object' &&
-      !Array.isArray(previousSnapshot)
-
-    try {
-      await storage.remove(BOT_META_MIGRATION_KEY)
-      await storage.set(BOT_META_V2_KEY, snapshot)
-      await storage.set(BOT_META_MIGRATION_KEY, true)
-    } catch (error) {
-      if (hasCommittedPrevious) {
-        try {
-          await storage.set(BOT_META_V2_KEY, previousSnapshot)
-          await storage.set(BOT_META_MIGRATION_KEY, true)
-        } catch {
-          await Promise.allSettled([
-            storage.remove(BOT_META_MIGRATION_KEY),
-            storage.remove(BOT_META_V2_KEY)
-          ])
-        }
-      } else {
-        await Promise.allSettled(
-          [BOT_META_MIGRATION_KEY, BOT_META_V2_KEY].map(key => storage.remove(key))
-        )
-      }
-      throw error
-    }
-  })
-
-  botMetaV2Commit = commit.catch(() => undefined)
-
-  return commit
-}
-
-function botOwner(owner) {
-  if (typeof owner === 'string') {
-    const name = owner.trim()
-    const route = migratedLocalRoutes.get(name)
-
-    return {
-      bot: route ? { name, sourceScoped: true, route } : { name },
-      name,
-      key: route ? botRouteKey(route) : name,
-      route: route || null
-    }
-  }
-
-  const name = String(owner?.name || '').trim()
-  const route = botConnectionRoute(owner)
-
-  return { bot: owner, name, key: route ? botRouteKey(route) : name, route }
-}
-
-/** Freshness fence for the server-meta overlay: a roster snapshot fetched
- * before the latest local/server metadata write must not overwrite it. */
-const botMetaWriteAt = new Map()
-
-function noteBotMetaWrite(key) {
-  botMetaWriteAt.set(key, Date.now())
-}
-
-async function saveBotMeta(owner, patch) {
-  const { bot, key, name, route } = botOwner(owner)
-  const prevMeta = $botMeta.get()[key] || {}
-  const next = { ...$botMeta.get(), [key]: { ...prevMeta, ...patch } }
-  noteBotMetaWrite(key)
-  $botMeta.set(next)
-
-  // Local plugin storage: instant, and the fallback for older gateways.
-  let localPersistence = Promise.resolve()
-  try {
-    const persisted = route || botMetaV2Active
-      ? commitBotMetaV2(pluginCtx?.storage, next)
-      : Promise.resolve(pluginCtx?.storage?.set?.(BOT_META_V1_KEY, next))
-    localPersistence = persisted.catch(() => undefined)
-  } catch {
-    /* storage unavailable — look persists for this window only */
-  }
-
-  // Server-side (source of truth when supported): profile.yaml ui_meta,
-  // namespaced under this plugin's id — every client machine sees the same
-  // roster. Return the outcome so user-initiated saves can distinguish a
-  // cross-machine save from a local-only fallback instead of reporting a
-  // false success. Data-URL fields are stripped from ui_meta (64KB cap,
-  // rides every profiles.list); the avatar IMAGE goes to the profile asset
-  // store instead (profiles.set_asset), which is server-side and uncapped by
-  // the list call — so pfps follow the profile across machines too.
-  let serverRequest = null
-  try {
-    const { image, pet, ...rest } = next[key] || {}
-    const request = route ? requestForBot(bot, 'profiles.configure', { name, ui_meta: { 'hermes-bots': rest } }) :
-      host.request('profiles.configure', { name, ui_meta: { 'hermes-bots': rest } })
-    serverRequest = Promise.resolve(request)
-  } catch {
-    /* older/unavailable gateway — the local fallback remains saved */
-  }
-
-  // Avatar image → profile asset store (feature-detected; local storage
-  // remains the fallback rendering source on older gateways) — but only when
-  // the image actually CHANGED. Every Edit Profile save sends the image key
-  // (changed or not); a no-op `clear` from one machine can race another
-  // machine's just-pushed avatar and wipe it server-side, and a no-op
-  // `data` push re-uploads the full data URL for nothing.
-  if ('image' in patch && patch.image !== (prevMeta.image ?? null)) {
-    try {
-      const req = patch.image
-        ? (route
-            ? requestForBot(bot, 'profiles.set_asset', { name, asset: 'avatar', data: patch.image })
-            : host.request('profiles.set_asset', { name, asset: 'avatar', data: patch.image }))
-        : (route
-            ? requestForBot(bot, 'profiles.set_asset', { name, asset: 'avatar', clear: true })
-            : host.request('profiles.set_asset', { name, asset: 'avatar', clear: true }))
-      req.catch(() => undefined)
-    } catch {
-      /* older gateway */
-    }
-  }
-
-  // Three-way outcome so callers can tell a REAL remote failure from the
-  // documented legacy fallback ("older gateways reject the param shape;
-  // that's fine, local wins"):
-  //   'persisted'   — gateway confirmed applied.ui_meta === true
-  //   'unsupported' — older gateway: request rejected, or response carries
-  //                   no `applied` contract at all. Silent local fallback;
-  //                   an error toast here would fire on EVERY save forever.
-  //   'failed'      — gateway speaks the contract and explicitly reported
-  //                   the ui_meta write did NOT apply.
-  let serverOutcome = 'unsupported'
-  if (serverRequest) {
-    try {
-      const result = await serverRequest
-      if (result?.applied?.ui_meta === true) {
-        serverOutcome = 'persisted'
-      } else if (result && typeof result === 'object' && result.applied && typeof result.applied === 'object') {
-        serverOutcome = 'failed'
-      }
-    } catch {
-      /* older/unavailable gateway — the local fallback remains saved */
-    }
-    // Re-stamp now that the server write settled: a roster snapshot fetched
-    // while profiles.configure was still in flight predates the new ui_meta
-    // just as surely as one fetched before the local write.
-    noteBotMetaWrite(key)
-  }
-
-  await localPersistence
-
-  return { serverPersisted: serverOutcome === 'persisted', serverOutcome }
-}
-
-/** Migrate name-keyed appearance state only when the live registry proves
- * there is one local source. A v1 name cannot identify a machine in a
- * multi-source desktop, so the conservative result there is to retain v1 as
- * rollback data and leave remote rows unpainted. */
-function hydrateBotMeta(snapshot, remap = null) {
-  const next = { ...snapshot }
-
-  for (const [key, meta] of Object.entries($botMeta.get())) {
-    const target = remap?.get(key) || key
-    next[target] = { ...(next[target] || {}), ...meta }
-  }
-
-  $botMeta.set(next)
-
-  return next
-}
-
-async function migrateBotMeta(storage = pluginCtx?.storage) {
-  let v1 = null
-  let v2 = null
-  let v2Committed = false
-
-  try {
-    ;[v1, v2, v2Committed] = await Promise.all([
-      storage?.get?.(BOT_META_V1_KEY),
-      storage?.get?.(BOT_META_V2_KEY),
-      storage?.get?.(BOT_META_MIGRATION_KEY)
-    ])
-  } catch {
-    return false
-  }
-
-  if (v2Committed === true && v2 && typeof v2 === 'object' && !Array.isArray(v2)) {
-    hydrateBotMeta(v2)
-    botMetaV2Active = true
-
-    return true
-  }
-
-  if (!v1 || typeof v1 !== 'object' || Array.isArray(v1) || typeof host.agents !== 'function') {
-    if (v1 && typeof v1 === 'object' && !Array.isArray(v1)) {
-      hydrateBotMeta(v1)
-    }
-
-    return false
-  }
-
-  let union
-  let routes
-
-  try {
-    union = await host.agents()
-    routes = typeof host.profileRoutes === 'function' ? await host.profileRoutes() : []
-  } catch {
-    hydrateBotMeta(v1)
-
-    return false
-  }
-
-  const sources = Array.isArray(union?.sources) ? union.sources : []
-  const localAgents = (union?.agents || []).filter(agent => agent?.connectionKind === 'local')
-  const soleLocal = sources.length === 1
-    ? sources[0]?.kind === 'local'
-    : sources.length === 0 && localAgents.length > 0 && (union?.agents || []).every(agent => agent?.connectionKind === 'local')
-
-  if (!soleLocal) {
-    hydrateBotMeta(v1)
-
-    return false
-  }
-
-  const migrated = {}
-  const pendingLocalRoutes = new Map()
-
-  for (const [name, meta] of Object.entries(v1)) {
-    const route = (routes || []).find(candidate => candidate?.mode === 'local' && candidate?.profile === name) ||
-      (() => {
-        const agent = localAgents.find(candidate => candidate.profile === name)
-
-        return agent
-          ? {
-              connectionId: agent.connectionId,
-              mode: 'local',
-              profile: name,
-              targetProfile: agent.targetProfile || name
-            }
-          : null
-      })()
-
-    if (!route?.connectionId) {
-      // A missing route makes the topology proof unusable for this key. Keep
-      // the v1 record intact rather than guessing a local/remote projection.
-      hydrateBotMeta(v1)
-
-      return false
-    }
-
-    const captured = {
-      connectionId: route.connectionId,
-      mode: 'local',
-      profile: name,
-      targetProfile: route.targetProfile || name
-    }
-    migrated[botRouteKey(captured)] = meta
-    pendingLocalRoutes.set(name, captured)
-  }
-
-  const remap = new Map(
-    [...pendingLocalRoutes].map(([name, route]) => [name, botRouteKey(route)])
-  )
-  const hydrated = { ...migrated }
-
-  for (const [key, meta] of Object.entries($botMeta.get())) {
-    const target = remap.get(key) || key
-    hydrated[target] = { ...(hydrated[target] || {}), ...meta }
-  }
-
-  try {
-    await commitBotMetaV2(storage, hydrated)
-  } catch {
-    botMetaV2Active = false
-    hydrateBotMeta(v1)
-
-    return false
-  }
-
-  migratedLocalRoutes.clear()
-  for (const [name, route] of pendingLocalRoutes) {
-    migratedLocalRoutes.set(name, route)
-  }
-  hydrateBotMeta(hydrated)
-  botMetaV2Active = true
-
-  return true
-}
-
-// ── hidden bots (right-click → Hide Bot) ────────────────────────────────────
-// Hiding is a ROSTER-DISPLAY concern only: a hidden bot keeps working,
-// remains mentionable, keeps group membership, and any open chat stays open.
-
-/** Session-only view toggle: reveal hidden bots (dimmed) in the roster. */
-const $showHiddenBots = atom(false)
-
-function isBotHidden(bot, metaByName) {
-  return Boolean(botRosterMeta(bot, metaByName)?.hidden)
-}
-
-function isBotPinned(bot, metaByName) {
-  return Boolean(botRosterMeta(bot, metaByName)?.pinned)
-}
-
-/** Hiding the selected bot re-homes the selection to the next visible owner. */
-function fallbackSelectionAfterHide(name) {
-  if ($selectedBot.get() !== name) {
-    return
-  }
-
-  const meta = $botMeta.get()
-  const visible = $lastRoster
-    .get()
-    .filter(bot => botSelectionKey(bot) !== name && !botRosterMeta(bot, meta)?.hidden)
-
-  if (visible.length) {
-    $selectedBot.set(botSelectionKey(visible[0]))
-    return
-  }
-
-  const defaultBot = $lastRoster.get().find(bot => isDefaultBot(bot) && !botRosterMeta(bot, meta)?.hidden)
-  if (defaultBot && botSelectionKey(defaultBot) !== name) {
-    $selectedBot.set(botSelectionKey(defaultBot))
-  } else if (!$lastRoster.get().some(isDefaultBot)) {
-    // Legacy sole-local rosters can transiently omit the default row. Keep the
-    // historic fallback rather than leaving Routines attached to a hidden bot.
-    $selectedBot.set('default')
-  }
-}
-
-/** One-time reconciliation: Bot Mode sessions are always hidden, but rooms
- *  and Bot Chats created before this policy (or while the old pref was off)
- *  left visible rows behind. On every plugin load, sweep the session ids we
- *  own by id (each group room's member sessions) through the core
- *  session.set_hidden RPC, then run the TITLE-based ownership sweep for
- *  everything else — canonical Bot Chats are identified by name (the
- *  registry row titled "Bot Chat"), so the title sweep is what hides them;
- *  no stored-id pointer is consulted. Idempotent (the DB setter is a no-op
- *  on already-hidden rows) and feature-detected: older Desktop hosts defer
- *  reconciliation rather than activating an absent profile backend. */
-function startHideSweepScheduler(ctx) {
-  let timer = null
-  let inflight = null
-  let pending = false
-  let disposed = false
-
-  const run = () => {
-    timer = null
-    if (disposed) {
-      return
-    }
-    if (inflight) {
-      pending = true
-      return
-    }
-
-    inflight = Promise.resolve()
-      .then(() => hideOwnedBotSessions())
-      .catch(() => undefined)
-      .finally(() => {
-        inflight = null
-        if (pending && !disposed) {
-          pending = false
-          schedule()
-        }
-      })
-  }
-  const schedule = () => {
-    if (disposed) {
-      return
-    }
-
-    try {
-      if (timer !== null) {
-        clearTimeout(timer)
-      }
-      timer = setTimeout(run, 0)
-    } catch {
-      run()
-    }
-  }
-  const stopGatewayListener = host.state.gateway.listen(state => {
-    if (state === 'open') {
-      schedule()
-    }
-  })
-
-  const teardown = () => {
-    disposed = true
-    stopGatewayListener()
-    if (timer !== null) {
-      clearTimeout(timer)
-      timer = null
-    }
-  }
-  if (typeof ctx.onDispose === 'function') {
-    ctx.onDispose(teardown)
-  }
-  schedule()
-}
-
-function hideOwnedBotSessions() {
-  const roomEntries = Object.values($groupChats.get()).flatMap(room =>
-    Object.entries(room?.sessions || {})
-      .map(([key, id]) => {
-        if (!id || id === true) {
-          return null
-        }
-
-        const persisted = room?.sessionOwners?.[key]
-        const derived = (room?.members || []).find(member => groupMemberKey(member) === key)
-        // Bare keys are legacy local rooms. A source-qualified key without its
-        // immutable owner is unsafe: never let it fall through ambient routing.
-        const owner = persisted || derived || (!key.includes('::') ? { name: key } : null)
-
-        if (key.includes('::')) {
-          const route = owner?.route
-          const sourceMarked = owner?.sourceScoped || owner?.remoteSource
-          const routeKey = route?.connectionId && route?.profile
-            ? `${route.connectionId}::${route.profile}`
-            : ''
-
-          if (!sourceMarked || !route?.targetProfile || routeKey !== key) {
-            return null
-          }
-        }
-
-        return owner ? { owner, id, dedupe: `${key}\u0000${id}` } : null
-      })
-      .filter(Boolean)
-  )
-
-  // The same member session can appear in several rooms (and legacy rooms can
-  // share ids) — hide each (owner, id) pair exactly once.
-  const rooms = [...new Map(roomEntries.map(entry => [entry.dedupe, entry])).values()]
-
-  const known = Promise.all(
-    rooms.map(({ owner, id }) =>
-      hidePersistedBotSession(owner, id).catch(() => undefined)
-    )
-  )
-
-  return Promise.all([known, sweepBotProfileSessions().catch(() => undefined)])
-}
-
-/** Reconcile durable visibility through the source's primary REST backend.
- *  Never fall back to requestForBot: that compatibility path activates an
- *  absent profile backend, which is worse than deferring this best-effort sweep. */
-function hidePersistedBotSession(bot, sessionId, profileOverride = '') {
-  if (typeof host.setPersistedSessionHidden !== 'function') {
-    return Promise.resolve()
-  }
-
-  const route = botConnectionRoute(bot)
-  const fallback = String(bot?.name || '').trim() || 'default'
-  const profile = profileOverride || backendTargetProfile(route, fallback)
-
-  return Promise.resolve(host.setPersistedSessionHidden(route, { sessionId, profile, hidden: true }))
-}
-
-// Titles Bot Mode itself mints for its plumbing sessions. Bot-to-bot CLI
-// handoffs (`hermes -p <bot> chat --in ~ -c "Bot Chat" --create-if-missing`)
-// create sessions with EXACTLY these titles; the "Group: " prefix is the
-// member-session title ensureGroupChatSession has
-// used since group chats shipped. Exact/prefix matching is deliberate — a
-// user's real conversation inside a bot profile keeps whatever title the
-// user gave it and is never touched.
-const BOT_MODE_SWEEP_TITLES = new Set(['Bot Chat', 'Agent Inbox'])
-const BOT_MODE_SWEEP_MIN_AGE_SECONDS = 5 * 60
-
-function isBotModeSweepTitle(title) {
-  const t = String(title || '').trim()
-  return BOT_MODE_SWEEP_TITLES.has(t) || t.startsWith('Group: ')
-}
-
-function isBotModeSweepCandidate(row, nowSeconds = Date.now() / 1000) {
-  const startedAt = Number(row?.started_at)
-  return (
-    row &&
-    row.id &&
-    isBotModeSweepTitle(row.title) &&
-    Number.isFinite(startedAt) &&
-    startedAt > 0 &&
-    nowSeconds - startedAt >= BOT_MODE_SWEEP_MIN_AGE_SECONDS
-  )
-}
-
-/** Ownership-based sweep: the id-based sweep above only covers sessions the
- *  plugin recorded ($botMeta canonical chats, $groupChats member sids), but
- *  Bot Mode sessions are ALSO minted outside the plugin — bot-to-bot CLI
- *  handoffs ("Agent Inbox" / extra "Bot Chat" rows born visible in a bot's
- *  profile) — and those ids the plugin never learns. So: enumerate each
- *  roster bot's OWN profile sessions (only bot profiles — a non-bot profile
- *  is never listed, so its sessions are never touched) and hide any VISIBLE
- *  row whose title is Bot Mode plumbing and whose creation grace period has
- *  elapsed. The grace period protects a new desktop draft while its first-turn
- *  title is pending; after five minutes an unchanged plumbing title is treated
- *  as Bot Mode-owned. session.list supplies epoch seconds; missing, malformed,
- *  millisecond, or future timestamps fail closed and stay visible. session.list
- *  without include_hidden returns only visible rows, which keeps the sweep
- *  naturally idempotent.
- *  Reads and writes go through the owning source's primary REST backend, which
- *  opens persisted state directly and never starts an inactive profile backend.
- *  Feature-detected + fire-and-forget: older Desktop hosts defer the sweep. */
-async function sweepBotProfileSessions(nowSeconds = Date.now() / 1000) {
-  if (typeof host.listPersistedSessions !== 'function' || typeof host.setPersistedSessionHidden !== 'function') {
-    return
-  }
-
-  const cached = $lastRoster.get()
-  let roster = Array.isArray(cached) && cached.length ? cached : null
-
-  if (!roster) {
-    // Plugin load can run before the Bots pane hydrates $lastRoster — fall
-    // back to the active gateway's own profile list (local bots; remote
-    // sources get covered by the next sweep once the roster cache exists).
-    try {
-      const activeBot = { name: String(host.state.profile?.get?.() || 'default').trim() || 'default' }
-      const res = await requestForBot(activeBot, 'profiles.list', {})
-      roster = Array.isArray(res?.profiles) ? res.profiles : []
-    } catch {
-      return
-    }
-  }
-
-  await Promise.all(
-    roster.map(async bot => {
-      const name = String(bot?.name || '').trim()
-
-      if (!name) {
-        return
-      }
-
-      try {
-        const route = botConnectionRoute(bot)
-        const profile = backendTargetProfile(route, name)
-        const res = await host.listPersistedSessions(route, { profile, limit: PROFILE_SESSION_LIST_LIMIT })
-        const rows = Array.isArray(res?.sessions) ? res.sessions : []
-
-        await Promise.all(
-          rows
-            .filter(row => isBotModeSweepCandidate(row, nowSeconds))
-            .map(row =>
-              Promise.resolve(
-                hidePersistedBotSession(bot, row.id, profile)
-              ).catch(() => undefined)
-            )
-        )
-      } catch {
-        /* older gateway / unreachable source — leave this profile alone */
-      }
-    })
-  )
-}
-
-/** Fetch server-side avatars for roster rows flagged has_avatar when the
- *  local cache doesn't already have an image for them. Fire-and-forget. */
-const avatarFetchInflight = new Set()
-
-const avatarPushInflight = new Set()
-
-/** Backfill: local meta has art the server lacks -> profiles.set_asset.
- *  Server-side avatars power the inter-agent notice pfp (core #85855) and
- *  cross-machine roster art, so local-only images are a bug, not a state. */
-function pushLocalAvatars(roster) {
-  for (const bot of roster) {
-    const key = botMetaKey(bot)
-
-    if (bot.has_avatar || avatarPushInflight.has(key)) {
-      continue
-    }
-
-    const image = $botMeta.get()[key]?.image
-
-    if (image && typeof image === 'string' && image.startsWith('data:')) {
-      avatarPushInflight.add(key)
-      const request = bot.sourceScoped
-        ? requestForBot(bot, 'profiles.set_asset', { name: bot.name, asset: 'avatar', data: image })
-        : host.request('profiles.set_asset', { name: bot.name, asset: 'avatar', data: image })
-      Promise.resolve(request)
-        .then(() => queryClient.invalidateQueries({ queryKey: ['hermes-bots', 'roster'] }))
-        .catch(() => avatarPushInflight.delete(key))
-      continue
-    }
-
-    // Vector shape/color face: no image exists anywhere — rasterize the
-    // live SVG (tagged data-bot-face) to a PNG and push that, so the
-    // inter-agent notices (core #85855/#85888) can show the real pfp.
-    const svg = document.querySelector('svg[data-bot-face=' + JSON.stringify(bot.name) + ']')
-
-    if (!svg) {
-      continue
-    }
-
-    avatarPushInflight.add(key)
-    rasterizeSvgToPng(svg, 160)
-      .then(png =>
-        png
-          ? (bot.sourceScoped
-              ? requestForBot(bot, 'profiles.set_asset', { name: bot.name, asset: 'avatar', data: png })
-              : host.request('profiles.set_asset', { name: bot.name, asset: 'avatar', data: png }))
-              .then(() => queryClient.invalidateQueries({ queryKey: ['hermes-bots', 'roster'] }))
-          : Promise.reject(new Error('rasterize failed'))
-      )
-      .catch(() => avatarPushInflight.delete(key))
-  }
-}
-
-/** Serialize an inline SVG and draw it to a canvas -> PNG data URL. */
-function rasterizeSvgToPng(svgEl, size) {
-  return new Promise(resolve => {
-    try {
-      const clone = svgEl.cloneNode(true)
-      clone.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
-      clone.setAttribute('width', String(size))
-      clone.setAttribute('height', String(size))
-      const markup = new XMLSerializer().serializeToString(clone)
-      const url = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(markup)
-      const img = new Image()
-
-      img.onload = () => {
-        try {
-          const canvas = document.createElement('canvas')
-          canvas.width = size
-          canvas.height = size
-          canvas.getContext('2d').drawImage(img, 0, 0, size, size)
-          resolve(canvas.toDataURL('image/png'))
-        } catch {
-          resolve(null)
-        }
-      }
-      img.onerror = () => resolve(null)
-      img.src = url
-    } catch {
-      resolve(null)
-    }
-  })
-}
-
-/** The roster backfill draws the live SVG at 160x160. Pets are 96x104
- *  and uploads are 256. Use that to tell a still face-copy from a real picture. */
-function isBackfilledFacePng(dataUrl) {
-  if (!dataUrl || typeof dataUrl !== 'string' || !dataUrl.startsWith('data:image/png;base64,')) {
-    return false
-  }
-
-  try {
-    const bin = atob(dataUrl.slice('data:image/png;base64,'.length).slice(0, 48))
-    if (bin.length < 24) {
-      return false
-    }
-    const w = (bin.charCodeAt(16) << 24) | (bin.charCodeAt(17) << 16) | (bin.charCodeAt(18) << 8) | bin.charCodeAt(19)
-    const h = (bin.charCodeAt(20) << 24) | (bin.charCodeAt(21) << 16) | (bin.charCodeAt(22) << 8) | bin.charCodeAt(23)
-    return w === 160 && h === 160
-  } catch {
-    return false
-  }
-}
-
-function pullServerAvatars(roster) {
-  pushLocalAvatars(roster)
-
-  for (const bot of roster) {
-    const key = botMetaKey(bot)
-
-    if (!bot.has_avatar || avatarFetchInflight.has(key)) {
-      continue
-    }
-
-    if ($botMeta.get()[key]?.image) {
-      continue
-    }
-
-    avatarFetchInflight.add(key)
-    const assetRequest = bot.sourceScoped
-      ? requestForBot(bot, 'profiles.get_asset', { name: bot.name, asset: 'avatar' })
-      : host.request('profiles.get_asset', { name: bot.name, asset: 'avatar' })
-    Promise.resolve(assetRequest)
-      .then(res => {
-        if (res?.found && res.data) {
-          const current = $botMeta.get()
-          const mine = current[key] || {}
-          // A 160px raster of the vector face is only for inter-agent
-          // notices. Do not park it on the roster or the live face dies.
-          if (isBackfilledFacePng(res.data) && mine.imageKind !== 'photo' && !mine.pet) {
-            return
-          }
-          $botMeta.set({ ...current, [key]: { ...mine, image: res.data } })
-          persistBotMetaSnapshot($botMeta.get(), Boolean(bot.sourceScoped))
-        }
-      })
-      .catch(() => undefined)
-      .finally(() => avatarFetchInflight.delete(key))
-  }
-}
-
-/** Server ui_meta (per roster row) beats local storage for the compact
- *  fields it carries; local-only fields (avatar image data URL, extracted
- *  pet icon) are PRESERVED — the server copy never includes them, so a
- *  naive replace would wipe a just-saved image avatar on the next roster
- *  paint. When server bot metadata exists, an omitted chat is authoritative
- *  deletion; local still fills all gaps for older gateways with no metadata.
- *
- *  `fetchedAt` (the snapshot's issue time) fences the overlay: a bot whose
- *  local meta was written AFTER the snapshot was fetched is skipped — that
- *  snapshot's ui_meta predates the write, and spreading it back over local
- *  meta resurrects state the user just changed (a disbanded group's
- *  membership reappearing as an empty roster row, a rename reverting, an
- *  unpin undoing). The next roster fetch post-dates the write and overlays
- *  normally, so server truth still gets the last word. */
-function mergeServerMeta(roster, fetchedAt = 0) {
-  const local = $botMeta.get()
-  let changed = false
-  const next = { ...local }
-
-  for (const bot of roster) {
-    const server = bot.ui_meta?.['hermes-bots']
-    if (server && typeof server === 'object') {
-      const key = botMetaKey(bot)
-      if (fetchedAt && fetchedAt < (botMetaWriteAt.get(key) || 0)) {
-        continue
-      }
-      const mine = next[key] || {}
-      const merged = { ...mine, ...server }
-
-      // Local-only fields survive the server overlay.
-      if (mine.image) {
-        merged.image = mine.image
-      }
-
-      // Legacy canonical-chat pointers (meta.chat) are dead: identity is the
-      // profile's "Bot Chat" registry row, resolved by name. Drop the key on
-      // sight so old ui_meta can never look meaningful again.
-      delete merged.chat
-
-      // Canonical multi-group metadata is authoritative for the compatibility
-      // scalar too. A server-side `group: null` is represented by omission,
-      // so retaining the local scalar would resurrect a membership that another
-      // desktop just removed.
-      if (
-        Array.isArray(server.groups) &&
-        Object.prototype.hasOwnProperty.call(mine, 'group') &&
-        !Object.prototype.hasOwnProperty.call(server, 'group')
-      ) {
-        delete merged.group
-      }
-
-      if (JSON.stringify(next[key] || null) !== JSON.stringify(merged)) {
-        next[key] = merged
-        changed = true
-      }
-    }
-  }
-
-  if (changed) {
-    $botMeta.set(next)
-
-    // Persist server reconciliation so a relaunch cannot rehydrate stale
-    // local fields that the server intentionally removed.
-    try {
-      persistBotMetaSnapshot(next, roster.some(bot => bot.sourceScoped))
-    } catch {
-      /* storage unavailable — reconciliation lasts for this window only */
-    }
-  }
-}
-
-/** Clone a bot: profile (config/skills/SOUL/memory via clone_from) + look.
- *  Name is "<base>-2", "-3", … — first free slot against the live roster. */
-async function duplicateBot(bot, roster) {
-  await ensureBotMetadata(bot)
-  const base = bot.name
-  const ownerRoute = botConnectionRoute(bot)
-  const ownerKey = ownerRoute ? botRouteKey(ownerRoute) : null
-  let name = null
-  for (let n = 2; n < 100; n++) {
-    // Truncate the BASE, never the suffix — slicing the joined string chops
-    // the "-2" off a max-length name and the candidate collides with the
-    // base forever (#19).
-    const suffix = `-${n}`
-    const candidate = base.slice(0, 64 - suffix.length) + suffix
-    if (!roster.some(b => b.name === candidate && (!ownerKey || botMetaKey(b)?.startsWith(`${ownerRoute.connectionId}::`)))) {
-      name = candidate
-      break
-    }
-  }
-
-  if (!name) {
-    throw new Error('No free name for the duplicate.')
-  }
-
-  await requestForBot(bot, 'profiles.create', {
-    name,
-    clone_from: base,
-    description: bot.description || ''
-  })
-
-  // Same look: avatar shape/color/image and a "(copy)" title so the two
-  // are tellable apart in the roster until the user renames. Do not copy
-  // chat or created. Those belong to the original bot.
-  const meta = $botMeta.get()[botMetaKey(bot)]
-  if (meta) {
-    const { chat, created, ...look } = meta
-    await saveBotMeta({ ...bot, name, route: ownerRoute, sourceScoped: Boolean(ownerRoute) }, {
-      ...look,
-      title: meta.title ? `${meta.title} (copy)` : ''
-    })
-  }
-
-  return name
-}
-
-/** Permanently delete a bot's Hermes profile, then remove plugin-local state
- * that would otherwise leave stale appearance/unread data behind.
- *
- * Prefer the SDK's `host.deleteProfile` when this Desktop build ships it: it
- * routes through the Electron-intercepted REST delete, which tears down the
- * bot's pool backend FIRST and routes the next request away from it. The
- * older `cli.exec` path bypasses that interception, so a backend that the
- * roster's hover pre-warm just woke (right-click hovers the row!) holds the
- * profile dir open — the CLI's rmtree races the live backend and the
- * renderer's socket reconnect respawns it mid-delete, resurrecting the
- * directory (hermes-agent#52279). That is the "can't delete a bot" error. */
-async function deleteBot(bot) {
-  const route = botConnectionRoute(bot)
-
-  if (isDefaultBot(bot) || String(route?.targetProfile || '').toLowerCase() === 'default') {
-    throw new Error('The default profile cannot be deleted.')
-  }
-
-  if (typeof host.deleteProfile === 'function') {
-    if (route) {
-      await host.deleteProfile(route)
-    } else {
-      await host.deleteProfile(bot.name)
-    }
-  } else {
-    // Older desktop without the SDK verb — source-scoped rows fail closed.
-    if (route) {
-      throw new Error('Source-scoped profile deletion requires host.deleteProfile.')
-    }
-
-    const result = await host.request('cli.exec', {
-      argv: ['profile', 'delete', bot.name, '--yes']
-    })
-
-    if (result?.blocked || result?.code !== 0) {
-      throw new Error(result?.hint || result?.output || `Could not delete profile ${bot.name}.`)
-    }
-  }
-
-  const meta = { ...$botMeta.get() }
-  delete meta[botMetaKey(bot)]
-  $botMeta.set(meta)
-
-  try {
-    if (route) {
-      await commitBotMetaV2(pluginCtx?.storage, meta)
-    } else {
-      await Promise.resolve(pluginCtx?.storage?.set?.(BOT_META_V1_KEY, meta))
-    }
-  } catch {
-    /* profile is deleted; stale local appearance is harmless if storage fails */
-  }
-
-  const unread = { ...$botUnread.get() }
-  delete unread[botSelectionKey(bot)]
-  $botUnread.set(unread)
-  rosterWatermarks.delete(botSelectionKey(bot))
-  avatarFetchInflight.delete(botMetaKey(bot))
-  avatarPushInflight.delete(botMetaKey(bot))
-
-  if ($selectedBot.get() === botSelectionKey(bot)) {
-    $selectedBot.set('default')
-  }
-  clearSelectedRosterBot(bot)
-
-  if ($openBotChat.get()?.key === botRosterKey(bot)) {
-    $openBotChat.set(null)
-    syncBotsHomeWorkspace()
-  }
-
-  queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-
-  const activeOwner = focusedRosterOwner($focusedBotOwner.get?.())
-  const deletedOwnerIsActive = route
-    ? activeOwner?.connectionId === route.connectionId && activeOwner?.name === route.profile
-    : activeOwner?.name === bot.name
-
-  if (deletedOwnerIsActive && typeof host.newChat === 'function') {
-    host.newChat('default')
-  }
-}
-
-// ── avatars (shape + color + eyes) ──────────────────────────────────────────
-
-// The original flat shapes. Sigils ('sigil-N') and platonic
-// solids remain render-only so any bot that picked one during the experiments
-// keeps its look.
-// Radix ScrollArea's viewport wraps children in a display:table div that
-// sizes to content — unbounded width means `truncate` below it never fires
-// and previews run through the panel edge. Scope-limited corrective.
-//
-// A second Radix quirk bites in the dialogs: the viewport is height:100%,
-// which computes to auto when the root only has max-height (no definite
-// height anywhere up the chain) — the viewport grows to full content height,
-// the root's overflow:hidden clips it, and NOTHING scrolls (#88). Capping
-// the viewport itself (inheriting the root's max-height) makes it the real
-// scroll container; lists shorter than the cap still shrink to fit.
-if (typeof document !== 'undefined' && !document.getElementById('hermes-bots-roster-css')) {
-  const style = document.createElement('style')
-  style.id = 'hermes-bots-roster-css'
-  style.textContent =
-    '.hermes-bots-roster [data-radix-scroll-area-viewport] > div {' +
-    ' display: block !important; width: 100%; min-width: 0; }' +
-    '.hermes-scroll-cap > [data-radix-scroll-area-viewport] { max-height: inherit; }' +
-    '@keyframes hermes-bots-pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.35; } }' +
-    '.hermes-bots-pulse { animation: hermes-bots-pulse 1.2s ease-in-out infinite; }'
-  document.head.appendChild(style)
-}
-
-const AVATAR_SHAPES = ['circle', 'squircle', 'pill', 'triangle', 'hexagon', 'cloud', 'drop']
-const AVATAR_PICKER_SHAPES = ['circle', 'blob', 'squircle', 'pill', 'triangle', 'hexagon', 'cloud', 'drop']
-
-/** xorshift PRNG seeded from a string — stable across sessions/platforms. */
-function sigilRng(text) {
-  let h = 2166136261
-  for (const ch of text) {
-    h ^= ch.charCodeAt(0)
-    h = Math.imul(h, 16777619)
-  }
-  let state = h >>> 0 || 88675123
-  return () => {
-    state ^= state << 13
-    state ^= state >>> 17
-    state ^= state << 5
-    state >>>= 0
-    return state / 4294967296
-  }
-}
-
-/**
- * Angular hermetic sigil: strokes on the left half of a 5-column grid,
- * mirrored right, plus a chance of a diamond ring. Returns SVG path strings.
- */
-function sigilGeometry(name, seed) {
-  const rng = sigilRng(`${name}::${seed}`)
-  const gx = i => 6 + i * 7 // 5 cols: 6..34
-  const gy = j => 8 + j * 6 // 5 rows: 8..32
-  const strokes = []
-  const segments = 4 + Math.floor(rng() * 3)
-
-  for (let k = 0; k < segments; k++) {
-    const x1 = Math.floor(rng() * 3) // left half incl. center
-    const y1 = Math.floor(rng() * 5)
-    const x2 = Math.min(2, Math.max(0, x1 + (rng() > 0.5 ? 1 : -1)))
-    const y2 = Math.min(4, Math.max(0, y1 + Math.floor(rng() * 3) - 1))
-
-    strokes.push(`M${gx(x1)} ${gy(y1)} L${gx(x2)} ${gy(y2)}`)
-    // mirror (col i → col 4-i)
-    strokes.push(`M${gx(4 - x1)} ${gy(y1)} L${gx(4 - x2)} ${gy(y2)}`)
-
-    // occasional cross-tie through the axis for connectedness
-    if (rng() > 0.6) {
-      strokes.push(`M${gx(x2)} ${gy(y2)} L${gx(4 - x2)} ${gy(y2)}`)
-    }
-  }
-
-  // spine down the axis grounds every variant
-  strokes.push(`M20 ${gy(0)} L20 ${gy(4)}`)
-
-  const ring = rng() > 0.45 ? 'M20 4 L36 20 L20 36 L4 20 Z' : null
-  return { strokes: strokes.join(' '), ring }
-}
-
-const AVATAR_COLORS = [
-  '#f5f5f4', // white
-  '#8d6748', // brown
-  '#ef4444', // red
-  '#f97316', // orange
-  '#14b8a6', // teal
-  '#38bdf8', // cyan
-  '#3b40c8', // royal blue
-  '#8b5cf6', // violet
-  '#ec4899', // magenta
-  '#9ca3af' // silver
-]
-
-/** Perceptual luminance — eyes/pupils flip light on dark bodies (ink, oxblood). */
-function isDarkColor(hex) {
-  try {
-    const n = parseInt(hex.slice(1), 16)
-    const r = (n >> 16) & 255
-    const g = (n >> 8) & 255
-    const b = n & 255
-    return 0.2126 * r + 0.7152 * g + 0.0722 * b < 110
-  } catch {
-    return false
-  }
-}
-
-function defaultShapeFor(name) {
-  let hash = 0
-  for (const ch of name) {
-    hash = (hash * 31 + ch.charCodeAt(0)) >>> 0
-  }
-  return AVATAR_SHAPES[hash % AVATAR_SHAPES.length]
-}
-
-// ── blobatar shapes mode (default for new agents) ───────────────────────────
-// Deterministic soft-body faces drawn from a string. Shape strings:
-//   'blobatar'                — the face follows the bot's NAME (renaming the
-//                               bot re-rolls the face, live in the dialog)
-//   'blobatar:<seed>'         — seed locked (the 🔒 lock / 🎲 randomize picks)
-//   'blobatar:<seed>:<kind>'  — plus one of the ten silhouettes pinned
-//   'blobatar::<kind>'        — silhouette pinned, seed still follows the name
-// Bot names are slugs (NAME_RE) and generated seeds are base36, so ':' never
-// appears inside a segment. Colors come from the library's own name-derived
-// palette (contrast-guaranteed) — the classic color swatches don't apply.
-
-const BLOB_KINDS = ['round', 'organic', 'boxy', 'capsule', 'nub', 'cloud', 'droplet', 'hexagon', 'sun', 'triangle']
-
-// Trait positions at the center of each silhouette band. Band thresholds are
-// frozen per blobatar major (gen2: 0.22 / 0.48 / 0.60 / 0.70 / 0.79 / 0.86 /
-// 0.915 / 0.95 / 0.98).
-const BLOB_KIND_TRAIT = {
-  round: 0.11, organic: 0.35, boxy: 0.54, capsule: 0.65, nub: 0.745,
-  cloud: 0.825, droplet: 0.8875, hexagon: 0.9325, sun: 0.965, triangle: 0.99
-}
-
-function isBlobShape(shape) {
-  return shape === 'blobatar' || (typeof shape === 'string' && shape.startsWith('blobatar:'))
-}
-
-function parseBlobShape(shape, name) {
-  const parts = typeof shape === 'string' ? shape.split(':') : []
-  const seedPart = parts[1] || ''
-  const kind = BLOB_KINDS.includes(parts[2]) ? parts[2] : ''
-  return { seed: seedPart || name || 'agent', seedPart, kind }
-}
-
-function blobShapeString(seedPart, kind) {
-  if (kind) {
-    return `blobatar:${seedPart}:${kind}`
-  }
-  return seedPart ? `blobatar:${seedPart}` : 'blobatar'
-}
-
-/** Static SVG markup for a blob face, tagged data-bot-face so the roster's
- *  PNG backfill (pushLocalAvatars → rasterizeSvgToPng) still finds it. */
-function blobMarkup(shape, name, size) {
-  if (!blobatarSvg) {
-    return null
-  }
-
-  const { seed, kind } = parseBlobShape(shape, name)
-  const opts = { size }
-
-  if (kind) {
-    opts.traits = { shape: BLOB_KIND_TRAIT[kind] }
-  }
-
-  try {
-    return blobatarSvg(seed, opts).replace('<svg ', '<svg data-bot-face=' + JSON.stringify(name) + ' ')
-  } catch {
-    return null
-  }
-}
-
-/** The colored body of the avatar (no eyes). Platonic solids are a filled
- *  silhouette + translucent internal edge lines (the projected wireframe);
- *  legacy flat shapes keep their old geometry so stored picks still render. */
-function shapeNode(shape, color, botName = 'agent') {
-  if (shape.startsWith('sigil-')) {
-    const seed = Number(shape.slice(6)) || 0
-    const { strokes, ring } = sigilGeometry(botName, seed)
-    const sw = { fill: 'none', stroke: color, strokeWidth: 2.2, strokeLinecap: 'round', strokeLinejoin: 'round' }
-    return jsxs('g', {
-      children: [
-        ring ? jsx('path', { d: ring, fill: 'none', stroke: color, strokeWidth: 1.2, opacity: 0.5 }) : null,
-        jsx('path', { d: strokes, ...sw })
-      ]
-    })
-  }
-
-  const stroke = { fill: color, stroke: color, strokeWidth: 7, strokeLinejoin: 'round' }
-  const edge = { fill: 'none', stroke: 'rgba(0,0,0,0.4)', strokeWidth: 1.4, strokeLinejoin: 'round', strokeLinecap: 'round' }
-  const face = { fill: color, stroke: 'rgba(0,0,0,0.4)', strokeWidth: 1.4, strokeLinejoin: 'round' }
-
-  switch (shape) {
-    // ── platonic solids ──
-    case 'tetrahedron':
-      return jsxs('g', {
-        children: [
-          jsx('path', { d: 'M20 5 L36 33 L4 33 Z', ...face }),
-          jsx('path', { d: 'M20 5 L20 25 M4 33 L20 25 M36 33 L20 25', ...edge })
-        ]
-      })
-    case 'cube':
-      return jsxs('g', {
-        children: [
-          jsx('path', { d: 'M20 4 L33 11 L33 29 L20 36 L7 29 L7 11 Z', ...face }),
-          jsx('path', { d: 'M7 11 L20 18 L33 11 M20 18 L20 36', ...edge })
-        ]
-      })
-    case 'octahedron':
-      return jsxs('g', {
-        children: [
-          jsx('path', { d: 'M20 3 L36 20 L20 37 L4 20 Z', ...face }),
-          jsx('path', { d: 'M4 20 L36 20 M20 3 L20 37', ...edge })
-        ]
-      })
-    case 'dodecahedron':
-      return jsxs('g', {
-        children: [
-          jsx('path', {
-            d: 'M20 3 L30 6.2 L36.2 14.7 L36.2 25.3 L30 33.8 L20 37 L10 33.8 L3.8 25.3 L3.8 14.7 L10 6.2 Z',
-            ...face
-          }),
-          jsx('path', {
-            d:
-              'M20 12 L27.6 17.5 L24.7 26.5 L15.3 26.5 L12.4 17.5 Z ' +
-              'M20 12 L20 3 M27.6 17.5 L36.2 14.7 M24.7 26.5 L30 33.8 M15.3 26.5 L10 33.8 M12.4 17.5 L3.8 14.7',
-            ...edge
-          })
-        ]
-      })
-    case 'icosahedron':
-      return jsxs('g', {
-        children: [
-          jsx('path', { d: 'M20 3 L34.7 11.5 L34.7 28.5 L20 37 L5.3 28.5 L5.3 11.5 Z', ...face }),
-          jsx('path', {
-            d:
-              'M20 11 L27.8 24.5 L12.2 24.5 Z ' +
-              'M20 11 L20 3 M20 11 L34.7 11.5 M20 11 L5.3 11.5 ' +
-              'M27.8 24.5 L34.7 11.5 M27.8 24.5 L34.7 28.5 M27.8 24.5 L20 37 ' +
-              'M12.2 24.5 L5.3 11.5 M12.2 24.5 L5.3 28.5 M12.2 24.5 L20 37',
-            ...edge
-          })
-        ]
-      })
-
-    // ── legacy flat shapes (stored picks from earlier versions) ──
-    case 'squircle':
-      return jsx('rect', { x: 3, y: 3, width: 34, height: 34, rx: 11, fill: color })
-    case 'pill':
-      return jsx('rect', { x: 2, y: 7, width: 36, height: 26, rx: 13, fill: color })
-    case 'triangle':
-      return jsx('path', { d: 'M20 5.5 L36 33.5 L4 33.5 Z', ...stroke })
-    case 'hexagon':
-      return jsx('path', { d: 'M20 3.5 L34.5 11.75 L34.5 28.25 L20 36.5 L5.5 28.25 L5.5 11.75 Z', ...stroke })
-    case 'cloud':
-      return jsx('path', {
-        d: 'M11 32 a7.5 7.5 0 0 1 -1 -14.9 A9.5 9.5 0 0 1 29 12.5 A7 7 0 0 1 30 32 Z',
-        fill: color
-      })
-    case 'drop':
-      return jsx('path', { d: 'M20 3 C20 3 6 20 6 27 a14 13.5 0 0 0 28 0 C34 20 20 3 20 3 Z', fill: color })
-    default:
-      return jsx('circle', { cx: 20, cy: 20, r: 17.5, fill: color })
-  }
-}
-
-const EYE_Y = {
-  // solids: eyes sit on the upper face region, clear of the busiest edges
-  tetrahedron: 26,
-  cube: 22.5,
-  octahedron: 14.5,
-  dodecahedron: 20,
-  icosahedron: 17.5,
-  // legacy
-  circle: 17,
-  squircle: 17,
-  pill: 20,
-  triangle: 25,
-  hexagon: 17,
-  cloud: 22,
-  drop: 24
-}
-
-// Solids draw eyes slightly tighter so they read as ON a face.
-const EYE_X = {
-  tetrahedron: [16.5, 23.5],
-  cube: [15, 25],
-  octahedron: [16, 24],
-  dodecahedron: [16.5, 23.5],
-  icosahedron: [16.5, 23.5]
-}
-
-function cubicAt(p0, p1, p2, p3, t) {
-  const u = 1 - t
-  return [
-    u * u * u * p0[0] + 3 * u * u * t * p1[0] + 3 * u * t * t * p2[0] + t * t * t * p3[0],
-    u * u * u * p0[1] + 3 * u * u * t * p1[1] + 3 * u * t * t * p2[1] + t * t * t * p3[1]
-  ]
-}
-
-/** Same outline as the old GitHub drop path, so it stays a fat water drop. */
-function sampleDropRing(steps) {
-  const pts = []
-  const n = Math.max(8, Math.floor(steps / 3))
-
-  for (let i = 0; i < n; i++) {
-    pts.push(cubicAt([20, 3], [20, 3], [6, 20], [6, 27], i / n))
-  }
-
-  for (let i = 0; i <= n; i++) {
-    const t = (i / n) * Math.PI
-    pts.push([20 - 14 * Math.cos(t), 27 + 13.5 * Math.sin(t)])
-  }
-
-  for (let i = 1; i <= n; i++) {
-    pts.push(cubicAt([34, 27], [34, 20], [20, 3], [20, 3], i / n))
-  }
-
-  return pts
-}
-
-function svgArc(x1, y1, rx, ry, fa, fs, x2, y2) {
-  const dx = (x1 - x2) / 2
-  const dy = (y1 - y2) / 2
-  let rx2 = rx * rx
-  let ry2 = ry * ry
-  const lam = (dx * dx) / rx2 + (dy * dy) / ry2
-  if (lam > 1) {
-    const s = Math.sqrt(lam)
-    rx *= s
-    ry *= s
-    rx2 = rx * rx
-    ry2 = ry * ry
-  }
-  const num = rx2 * ry2 - rx2 * dy * dy - ry2 * dx * dx
-  const den = rx2 * dy * dy + ry2 * dx * dx
-  let sq = Math.sqrt(Math.max(0, num / den))
-  if (fa === fs) {
-    sq = -sq
-  }
-  const cx = sq * (rx * dy / ry) + (x1 + x2) / 2
-  const cy = sq * (-ry * dx / rx) + (y1 + y2) / 2
-  const ang = (ux, uy, vx, vy) => {
-    const n = Math.hypot(ux, uy) * Math.hypot(vx, vy) || 1
-    let a = Math.acos(Math.max(-1, Math.min(1, (ux * vx + uy * vy) / n)))
-    if (ux * vy - uy * vx < 0) {
-      a = -a
-    }
-    return a
-  }
-  const theta1 = ang(1, 0, (x1 - cx) / rx, (y1 - cy) / ry)
-  let dtheta = ang((x1 - cx) / rx, (y1 - cy) / ry, (x2 - cx) / rx, (y2 - cy) / ry)
-  if (!fs && dtheta > 0) {
-    dtheta -= Math.PI * 2
-  }
-  if (fs && dtheta < 0) {
-    dtheta += Math.PI * 2
-  }
-  return { cx, cy, rx, ry, theta1, dtheta }
-}
-
-function sampleArc(arc, n) {
-  const pts = []
-  for (let i = 0; i < n; i++) {
-    const th = arc.theta1 + arc.dtheta * (i / n)
-    pts.push([arc.cx + arc.rx * Math.cos(th), arc.cy + arc.ry * Math.sin(th)])
-  }
-  return pts
-}
-
-/** Same outline as the old GitHub cloud path: three puffs and a flat floor. */
-function sampleCloudRing(steps) {
-  const a1 = svgArc(11, 32, 7.5, 7.5, 0, 1, 10, 17.1)
-  const a2 = svgArc(10, 17.1, 9.5, 9.5, 0, 1, 29, 12.5)
-  const a3 = svgArc(29, 12.5, 7, 7, 0, 1, 30, 32)
-  const len1 = Math.abs(a1.dtheta) * a1.rx
-  const len2 = Math.abs(a2.dtheta) * a2.rx
-  const len3 = Math.abs(a3.dtheta) * a3.rx
-  const len4 = 19
-  const total = len1 + len2 + len3 + len4
-  const n = Math.max(64, steps)
-  const n1 = Math.max(8, Math.round(n * len1 / total))
-  const n2 = Math.max(10, Math.round(n * len2 / total))
-  const n3 = Math.max(10, Math.round(n * len3 / total))
-  const n4 = Math.max(4, n - n1 - n2 - n3)
-  const pts = []
-  pts.push(...sampleArc(a1, n1))
-  pts.push(...sampleArc(a2, n2))
-  pts.push(...sampleArc(a3, n3))
-  for (let i = 0; i < n4; i++) {
-    pts.push([30 + (11 - 30) * (i / n4), 32])
-  }
-  return pts
-}
-
-/** Outline of a face in a 40x40 box. Same family as Grok Bot
- *  (blob / squircle / pebble / \u2026) but sampled from formulas, not
- *  a dumped point cloud. */
-function sampleFaceRing(shape, steps = 52) {
-  const kind = (shape || '').startsWith('sigil-') ? 'circle' : shape
-
-  if (kind === 'drop' || kind === 'teardrop') {
-    return sampleDropRing(steps)
-  }
-  if (kind === 'cloud') {
-    return sampleCloudRing(steps)
-  }
-  const pts = []
-
-  for (let i = 0; i < steps; i++) {
-    const a = (i / steps) * Math.PI * 2 - Math.PI / 2
-    const c = Math.cos(a)
-    const s = Math.sin(a)
-    let rx = 16
-    let ry = 16
-    if (kind === 'circle') {
-      rx = ry = 16.2
-    } else if (kind === 'blob') {
-      rx = ry = 16 + 1.7 * Math.sin(3 * a) + 0.7 * Math.cos(5 * a)
-    } else if (kind === 'squircle') {
-      const p = 5
-      const d = Math.pow(Math.abs(c) ** p + Math.abs(s) ** p, 1 / p) || 1
-      rx = ry = 16.2 / d
-    } else if (kind === 'pill') {
-      const d = Math.pow(Math.abs(c) ** 8 + Math.abs(s / 0.72) ** 8, 1 / 8) || 1
-      rx = ry = 16 / d
-    } else if (kind === 'triangle' || kind === 'tetrahedron' || kind === 'wedge') {
-      const u = (a + Math.PI / 2 + Math.PI * 2) % (Math.PI * 2)
-      const sector = (u / (Math.PI * 2 / 3)) % 1
-      rx = ry = 13.5 / Math.max(0.42, Math.cos((sector - 0.5) * 1.9))
-    } else if (kind === 'hexagon' || kind === 'hex' || kind === 'icosahedron' || kind === 'dodecahedron') {
-      const seg = Math.PI / 3
-      const hex = Math.cos(seg / 2) / Math.cos(a - seg * Math.round(a / seg))
-      rx = ry = 16.2 * hex
-    } else if (kind === 'cube' || kind === 'octahedron') {
-      const p = 3.1
-      const d = Math.pow(Math.abs(c) ** p + Math.abs(s) ** p, 1 / p) || 1
-      rx = ry = 16 / d
-    } else if (kind === 'pebble') {
-      rx = 16.4 * (1.04 - 0.14 * Math.cos(2 * a))
-      ry = 15.2 * (1.06 + 0.08 * Math.sin(2 * a))
-    } else {
-      rx = ry = 16.2
-    }
-
-    pts.push([20 + rx * c, 20 + ry * s])
-  }
-
-  return pts
-}
-
-function projectFacePoint(x, y, turn, tilt, roll) {
-  const dx = x - 20
-  const dy = y - 20
-  const r = (roll * Math.PI) / 180
-  const xr = dx * Math.cos(r) - dy * Math.sin(r)
-  const yr = dx * Math.sin(r) + dy * Math.cos(r)
-  const sx = 0.74 + 0.26 * Math.abs(Math.cos((turn * Math.PI) / 180))
-  const sy = 0.8 + 0.2 * Math.abs(Math.cos((tilt * Math.PI) / 180))
-  return [20 + xr * sx, 20 + yr * sy]
-}
-
-function ringToPath(pts) {
-  if (!pts.length) {
-    return ''
-  }
-
-  let d = `M${pts[0][0].toFixed(2)} ${pts[0][1].toFixed(2)}`
-
-  for (let i = 1; i < pts.length; i++) {
-    d += `L${pts[i][0].toFixed(2)} ${pts[i][1].toFixed(2)}`
-  }
-
-  return d + 'Z'
-}
-
-/** Grok-style pose. thinking/working lean and sway. idle is a small sine. */
-function facePose(mood, t) {
-  if (mood === 'work') {
-    return {
-      turn: -11 + Math.sin(t * 0.48) * 8,
-      tilt: Math.sin(t * 0.42) * 8 + Math.sin(t * 1.1) * 1.6,
-      roll: Math.sin(t * 0.75) * 4.2,
-      gazeX: Math.sin(t * 0.55) * 3.6,
-      gazeY: -1.6 + Math.sin(t * 0.38) * 2,
-      blink: t % 1.45 > 1.26,
-      d0: 0.2 + 0.8 * Math.max(0, Math.sin(t * 2.6)),
-      d1: 0.2 + 0.8 * Math.max(0, Math.sin(t * 2.6 - 0.7)),
-      d2: 0.2 + 0.8 * Math.max(0, Math.sin(t * 2.6 - 1.4))
-    }
-  }
-
-  return {
-    turn: Math.sin(t * 0.5) * 1.5,
-    tilt: Math.sin(t * 0.27),
-    roll: Math.sin(t * 0.85) * 1.2,
-    gazeX: 0,
-    gazeY: 0,
-    blink: t % 3.2 > 3.02,
-    d0: 0,
-    d1: 0,
-    d2: 0
-  }
-}
-
-function paintMathFace(svg, t) {
-  const mood = svg.getAttribute('data-hb-mood') || 'idle'
-  const shape = svg.getAttribute('data-hb-shape') || 'circle'
-  const pose = facePose(mood, t)
-  const body = svg.querySelector('[data-hb-body]')
-  const open = svg.querySelector('[data-hb-open]')
-  const shut = svg.querySelector('[data-hb-shut]')
-  const el = svg.querySelector('[data-hb-el]')
-  const er = svg.querySelector('[data-hb-er]')
-  const dots = svg.querySelectorAll('[data-hb-dot]')
-
-  if (body) {
-    if (shape === 'cloud') {
-      body.setAttribute('d', 'M11 32 a7.5 7.5 0 0 1 -1 -14.9 A9.5 9.5 0 0 1 29 12.5 A7 7 0 0 1 30 32 Z')
-    } else {
-      const ring = sampleFaceRing(shape).map(([x, y]) => projectFacePoint(x, y, pose.turn, pose.tilt, pose.roll))
-      body.setAttribute('d', ringToPath(ring))
-    }
-  }
-
-  const eyeY = (shape === 'cloud' ? 22 : 17.2) + pose.gazeY
-  const eyeL = 15.4 + pose.gazeX
-  const eyeR = 24.6 + pose.gazeX
-
-  if (el) {
-    el.setAttribute('cx', eyeL)
-    el.setAttribute('cy', eyeY)
-  }
-
-  if (er) {
-    er.setAttribute('cx', eyeR)
-    er.setAttribute('cy', eyeY)
-  }
-
-  // Catchlights ride the pupils (upper-left offset) — without this they
-  // stay at the circle-face position and drift outside e.g. the cloud's
-  // lower-set eyes.
-  const hl = svg.querySelector('[data-hb-hl-l]')
-  const hr = svg.querySelector('[data-hb-hl-r]')
-
-  if (hl) {
-    hl.setAttribute('cx', eyeL - 0.6)
-    hl.setAttribute('cy', eyeY - 0.7)
-  }
-
-  if (hr) {
-    hr.setAttribute('cx', eyeR - 0.6)
-    hr.setAttribute('cy', eyeY - 0.7)
-  }
-
-  if (open) {
-    open.setAttribute('opacity', pose.blink ? '0' : '1')
-  }
-
-  if (shut) {
-    shut.setAttribute('d', `M${eyeL - 2.6} ${eyeY} L${eyeL + 2.6} ${eyeY} M${eyeR - 2.6} ${eyeY} L${eyeR + 2.6} ${eyeY}`)
-    shut.setAttribute('opacity', pose.blink ? '1' : '0')
-  }
-
-  dots.forEach((dot, i) => {
-    const o = i === 0 ? pose.d0 : i === 1 ? pose.d1 : pose.d2
-    dot.setAttribute('opacity', String(o))
-  })
-
-  svg.style.transform = `rotate(${pose.tilt}deg)`
-  svg.style.transformOrigin = '50% 70%'
-}
-
-function walkMathFaces(root, acc) {
-  if (!root || !root.querySelectorAll) {
-    return acc
-  }
-
-  root.querySelectorAll('svg[data-hb-math]').forEach(node => acc.push(node))
-  root.querySelectorAll('*').forEach(el => {
-    if (el.shadowRoot) {
-      walkMathFaces(el.shadowRoot, acc)
-    }
-  })
-  return acc
-}
-
-function startFaceClock() {
-  if (typeof window === 'undefined') {
-    return
-  }
-
-  if (window.__hbFaceClock) {
-    // Already initialized (possibly parked) — make sure it's awake. BotFace
-    // renders route here, so a face mounting is what wakes a dormant clock.
-    window.__hbFaceClock.wake()
-
-    return
-  }
-
-  const t0 = performance.now()
-  // A large roster can mount hundreds of faces. Observe the cached nodes so
-  // off-screen cards do not consume a full animation frame by themselves.
-  let faces = []
-  let lastScan = -Infinity
-  const visibleFaces = new Set()
-  const observedFaces = new Set()
-  const observer =
-    typeof IntersectionObserver === 'function'
-      ? new IntersectionObserver(entries => {
-          let becameVisible = false
-
-          for (const entry of entries) {
-            if (entry.isIntersecting) {
-              visibleFaces.add(entry.target)
-              becameVisible = true
-            } else {
-              visibleFaces.delete(entry.target)
-            }
-          }
-
-          // A parked clock (no visible faces) resumes when one scrolls in.
-          if (becameVisible) {
-            window.__hbFaceClock?.wake()
-          }
-        })
-      : null
-
-  const scanFaces = () => {
-    faces = walkMathFaces(document, [])
-
-    if (!observer) {
-      return
-    }
-
-    const currentFaces = new Set(faces)
-
-    for (const svg of observedFaces) {
-      if (!currentFaces.has(svg)) {
-        observer.unobserve(svg)
-        observedFaces.delete(svg)
-        visibleFaces.delete(svg)
-      }
-    }
-
-    for (const svg of faces) {
-      if (!observedFaces.has(svg)) {
-        observedFaces.add(svg)
-        observer.observe(svg)
-      }
-    }
-  }
-
-  // Shared painting body for both scheduling paths: 1Hz document rescans,
-  // paint only visible faces (all cached faces when IO is unavailable).
-  const paint = now => {
-    if (now - lastScan > 1000) {
-      scanFaces()
-      lastScan = now
-    }
-    const t = (now - t0) / 1000
-    const facesToPaint = observer ? visibleFaces : faces
-
-    for (const svg of facesToPaint) {
-      if (svg.isConnected) {
-        paintMathFace(svg, t)
-      }
-    }
-  }
-
-  // Nothing worth animating: no faces mounted (BotFace wakes us on the next
-  // mount) or none visible (the observer wakes us when one scrolls in).
-  const idle = () => faces.length === 0 || (observer && visibleFaces.size === 0)
-
-  const teardownCaches = () => {
-    if (observer) {
-      observer.disconnect()
-    }
-
-    visibleFaces.clear()
-    observedFaces.clear()
-    faces = []
-    delete window.__hbFaceClock
-  }
-
-  // Newer desktops: the SDK's budgeted loop owns scheduling (15fps budget,
-  // hidden/minimized/unfocused pause, dormancy, teardown). typeof-guarded so
-  // older shells and the vm test harness use the hand-rolled path below.
-  if (typeof createBudgetedLoop === 'function' && createBudgetedLoop) {
-    const loop = createBudgetedLoop(paint, { fps: 15, idleWhen: idle })
-
-    window.__hbFaceClock = {
-      stop: () => {
-        loop.dispose()
-        teardownCaches()
-      },
-      wake: () => {
-        // Faces may have mounted/unmounted while parked — rescan on wake.
-        lastScan = -Infinity
-        loop.wake()
-      }
-    }
-
-    return
-  }
-
-  // Fallback scheduling for desktops whose SDK predates createBudgetedLoop.
-  let lastPaint = -Infinity
-  let rafId = 0
-  let dormant = false
-  let stopped = false
-
-  const tick = now => {
-    if (stopped) {
-      return
-    }
-
-    rafId = 0
-    // 15fps is smooth at avatar scale and bounds SVG/DOM churn. The clock
-    // still uses rAF so Chromium can pause it when the window is occluded.
-    if (!document.hidden && now - lastPaint >= 1000 / 15) {
-      paint(now)
-      lastPaint = now
-    }
-
-    // Park instead of burning frames + 1Hz whole-document shadow walks.
-    if (idle()) {
-      dormant = true
-
-      return
-    }
-
-    rafId = window.requestAnimationFrame(tick)
-  }
-
-  const wake = () => {
-    if (stopped || !dormant) {
-      return
-    }
-
-    dormant = false
-    // Faces may have mounted/unmounted while parked — rescan on first tick.
-    lastScan = -Infinity
-    rafId = window.requestAnimationFrame(tick)
-  }
-
-  const stop = () => {
-    stopped = true
-
-    if (rafId) {
-      window.cancelAnimationFrame(rafId)
-      rafId = 0
-    }
-
-    teardownCaches()
-  }
-
-  window.__hbFaceClock = { stop, wake }
-  rafId = window.requestAnimationFrame(tick)
-}
-
-/** Tear the face clock down (plugin disable/reload) — cancels the animation
- *  frame, disconnects the visibility observer, and drops all cached nodes. */
-function stopFaceClock() {
-  if (typeof window !== 'undefined' && window.__hbFaceClock) {
-    window.__hbFaceClock.stop()
-  }
-}
-
-/**
- * Live math face. Photos still use <img>. Shape avatars stay SVG so
- * the clock can move them (a baked PNG cannot).
- */
-function BotFace({ shape, color, image, size = 36, name = 'agent', mood = 'idle' }) {
-  startFaceClock()
-
-  if (image) {
-    return jsx('img', {
-      src: image,
-      alt: '',
-      'aria-hidden': true,
-      style: { width: size, height: size, borderRadius: '22%', objectFit: 'cover', display: 'block' }
-    })
-  }
-
-  // Blobatar shapes: the library draws the whole face (body + eyes + its own
-  // name-derived palette). Inline SVG via innerHTML so the roster PNG
-  // backfill's `svg[data-bot-face=…]` query still finds it; the math clock
-  // ignores it (no data-hb-math). Falls back to the legacy math face when the
-  // SDK predates the export.
-  if (isBlobShape(shape)) {
-    const markup = blobMarkup(shape, name, size)
-
-    if (markup) {
-      return jsx('span', {
-        'aria-hidden': true,
-        style: { width: size, height: size, display: 'block', lineHeight: 0 },
-        dangerouslySetInnerHTML: { __html: markup }
-      })
-    }
-
-    // Older SDK without blobatar: legacy deterministic shape from the name.
-    shape = defaultShapeFor(name)
-  }
-
-  // Sigils are line art (no filled body) — the math clock rebuilds filled
-  // outlines, which would turn a stored sigil pick into a blank circle.
-  // Keep the legacy static render for them so old picks still draw.
-  if (shape.startsWith('sigil-')) {
-    const eyes = jsxs('g', {
-      children: [
-        jsx('circle', { cx: 16, cy: 14, r: 2.4, fill: color }),
-        jsx('circle', { cx: 24, cy: 14, r: 2.4, fill: color })
-      ]
-    })
-    return jsxs('svg', {
-      'data-bot-face': name,
-      viewBox: '0 0 40 40',
-      width: size,
-      height: size,
-      'aria-hidden': true,
-      children: [shapeNode(shape, color, name), eyes]
-    })
-  }
-
-  const working = mood === 'work'
-  const eyeFill = isDarkColor(color) ? 'rgba(232,220,195,0.95)' : 'rgba(0,0,0,0.85)'
-  // Catchlight contrast follows the pupil, not the body: dark pupils get the
-  // white sparkle, light (cream) pupils on dark bodies get a dark one — a
-  // white dot on a cream pupil is invisible, which read as "no eye dots" on
-  // maroon/ink/oxblood avatars.
-  const hlFill = isDarkColor(color) ? 'rgba(0,0,0,0.6)' : 'rgba(255,255,255,0.85)'
-  const ring = sampleFaceRing(shape)
-  const rest = facePose(working ? 'work' : 'idle', 0)
-  // Shape-aware initial eye line — the cloud body sits lower, so its eyes
-  // (and their catchlights) start at the cloud position instead of jumping
-  // there on the first clock paint.
-  const eyeY0 = shape === 'cloud' ? 22 : 17.2
-
-  return jsxs('svg', {
-    'data-bot-face': name,
-    'data-hb-math': '1',
-    'data-hb-mood': working ? 'work' : 'idle',
-    'data-hb-shape': shape || 'circle',
-    viewBox: '0 0 40 44',
-    width: size,
-    height: size,
-    'aria-hidden': true,
-    style: { overflow: 'visible', display: 'block' },
-    children: [
-      jsx('path', {
-        'data-hb-body': '1',
-        d: shape === 'cloud'
-          ? 'M11 32 a7.5 7.5 0 0 1 -1 -14.9 A9.5 9.5 0 0 1 29 12.5 A7 7 0 0 1 30 32 Z'
-          : ringToPath(ring),
-        fill: color
-      }),
-      jsxs('g', {
-        'data-hb-open': '1',
-        children: [
-          jsx('ellipse', { 'data-hb-el': '1', cx: 15.4, cy: eyeY0, rx: 2.2, ry: working ? 2.6 : 2.3, fill: eyeFill }),
-          jsx('ellipse', { 'data-hb-er': '1', cx: 24.6, cy: eyeY0, rx: 2.2, ry: working ? 2.6 : 2.3, fill: eyeFill }),
-          jsx('circle', { 'data-hb-hl-l': '1', cx: 14.8, cy: eyeY0 - 0.7, r: 0.65, fill: hlFill }),
-          jsx('circle', { 'data-hb-hl-r': '1', cx: 24, cy: eyeY0 - 0.7, r: 0.65, fill: hlFill })
-        ]
-      }),
-      jsx('path', {
-        'data-hb-shut': '1',
-        d: `M12.8 ${eyeY0} L18 ${eyeY0} M22 ${eyeY0} L27.2 ${eyeY0}`,
-        stroke: eyeFill,
-        strokeWidth: 2,
-        strokeLinecap: 'round',
-        fill: 'none',
-        opacity: 0
-      }),
-      working
-        ? jsxs('g', {
-            children: [
-              jsx('circle', { 'data-hb-dot': '1', cx: 16.4, cy: 41.2, r: 1.15, fill: color, opacity: rest.d0 }),
-              jsx('circle', { 'data-hb-dot': '1', cx: 20, cy: 41.2, r: 1.15, fill: color, opacity: rest.d1 }),
-              jsx('circle', { 'data-hb-dot': '1', cx: 23.6, cy: 41.2, r: 1.15, fill: color, opacity: rest.d2 })
-            ]
-          })
-        : null
-    ]
-  })
-}
-
-// -- inline MCP setup (per-profile), driven by the mcp.servers.* gateway RPCs --
-// Feature-detected: if the gateway predates those RPCs the setup button hides
-// and the row falls back to the "run hermes mcp / Settings" hint. profile is
-// the target bot's profile name (its config is what we write).
-
-async function mcpRpc(method, params) {
-  // Returns { ok, result } or { ok:false, unsupported:true } when the gateway
-  // doesn't know the method (older backend) vs a real error.
-  try {
-    const res = await host.request(method, params)
-    return { ok: true, result: res }
-  } catch (err) {
-    const msg = String((err && err.message) || err || '')
-    if (/unknown method/i.test(msg)) {
-      return { ok: false, unsupported: true }
-    }
-    return { ok: false, error: msg }
-  }
-}
-
-// Probe whether the new lifecycle RPCs exist on this gateway (cached per session).
-let _mcpRpcSupported = null
-async function mcpSetupSupported() {
-  if (_mcpRpcSupported !== null) {
-    return _mcpRpcSupported
-  }
-  const r = await mcpRpc('mcp.servers.list', {})
-  _mcpRpcSupported = !(r.ok === false && r.unsupported)
-  return _mcpRpcSupported
-}
-
-function McpSetupButton({ profile, entry, onDone, ensureProfile }) {
-  // entry: { name, requires:[env keys], auth?, fromCatalog, installed }
-  // profile may be null at first (New Bot: the profile isn't created yet).
-  // ensureProfile() lazily creates it on the first setup action and returns the
-  // slug, so OAuth / API-key setup works DURING creation, not only in Edit.
-  const [phase, setPhase] = useState('idle') // idle | keys | oauth | busy | done | error
-  const [supported, setSupported] = useState(null)
-  const [keyValues, setKeyValues] = useState({})
-  const [message, setMessage] = useState('')
-  const pollRef = useRef(null)
-  const profileRef = useRef(profile || null)
-
-  useEffect(() => {
-    if (profile) {
-      profileRef.current = profile
-    }
-  }, [profile])
-
-  // Resolve the target profile, creating it on demand for the New Bot flow.
-  const resolveProfile = async () => {
-    if (profileRef.current) {
-      return profileRef.current
-    }
-    if (ensureProfile) {
-      const created = await ensureProfile()
-      if (created) {
-        profileRef.current = created
-      }
-      return created
-    }
-    return null
-  }
-
-  useEffect(() => {
-    let alive = true
-    mcpSetupSupported().then(ok => {
-      if (alive) setSupported(ok)
-    })
-    return () => {
-      alive = false
-      if (pollRef.current) {
-        clearInterval(pollRef.current)
-        pollRef.current = null
-      }
-    }
-  }, [])
-
-  const isOAuth = (entry.auth || '').toLowerCase() === 'oauth'
-  const requires = entry.requires || []
-
-  const beginKeys = async () => {
-    // Ensure the server exists in the target profile first (add from catalog).
-    setPhase('busy')
-    setMessage('')
-    const profile = await resolveProfile()
-    if (!profile) {
-      setPhase('idle')
-      return
-    }
-    if (entry.fromCatalog && !entry.installed) {
-      const add = await mcpRpc('mcp.servers.add', { profile, name: entry.name, preset: entry.name })
-      if (!add.ok) {
-        setPhase('error')
-        setMessage(add.error || 'Could not add server')
-        return
-      }
-    }
-    setPhase(isOAuth ? 'oauth' : 'keys')
-  }
-
-  const submitKeys = async () => {
-    setPhase('busy')
-    const profile = profileRef.current
-    if (!profile) {
-      setPhase('error')
-      setMessage('No target profile')
-      return
-    }
-    for (const k of requires) {
-      const val = (keyValues[k] || '').trim()
-      if (!val) {
-        continue
-      }
-      const r = await mcpRpc('mcp.servers.set_api_key', { profile, name: entry.name, env_var: k, value: val })
-      if (!r.ok) {
-        setPhase('error')
-        setMessage(r.error || ('Failed to set ' + k))
-        return
-      }
-    }
-    // Verify via test.
-    const t = await mcpRpc('mcp.servers.test', { profile, name: entry.name })
-    if (t.ok && t.result && (t.result.ok || (t.result.result && t.result.result.ok))) {
-      setPhase('done')
-      host.notify({ kind: 'success', message: entry.name + ' configured' })
-      onDone && onDone()
-    } else {
-      setPhase('error')
-      setMessage((t.result && (t.result.error || (t.result.result && t.result.result.error))) || 'Server test failed after setup')
-    }
-  }
-
-  const beginOAuth = async () => {
-    // A second click (retry, impatient double-click) must not orphan the
-    // previous poll interval — an overwritten pollRef leaks a 2s poller that
-    // runs until unmount and can flip phase from a stale OAuth session.
-    if (pollRef.current) {
-      clearInterval(pollRef.current)
-      pollRef.current = null
-    }
-    setPhase('busy')
-    setMessage('')
-    const profile = await resolveProfile()
-    if (!profile) {
-      setPhase('idle')
-      return
-    }
-    if (entry.fromCatalog && !entry.installed) {
-      const add = await mcpRpc('mcp.servers.add', { profile, name: entry.name, preset: entry.name })
-      if (!add.ok) {
-        setPhase('error')
-        setMessage(add.error || 'Could not add server')
-        return
-      }
-    }
-    const start = await mcpRpc('mcp.servers.oauth.start', { profile, name: entry.name })
-    const payload = start.result && (start.result.result || start.result)
-    const authUrl = payload && (payload.auth_url || payload.verification_url)
-    const sessionId = payload && payload.session_id
-    if (!start.ok || !authUrl || !sessionId) {
-      setPhase('error')
-      setMessage((start.error) || 'Could not start OAuth')
-      return
-    }
-    // Open the auth URL in the native browser, same as provider OAuth.
-    try {
-      if (host.openExternal) {
-        host.openExternal(authUrl)
-      } else if (typeof window !== 'undefined' && window.hermesDesktop && window.hermesDesktop.openExternal) {
-        window.hermesDesktop.openExternal(authUrl)
-      } else {
-        window.open(authUrl, '_blank')
-      }
-    } catch {
-      /* fall through to poll; user can open the URL from the toast */
-    }
-    setPhase('oauth')
-    setMessage('Complete sign-in in your browser...')
-    pollRef.current = setInterval(async () => {
-      const poll = await mcpRpc('mcp.servers.oauth.poll', { profile, name: entry.name, session_id: sessionId })
-      const pd = poll.result && (poll.result.result || poll.result)
-      const status = pd && pd.status
-      if (status === 'approved') {
-        clearInterval(pollRef.current)
-        pollRef.current = null
-        setPhase('done')
-        host.notify({ kind: 'success', message: entry.name + ' authenticated' })
-        onDone && onDone()
-      } else if (status === 'error') {
-        clearInterval(pollRef.current)
-        pollRef.current = null
-        setPhase('error')
-        setMessage((pd && pd.error_message) || 'OAuth failed')
-      }
-    }, 2000)
-  }
-
-  if (supported === false) {
-    return jsx('span', {
-      className: 'ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)',
-      children: 'needs setup (' + requires.join(', ') + ') \u2014 restart the gateway to enable in-app setup'
-    })
-  }
-  if (phase === 'done') {
-    return jsx('span', { className: 'ml-1.5 text-[0.65rem] text-(--ui-success,#22c55e)', children: 'set up \u2713' })
-  }
-  if (phase === 'keys') {
-    return jsxs('div', {
-      className: 'mt-1 grid gap-1',
-      children: [
-        ...requires.map(k =>
-          jsx(Input, {
-            key: k,
-            type: 'password',
-            className: 'h-6 text-[0.7rem]',
-            placeholder: k,
-            value: keyValues[k] || '',
-            onChange: e => setKeyValues(prev => ({ ...prev, [k]: e.target.value }))
-          }, k)
-        ),
-        jsxs('div', {
-          className: 'flex gap-1',
-          children: [
-            jsx(Button, { size: 'xs', variant: 'secondary', onClick: () => void submitKeys(), children: 'Save & test' }),
-            jsx(Button, { size: 'xs', variant: 'ghost', onClick: () => setPhase('idle'), children: 'Cancel' })
-          ]
-        })
-      ]
-    })
-  }
-  if (phase === 'oauth') {
-    return jsx('span', { className: 'ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)', children: message || 'Authorizing\u2026' })
-  }
-  if (phase === 'busy') {
-    return jsx('span', { className: 'ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)', children: 'Working\u2026' })
-  }
-  if (phase === 'error') {
-    return jsxs('span', {
-      className: 'ml-1.5 text-[0.65rem] text-(--ui-danger,#ef4444)',
-      children: [(message || 'Setup failed') + ' ', jsx('button', { className: 'underline', onClick: () => setPhase('idle'), children: 'retry' })]
-    })
-  }
-  // idle
-  return jsx('button', {
-    className: 'ml-1.5 text-[0.65rem] text-(--ui-accent,#4f9cf9) underline',
-    onClick: () => void (isOAuth ? beginOAuth() : beginKeys()),
-    children: isOAuth ? 'Sign in\u2026' : 'Set up\u2026'
-  })
-}
-
-function botAppearance(name, meta) {
-  // The primary profile is literally named "default"; the SDK's profileColor
-  // can hand it a near-black that renders as an ugly black square, and any
-  // auto-seeded color in local bot-meta would otherwise stick. Give the
-  // primary a nice fixed generic look (a friendly violet squircle). A user's
-  // EXPLICIT customization still wins: an uploaded/generated/pet image, or a
-  // shape/color they set via the editor (tracked by meta.custom === true).
-  const isPrimary = (name || '').trim().toLowerCase() === 'default'
-  const userCustomized = Boolean(meta?.custom)
-  if (isPrimary && !userCustomized) {
-    return { shape: 'squircle', color: '#8b5cf6', image: meta?.image || null }
-  }
-  return {
-    shape: meta?.shape || defaultShapeFor(name),
-    color: meta?.color || profileColor(name),
-    image: meta?.image || null
-  }
-}
-
-// ── image avatars: upload from device + generate via image.generate ─────────
-
-/** Downscale to a small square so plugin storage stays light. */
-function normalizeAvatarImage(dataUrl, edge = 256) {
-  return new Promise(resolve => {
-    const img = new Image()
-    img.onload = () => {
-      try {
-        const canvas = document.createElement('canvas')
-        canvas.width = edge
-        canvas.height = edge
-        const ctx2d = canvas.getContext('2d')
-        const side = Math.min(img.width, img.height)
-        ctx2d.drawImage(img, (img.width - side) / 2, (img.height - side) / 2, side, side, 0, 0, edge, edge)
-        resolve(canvas.toDataURL('image/png'))
-      } catch {
-        resolve(dataUrl)
-      }
-    }
-    img.onerror = () => resolve(dataUrl)
-    img.src = dataUrl
-  })
-}
-
-function pickImageFromDevice() {
-  return new Promise(resolve => {
-    const input = document.createElement('input')
-    input.type = 'file'
-    input.accept = 'image/png,image/jpeg,image/webp,image/gif'
-    input.onchange = () => {
-      const file = input.files?.[0]
-
-      if (!file) {
-        return resolve(null)
-      }
-
-      if (file.size > 15_000_000) {
-        host.notify({ kind: 'error', message: 'Image too large (max 15MB).' })
-        return resolve(null)
-      }
-
-      const reader = new FileReader()
-      reader.onload = () => resolve(typeof reader.result === 'string' ? reader.result : null)
-      reader.onerror = () => resolve(null)
-      reader.readAsDataURL(file)
-    }
-    input.click()
-  })
-}
-
-// ── group-chat attachments: pick/paste/drop files the room's members see ────
-
-/** Classify a picked file for the group-attachment pipeline. */
-function groupAttachmentKind(file) {
-  if (/^image\//.test(file.type || '')) {
-    return 'image'
-  }
-
-  if (file.type === 'application/pdf' || /\.pdf$/i.test(file.name || '')) {
-    return 'pdf'
-  }
-
-  return 'file'
-}
-
-/** File objects → [{ name, data, kind }] (data URLs), oversized files skipped
- *  with a toast. Images are downscaled; PDFs and other files ride as raw data
- *  URLs for the gateway's pdf.attach / file.attach staging. Shared by the
- *  picker button, the composer paste handler, and room drag & drop. */
-async function filesToGroupAttachments(files) {
-  const picked = []
-
-  for (const file of [...(files || [])]) {
-    if (!file) {
-      continue
-    }
-
-    if (file.size > 15_000_000) {
-      host.notify({ kind: 'error', message: `${file.name || 'attachment'}: too large (max 15MB).` })
-      continue
-    }
-
-    const data = await new Promise(done => {
-      const reader = new FileReader()
-      reader.onload = () => done(typeof reader.result === 'string' ? reader.result : null)
-      reader.onerror = () => done(null)
-      reader.readAsDataURL(file)
-    })
-
-    if (!data) {
-      continue
-    }
-
-    const kind = groupAttachmentKind(file)
-    picked.push({
-      name: file.name || (kind === 'image' ? 'pasted image' : 'attachment'),
-      data: kind === 'image' ? await normalizeGroupAttachment(data) : data,
-      kind
-    })
-  }
-
-  return picked
-}
-
-/** Multi-file picker for the group composer — any file type; kind decides
- *  the staging RPC. Resolves to [{ name, data, kind }]. */
-function pickGroupAttachments() {
-  return new Promise(resolve => {
-    const input = document.createElement('input')
-    input.type = 'file'
-    input.multiple = true
-    input.onchange = () => resolve(filesToGroupAttachments(input.files))
-    input.click()
-  })
-}
-
-/** Bound a group attachment's long edge so room logs (persisted with the
- *  plugin's other durable state) stay light while screenshots keep enough
- *  resolution for vision models to read text. No-op for small images or
- *  anything the canvas can't decode. */
-function normalizeGroupAttachment(dataUrl, maxEdge = 1568) {
-  return new Promise(resolve => {
-    const img = new Image()
-    img.onload = () => {
-      try {
-        const long = Math.max(img.width, img.height)
-
-        if (!long || long <= maxEdge) {
-          return resolve(dataUrl)
-        }
-
-        const scale = maxEdge / long
-        const canvas = document.createElement('canvas')
-        canvas.width = Math.max(1, Math.round(img.width * scale))
-        canvas.height = Math.max(1, Math.round(img.height * scale))
-        canvas.getContext('2d').drawImage(img, 0, 0, canvas.width, canvas.height)
-        resolve(canvas.toDataURL('image/png'))
-      } catch {
-        resolve(dataUrl)
-      }
-    }
-    img.onerror = () => resolve(dataUrl)
-    img.src = dataUrl
-  })
-}
-
-/** Cached probe: does the gateway have an image backend? A `false` answer
- *  is re-checked on every dialog open — the gateway may have been restarted
- *  (picking up image.generate) or a backend enabled since the last probe.
- *  Only `true` is sticky. */
-const $imagenAvailable = atom(null)
-let imagenProbeInflight = null
-
-function probeImagen() {
-  if (imagenProbeInflight) {
-    return imagenProbeInflight
-  }
-
-  imagenProbeInflight = host
-    .request('image.generate', { probe: true })
-    .then(res => $imagenAvailable.set(Boolean(res?.available)))
-    .catch(() => $imagenAvailable.set(false))
-    .finally(() => {
-      imagenProbeInflight = null
-    })
-
-  return imagenProbeInflight
-}
-
-async function generateAvatarImage(bot, title, description) {
-  const who = [title || bot, description].filter(Boolean).join(' — ')
-  const res = await host.request('image.generate', {
-    prompt:
-      `Cute minimal robot avatar for an AI agent named "${who}". ` +
-      'Friendly simple mascot face, bold flat vector style, solid color background, centered, no text.',
-    aspect_ratio: 'square'
-  })
-
-  if (!res?.success) {
-    throw new Error(res?.error || 'generation failed')
-  }
-
-  // image_data (data URL) works over local AND remote gateways; the raw
-  // backend URL is the fallback when the gateway couldn't inline it.
-  return res.image_data || res.image
-}
-
-/** Shape grid + color swatches, shared by Edit Profile and New Bot.
- *  Layout uses inline grid styles — arbitrary Tailwind classes like
- *  `grid-cols-7` are NOT in the app's precompiled CSS, which collapsed
- *  this into a single vertical column. */
-function AvatarPicker({ shape, color, image, onShape, onColor, onImage, generateSeed }) {
-  const pickerName = generateSeed?.name || 'agent'
-  const imagen = useValue($imagenAvailable)
-  const [tab, setTab] = useState('bot')
-  const [describe, setDescribe] = useState('')
-  const [genBusy, setGenBusy] = useState(false)
-
-  if (imagen === null) {
-    void probeImagen()
-  }
-
-  // Re-check a stale "unavailable" whenever the user lands on the Generate
-  // tab — the gateway may have restarted with image.generate since.
-  const goTab = id => {
-    setTab(id)
-
-    if (id === 'generate' && $imagenAvailable.get() === false) {
-      $imagenAvailable.set(null)
-      void probeImagen()
-    }
-  }
-
-  const upload = async () => {
-    const raw = await pickImageFromDevice()
-
-    if (raw) {
-      onImage(await normalizeAvatarImage(raw))
-    }
-  }
-
-  const generate = async () => {
-    if (genBusy) {
-      return
-    }
-
-    setGenBusy(true)
-
-    try {
-      const custom = describe.trim()
-      const img = custom
-        ? await (async () => {
-            const res = await host.request('image.generate', {
-              prompt: `${custom}. Avatar for an AI agent: centered, bold flat vector style, solid color background, no text.`,
-              aspect_ratio: 'square'
-            })
-
-            if (!res?.success) {
-              throw new Error(res?.error || 'generation failed')
-            }
-
-            return res.image_data || res.image
-          })()
-        : await generateAvatarImage(generateSeed?.name || 'agent', generateSeed?.title, generateSeed?.description)
-
-      if (img) {
-        onImage(await normalizeAvatarImage(img))
-      }
-    } catch (err) {
-      host.notifyError(err, 'Avatar generation failed')
-    } finally {
-      setGenBusy(false)
-    }
-  }
-
-  const tabButton = (id, label) =>
-    jsx(
-      'button',
-      {
-        type: 'button',
-        className: cn(
-          'rounded-full px-3 py-1 text-xs font-medium transition-colors',
-          tab === id
-            ? 'bg-(--chrome-action-hover) text-foreground'
-            : 'text-(--ui-text-tertiary) hover:text-(--ui-text-secondary)'
-        ),
-        onClick: () => goTab(id),
-        children: label
-      },
-      id
-    )
-
-  return jsxs('div', {
-    className: 'grid justify-items-center gap-3',
-    children: [
-      // Tab pills: Bot | Generate | Upload | Pet
-      jsxs('div', {
-        className: 'flex items-center gap-1',
-        children: [tabButton('bot', 'Bot'), tabButton('generate', 'Generate'), tabButton('upload', 'Upload'), tabButton('pet', 'Pet')]
-      }),
-
-      image && tab !== 'generate'
-        ? jsx(Button, {
-            type: 'button',
-            variant: 'ghost',
-            size: 'sm',
-            onClick: () => onImage(null),
-            children: 'Remove image — use shape'
-          })
-        : null,
-
-      tab === 'bot'
-        ? isBlobShape(shape) && blobatarSvg
-          ? (() => {
-              const { seedPart, kind } = parseBlobShape(shape, pickerName)
-              const locked = Boolean(seedPart)
-              return jsxs('div', {
-                className: 'grid justify-items-center gap-3',
-                children: [
-                  // Silhouette pins: Auto (name decides) + the six blob kinds.
-                  jsx('div', {
-                    style: {
-                      display: 'grid',
-                      gridTemplateColumns: 'repeat(4, minmax(0, 1fr))',
-                      gap: '6px',
-                      justifyItems: 'center'
-                    },
-                    children: ['', ...BLOB_KINDS].map(k =>
-                      jsx(
-                        'button',
-                        {
-                          type: 'button',
-                          title: k || 'Auto — the name decides',
-                          className: cn(
-                            'flex items-center justify-center rounded-md transition-colors hover:bg-(--chrome-action-hover)',
-                            k === kind && !image && 'ring-1 ring-(--ui-accent)'
-                          ),
-                          style: { width: 44, height: 44 },
-                          onClick: () => {
-                            onImage(null)
-                            onShape(blobShapeString(seedPart, k))
-                          },
-                          children: k
-                            ? jsx(BotFace, { shape: blobShapeString(seedPart, k), color, size: 32, name: pickerName })
-                            : jsx('span', { className: 'text-[0.6rem] text-(--ui-text-tertiary)', children: 'Auto' })
-                        },
-                        k || 'auto'
-                      )
-                    )
-                  }),
-                  jsxs('div', {
-                    className: 'flex items-center gap-1',
-                    children: [
-                      jsxs(Button, {
-                        type: 'button',
-                        variant: 'ghost',
-                        size: 'sm',
-                        onClick: () => {
-                          onImage(null)
-                          onShape(blobShapeString(Math.random().toString(36).slice(2, 10), kind))
-                        },
-                        children: [jsx(Codicon, { name: 'refresh', className: 'mr-1 text-[0.8rem]' }), 'Randomize']
-                      }),
-                      jsxs(Button, {
-                        type: 'button',
-                        variant: 'ghost',
-                        size: 'sm',
-                        title: locked
-                          ? 'Unlock — the face follows the agent\u2019s name again'
-                          : 'Keep this exact face even if the name changes',
-                        onClick: () => onShape(blobShapeString(locked ? '' : pickerName, kind)),
-                        children: [
-                          jsx(Codicon, { name: locked ? 'unlock' : 'lock', className: 'mr-1 text-[0.8rem]' }),
-                          locked ? 'Unlock' : 'Lock face'
-                        ]
-                      })
-                    ]
-                  }),
-                  jsx('div', {
-                    className: 'text-center text-[0.65rem] text-(--ui-text-quaternary)',
-                    children: locked ? 'Face locked — renaming won\u2019t change it.' : 'Face follows the name.'
-                  }),
-                  jsx(Button, {
-                    type: 'button',
-                    variant: 'ghost',
-                    size: 'sm',
-                    className: 'text-(--ui-text-tertiary)',
-                    onClick: () => onShape(defaultShapeFor(pickerName)),
-                    children: 'Classic shapes'
-                  })
-                ]
-              })
-            })()
-          : jsxs('div', {
-            className: 'grid justify-items-center gap-3',
-            children: [
-              jsx('div', {
-                style: {
-                  display: 'grid',
-                  gridTemplateColumns: 'repeat(4, minmax(0, 1fr))',
-                  gap: '6px',
-                  justifyItems: 'center'
-                },
-                children: (blobatarSvg ? ['blobatar', ...AVATAR_PICKER_SHAPES] : AVATAR_PICKER_SHAPES).map(s =>
-                  jsx(
-                    'button',
-                    {
-                      type: 'button',
-                      title: s === 'blobatar' ? 'Blob face — drawn from the agent\u2019s name' : undefined,
-                      className: cn(
-                        'flex items-center justify-center rounded-md transition-colors hover:bg-(--chrome-action-hover)',
-                        s === shape && !image && 'ring-1 ring-(--ui-accent)'
-                      ),
-                      style: { width: 44, height: 44 },
-                      onClick: () => {
-                        onImage(null)
-                        onShape(s)
-                      },
-                      children: jsx(BotFace, { shape: s, color, size: 32, name: pickerName })
-                    },
-                    s
-                  )
-                )
-              }),
-              jsx('div', {
-                style: {
-                  display: 'grid',
-                  gridTemplateColumns: 'repeat(5, minmax(0, 1fr))',
-                  gap: '8px',
-                  justifyItems: 'center'
-                },
-                children: AVATAR_COLORS.map(c =>
-                  jsx(
-                    'button',
-                    {
-                      type: 'button',
-                      className: cn(
-                        'rounded-full transition-transform hover:scale-110',
-                        c === color && 'ring-2 ring-(--ui-accent) ring-offset-1 ring-offset-(--ui-bg, transparent)'
-                      ),
-                      style: { width: 22, height: 22, backgroundColor: c },
-                      onClick: () => onColor(c)
-                    },
-                    c
-                  )
-                )
-              })
-            ]
-          })
-        : null,
-
-      tab === 'generate'
-        ? imagen
-          ? jsxs('div', {
-              className: 'grid w-full gap-2',
-              children: [
-                jsx(Textarea, {
-                  className: 'min-h-16 text-xs',
-                  placeholder: 'Describe your avatar…',
-                  value: describe,
-                  onChange: event => setDescribe(event.target.value)
-                }),
-                jsxs(Button, {
-                  type: 'button',
-                  variant: 'secondary',
-                  className: 'w-full justify-center',
-                  disabled: genBusy,
-                  onClick: generate,
-                  children: [
-                    genBusy
-                      ? jsx(GlyphSpinner, { spinner: 'breathe', className: 'mr-1 text-[0.8rem]' })
-                      : jsx(Codicon, { name: 'sparkle', className: 'mr-1 text-[0.8rem]' }),
-                    genBusy ? 'Generating…' : 'Generate'
-                  ]
-                }),
-                describe.trim()
-                  ? null
-                  : jsx('div', {
-                      className: 'text-center text-[0.65rem] text-(--ui-text-quaternary)',
-                      children: 'Leave blank to generate from the agent\u2019s name and description.'
-                    })
-              ]
-            })
-          : jsx('div', {
-              className: 'px-2 py-3 text-center text-xs leading-5 text-(--ui-text-tertiary)',
-              children:
-                imagen === false
-                  ? 'No image model available. If you just enabled one (or updated Hermes), restart the gateway: Ctrl+K → "Restart gateway".'
-                  : 'Checking image backend…'
-            })
-        : null,
-
-      tab === 'upload'
-        ? jsxs(Button, {
-            type: 'button',
-            variant: 'secondary',
-            className: 'w-full justify-center',
-            onClick: upload,
-            children: [jsx(Codicon, { name: 'device-camera', className: 'mr-1 text-[0.8rem]' }), 'Choose an image…']
-          })
-        : null,
-
-      tab === 'pet' ? jsx(PetTab, { image, onImage }) : null
-    ]
-  })
-}
-
-// ── pet tab: attach a petdex companion that lives beside the avatar ─────────
-
-// A petdex "spritesheet" is the FULL animation sheet (1536×1872 webp, ~2MB;
-// 8×9 grid of 192×208 frames). Using it as an <img> both downloads megabytes
-// per tile and shows the whole sheet squashed. Extract frame 0 once per slug
-// via canvas, downscale to 96px, and cache the data URL. Concurrency-capped
-// so opening the tab doesn't fire dozens of 2MB fetches at once.
-const PET_FRAME_W = 192
-const PET_FRAME_H = 208
-const petFrameCache = new Map()
-let petFetchActive = 0
-const petFetchQueue = []
-
-function pumpPetQueue() {
-  while (petFetchActive < 4 && petFetchQueue.length) {
-    const job = petFetchQueue.shift()
-    petFetchActive++
-    job().finally(() => {
-      petFetchActive--
-      pumpPetQueue()
-    })
-  }
-}
-
-function petFrameIcon(spriteUrl) {
-  if (!spriteUrl) {
-    return Promise.resolve(null)
-  }
-
-  if (!petFrameCache.has(spriteUrl)) {
-    petFrameCache.set(
-      spriteUrl,
-      new Promise(resolve => {
-        petFetchQueue.push(async () => {
-          try {
-            const resp = await fetch(spriteUrl, { signal: AbortSignal.timeout(15000) })
-            const blob = await resp.blob()
-            // Crop frame 0 during decode — never materialize the full sheet.
-            const bitmap = await createImageBitmap(blob, 0, 0, PET_FRAME_W, PET_FRAME_H)
-            const canvas = document.createElement('canvas')
-            canvas.width = 96
-            canvas.height = 104
-            canvas.getContext('2d').drawImage(bitmap, 0, 0, 96, 104)
-            bitmap.close()
-            resolve(canvas.toDataURL('image/png'))
-          } catch {
-            petFrameCache.delete(spriteUrl)
-            resolve(null)
-          }
-        })
-        pumpPetQueue()
-      })
-    )
-  }
-
-  return petFrameCache.get(spriteUrl)
-}
-
-/** One pet tile image: frame 0 only, resolved lazily through the cache. */
-function PetThumb({ spriteUrl, size = 40 }) {
-  const [icon, setIcon] = useState(null)
-
-  useEffect(() => {
-    let alive = true
-    petFrameIcon(spriteUrl).then(url => {
-      if (alive) {
-        setIcon(url)
-      }
-    })
-    return () => {
-      alive = false
-    }
-  }, [spriteUrl])
-
-  if (!icon) {
-    return jsx('div', {
-      style: { width: size, height: size, borderRadius: 6, background: 'var(--chrome-action-hover, rgba(255,255,255,0.06))' }
-    })
-  }
-
-  return jsx('img', {
-    src: icon,
-    alt: '',
-    style: { width: size, height: size, objectFit: 'contain', imageRendering: 'pixelated', borderRadius: 6 }
-  })
-}
-
-function PetTab({ image, onImage }) {
-  // Selection is dialog-local: committed by the dialog's Save like any
-  // uploaded/generated image (a direct meta write here gets clobbered by
-  // Save's own image state).
-  const [selectedSlug, setSelectedSlug] = useState(null)
-  const { data, isLoading } = useQuery({
-    queryKey: [ID, 'pet-gallery'],
-    queryFn: () => host.request('pet.gallery', {}),
-    staleTime: 300000
-  })
-  const [query, setQuery] = useState('')
-  // Windowed rendering: the gallery is 4500+ pets — mounting an <img> per pet
-  // froze the dialog. Render `limit` at a time and grow on scroll-to-bottom.
-  const [limit, setLimit] = useState(24)
-  const pets = data?.pets ?? []
-
-  if (isLoading) {
-    return jsx('div', {
-      className: 'flex justify-center py-4',
-      children: jsx(GlyphSpinner, { spinner: 'breathe', className: 'text-(--ui-text-tertiary)' })
-    })
-  }
-
-  if (!pets.length) {
-    return jsx('div', {
-      className: 'px-2 py-3 text-center text-xs text-(--ui-text-tertiary)',
-      children: 'No pets in the petdex gallery. Run `hermes pets` to explore.'
-    })
-  }
-
-  const q = query.trim().toLowerCase()
-  const filtered = q
-    ? pets.filter(pet => (pet.displayName || '').toLowerCase().includes(q) || (pet.slug || '').includes(q))
-    : pets
-  // Installed and curated pets surface first — they're the likeliest picks.
-  const ranked = filtered.slice().sort((a, b) => {
-    const rank = pet => (pet.installed ? 0 : pet.curated ? 1 : 2)
-    return rank(a) - rank(b)
-  })
-  const visible = ranked.slice(0, limit)
-
-  const onScroll = event => {
-    const el = event.currentTarget
-
-    if (el.scrollTop + el.clientHeight >= el.scrollHeight - 120 && limit < ranked.length) {
-      setLimit(prev => Math.min(prev + 24, ranked.length))
-    }
-  }
-
-  return jsxs('div', {
-    className: 'grid w-full gap-2',
-    children: [
-      jsx('div', {
-        className: 'text-center text-[0.65rem] text-(--ui-text-quaternary)',
-        children: 'Pick a pet as this agent’s profile picture.'
-      }),
-      jsx(Input, {
-        className: 'h-7 text-xs',
-        placeholder: `Search ${pets.length} pets…`,
-        value: query,
-        onChange: event => {
-          setQuery(event.target.value)
-          setLimit(24)
-        }
-      }),
-      image && selectedSlug
-        ? jsx(Button, {
-            type: 'button',
-            variant: 'ghost',
-            size: 'sm',
-            className: 'justify-center',
-            onClick: () => {
-              setSelectedSlug(null)
-              onImage(null)
-            },
-            children: 'Remove — back to shape avatar'
-          })
-        : null,
-      filtered.length === 0
-        ? jsx('div', {
-            className: 'py-3 text-center text-xs text-(--ui-text-quaternary)',
-            children: 'No pets match.'
-          })
-        : jsxs('div', {
-            onScroll,
-            style: { maxHeight: 220, overflowY: 'auto' },
-            children: [
-              jsx('div', {
-                style: {
-                  display: 'grid',
-                  gridTemplateColumns: 'repeat(3, minmax(0, 1fr))',
-                  gap: '6px'
-                },
-                children: visible.map(pet =>
-                  jsxs(
-                    'button',
-                    {
-                      type: 'button',
-                      className: cn(
-                        'grid justify-items-center gap-1 rounded-md p-1.5 transition-colors hover:bg-(--chrome-action-hover)',
-                        selectedSlug === pet.slug && 'ring-1 ring-(--ui-accent)'
-                      ),
-                      onClick: () => {
-                        // The pet IS the profile picture: extract frame 0
-                        // and hand it to the dialog as the avatar image.
-                        // Persisted when the user hits Save.
-                        setSelectedSlug(pet.slug)
-                        void petFrameIcon(pet.spritesheetUrl).then(icon => {
-                          if (icon) {
-                            onImage(icon)
-                          } else {
-                            setSelectedSlug(null)
-                            host.notify({ kind: 'error', message: 'Could not load that pet — try another.' })
-                          }
-                        })
-                      },
-                      children: [
-                        jsx(PetThumb, { spriteUrl: pet.spritesheetUrl, size: 40 }),
-                        jsx('span', {
-                          className: 'w-full truncate text-center text-[0.6rem] text-(--ui-text-tertiary)',
-                          children: pet.displayName
-                        })
-                      ]
-                    },
-                    pet.slug
-                  )
-                )
-              }),
-              limit < ranked.length
-                ? jsx('div', {
-                    className: 'py-2 text-center text-[0.65rem] text-(--ui-text-quaternary)',
-                    children: `Scroll for more (${limit} of ${ranked.length})`
-                  })
-                : null
-            ]
-          })
-    ]
-  })
-}
-
-// ── data ─────────────────────────────────────────────────────────────────────
-
-/** True once profiles.list reports the backend injects the bot-to-bot
- *  protocol into the system prompt itself (hermes-agent bot_mode_probe).
- *  Gates every SOUL.md protocol append below. */
-let serverInjectsProtocol = false
-
-function useRoster() {
-  const activeConnectionId = useValue(host.state.connectionId)
-
-  return useQuery({
-    queryKey: [...ROSTER_KEY, activeConnectionId],
-    queryFn: async () => {
-      // Stamp the ISSUE time on the snapshot: mergeServerMeta compares it
-      // against each bot's last local meta write, and a fetch issued before
-      // a write can only carry pre-write ui_meta. (Issue time is the
-      // conservative bound — the server answered no earlier than this.)
-      const issuedAt = Date.now()
-      // Rich rows (last_session, canonical_session, ui_meta, has_avatar)
-      // come from the ACTIVE gateway's profiles.list — the canonical Bot
-      // Chat is resolved server-side by NAME (the "Bot Chat" registry row),
-      // so the roster never sends session pointers.
-      // Refresh the alias identity index alongside the roster: alias routes
-      // (Desktop profile → remote backend root) are what let a backend row
-      // keep its configured friendly identity after activation (#89131).
-      // Best-effort and feature-detected — a failed read keeps the last
-      // good index rather than dropping identities mid-session.
-      if (typeof host.profileRoutes === 'function') {
-        try {
-          indexAliasRoutes(await host.profileRoutes())
-        } catch {
-          /* keep the previous alias index */
-        }
-      }
-      // Owner routing is ambient in the SDK now (post-#92731): requestForBot
-      // resolves the active owner itself, no captured route needed here.
-      const activeBot = { name: String(host.state.profile?.get?.() || 'default').trim() || 'default' }
-      const local = await requestForBot(activeBot, 'profiles.list', {})
-      // Newer backends inject the teammate-messaging protocol into every
-      // session's system prompt (agent.bot_mode_protocol) — SOUL.md must not
-      // carry a second copy. Older gateways lack the flag: keep appending.
-      serverInjectsProtocol = Boolean(local?.bot_mode_protocol)
-
-      // Multi-source desktops (hermes-agent #86875) also expose the union
-      // agent roster across every registered connection. Merge agents from
-      // OTHER sources in as additional rows. Feature-detected + best-effort:
-      // an older Desktop build (no host.agents) or a roster hiccup leaves
-      // the local list exactly as it was.
-      if (typeof host.agents === 'function') {
-        try {
-          const union = await host.agents()
-          const previous = $lastRoster.get().filter(row => !row?.ghost)
-          const merged = mergeMultiSourceRoster(local, union, activeConnectionId, previous)
-          const sources = Array.isArray(union?.sources) ? union.sources : []
-
-          return {
-            ...merged,
-            profiles: (merged?.profiles || []).map(row => annotateBotSource(row, sources)),
-            sources,
-            fetchedAt: issuedAt
-          }
-        } catch {
-          /* older build or roster failure — single-source list stands */
-        }
-      }
-
-      return { ...(local && typeof local === 'object' ? local : {}), fetchedAt: issuedAt }
-    },
-    refetchInterval: 5000,
-    staleTime: 5000,
-    retry: ROSTER_QUERY_RETRY,
-    retryDelay: attempt => Math.min(15000, 1000 * 2 ** attempt)
-  })
-}
-
-/** Synchronous union-roster read for the composer surfaces (autocomplete
- *  provider + mention middleware). useRoster caches under
- *  [...ROSTER_KEY, activeConnectionId] — a 3-element key — so a bare
- *  getQueryData(ROSTER_KEY) exact-match lookup returns undefined forever
- *  (issue #89303: remote handles absent from @ autocomplete, mentions
- *  unrouted). Read the live connection's entry first, then fall back to a
- *  prefix scan keeping the freshest snapshot. Never throws: cold cache or
- *  legacy queryClient returns null and callers fall back to their own path. */
-function cachedUnionRoster() {
-  if (typeof queryClient === 'undefined' || !queryClient || typeof queryClient.getQueryData !== 'function') {
-    return null
-  }
-
-  try {
-    const connectionId = String(
-      host.state.connectionId?.get?.() || host.activeConnectionId?.() || 'local'
-    )
-    const exact = queryClient.getQueryData([...ROSTER_KEY, connectionId])
-
-    if (Array.isArray(exact?.profiles)) {
-      return exact
-    }
-
-    if (typeof queryClient.getQueriesData === 'function') {
-      let best = null
-
-      // v5 takes a filters object; a legacy v3 queryClient treats the same
-      // object as the key itself and simply matches nothing — harmless.
-      for (const [, data] of queryClient.getQueriesData({ queryKey: ROSTER_KEY })) {
-        if (
-          Array.isArray(data?.profiles) &&
-          (!best || Number(data.fetchedAt || 0) > Number(best.fetchedAt || 0))
-        ) {
-          best = data
-        }
-      }
-
-      return best
-    }
-  } catch {
-    /* cache hiccup — caller falls back (middleware refetches) */
-  }
-
-  return null
-}
-
-/** Merge the union agent roster (host.agents) over the active gateway's
- *  profiles.list. Active-source rows — matched by the LIVE connection id,
- *  falling back to the roster's primaryConnectionId, then the legacy
- *  kind==='local' rule on older desktops — are the agents profiles.list
- *  already returned: they only ANNOTATE the rich rows (handle, connection
- *  fields); rich fields stay authoritative and they are NOT duplicated.
- *  Rows from other sources become new roster entries tagged with their
- *  source label so BotRow can badge them, warm the captured agent, and route
- *  every open directly through that descriptor. Pure — exercised directly by
- *  the tests. */
-function mergeMultiSourceRoster(local, union, activeConnectionId, previous = []) {
-  const localProfiles = Array.isArray(local?.profiles) ? local.profiles : []
-  const agents = Array.isArray(union?.agents) ? union.agents : []
-  // A live id of null/'' means the window is on the unscoped local backend
-  // (legacy hosts reported null for mode:'local'; the SDK now reports
-  // 'local'). Do NOT fall back to registry primary when the third argument
-  // was passed — primary can still say "spark" after the user clicked a
-  // local bot, which skipped every Spark row as "active" and invented a
-  // This-device shadow of default.
-  const liveProvided = arguments.length >= 3
-  const liveId = String(activeConnectionId || '').trim()
-  let activeId = liveId || (liveProvided ? '' : String(union?.primaryConnectionId || '').trim())
-
-  // Migrated remote-primary windows can still expose a legacy remote
-  // descriptor without connectionId. That produces a null live id even
-  // though profiles.list is answering from the registry primary. Infer the
-  // primary only when its inventory matches the rich rows and the local
-  // inventory does not. A genuinely local window has a matching local row,
-  // so it keeps the null-is-local behavior used after clicking This device.
-  if (!activeId && liveProvided) {
-    const primaryId = String(union?.primaryConnectionId || '').trim()
-    const richNames = new Set(localProfiles.map(profile => String(profile?.name || '').trim()).filter(Boolean))
-    const localMatches = agents.some(
-      agent => agent?.connectionKind === 'local' && richNames.has(String(agent?.profile || '').trim())
-    )
-    const primaryMatches = agents.some(
-      agent => String(agent?.connectionId || '').trim() === primaryId && richNames.has(String(agent?.profile || '').trim())
-    )
-
-    if (!localMatches && primaryId && primaryMatches) {
-      activeId = primaryId
-    }
-  }
-  const activeByName = new Map()
-
-  // Treat the rich list as one row per active-source profile. Clone every
-  // row: some gateway clients reuse response objects, and annotating those in
-  // place made each five-second refresh feed the previous union back into the
-  // next merge, growing duplicate source rows indefinitely.
-  for (const profile of localProfiles) {
-    const name = String(profile?.name || '').trim()
-
-    if (!name || profile?.remoteSource) {
-      continue
-    }
-
-    if (profile?.sourceScoped && activeId && profile.connectionId !== activeId) {
-      continue
-    }
-
-    if (!activeByName.has(name)) {
-      activeByName.set(name, { ...profile, name })
-    }
-  }
-
-  const profiles = [...activeByName.values()]
-
-  // host.agents is an Electron/main-process capability. Defend the plugin
-  // boundary too: older shells or reconnect races can still hand us repeated
-  // identities even after the core roster deduplicates them.
-  const seenSources = new Set()
-
-  for (const agent of agents) {
-    const profile = String(agent?.profile || '').trim()
-    const connectionId = String(agent?.connectionId || '').trim()
-    const sourceKey = `${connectionId}::${profile || 'default'}`
-
-    if (!profile || seenSources.has(sourceKey)) {
-      continue
-    }
-
-    seenSources.add(sourceKey)
-
-    // The union enumerates EVERY registered connection, including the active
-    // gateway that already answered profiles.list. Without this the active
-    // gateway's own agents (connectionKind 'remote' on a remote-primary
-    // desktop) would be appended as phantom duplicates — every bot listed
-    // twice. Older Electron builds predate the connection ids; fall back to
-    // the legacy local-source rule so single-source behavior stays intact.
-    const isActiveSource = activeId ? connectionId === activeId : agent.connectionKind === 'local'
-    const row = isActiveSource ? activeByName.get(profile) : null
-
-    if (row) {
-      // Annotate in place: the @name-device handle only differs from the
-      // bare name when the profile exists on several sources.
-      row.handle = agent.handle
-      row.connectionId = agent.connectionId
-      row.connectionKind = agent.connectionKind
-      row.connectionLabel = agent.connectionLabel
-      row.targetProfile = agent.targetProfile || profile
-      row.route = {
-        connectionId,
-        mode: agent.connectionKind === 'local' ? 'local' : 'remote',
-        profile,
-        targetProfile: agent.targetProfile || profile
-      }
-      row.sourceScoped = true
-      continue
-    }
-
-    if (isActiveSource) {
-      // Union saw an active-source profile profiles.list didn't return (older
-      // backend mid-refresh) — skip rather than invent a thin row.
-      continue
-    }
-
-    profiles.push({
-      name: profile,
-      handle: agent.handle,
-      connectionId,
-      connectionKind: agent.connectionKind,
-      connectionLabel: agent.connectionLabel,
-      targetProfile: agent.targetProfile || profile,
-      route: {
-        connectionId,
-        mode: agent.connectionKind === 'local' ? 'local' : 'remote',
-        profile,
-        targetProfile: agent.targetProfile || profile
-      },
-      remoteSource: true,
-      sourceScoped: true
-    })
-  }
-
-  // SSH sources drop to connect-on-demand the moment their tunnel is not
-  // the live gateway. Keep previously painted remote rows so clicking the
-  // local agent does not empty Bot Mode.
-  if (Array.isArray(previous) && previous.length > 0) {
-    const present = new Set(profiles.map(row => `${row.connectionId || ''}::${row.name}`))
-    const unionSourceIds = new Set(agents.map(agent => String(agent?.connectionId || '').trim()).filter(Boolean))
-    const omitted = new Set(
-      (Array.isArray(union?.sources) ? union.sources : [])
-        .filter(source => source?.error === 'connect-on-demand' || source?.reachable === false)
-        .map(source => String(source.connectionId || '').trim())
-        .filter(Boolean)
-    )
-
-    const registered = new Set(
-      (Array.isArray(union?.sources) ? union.sources : [])
-        .map(source => String(source?.connectionId || '').trim())
-        .filter(Boolean)
-    )
-
-    for (const row of previous) {
-      const connectionId = String(row?.connectionId || '').trim()
-      const name = String(row?.name || '').trim()
-      const key = `${connectionId}::${name || 'default'}`
-
-      if (!row?.remoteSource || !connectionId || !name || present.has(key)) {
-        continue
-      }
-
-      if (registered.size > 0 && !registered.has(connectionId)) {
-        continue
-      }
-
-      if (omitted.has(connectionId) || !unionSourceIds.has(connectionId)) {
-        profiles.push({ ...row, remoteSource: true, sourceScoped: true })
-        present.add(key)
-      }
-    }
-  }
-
-  return { ...local, profiles }
-}
-
-/** The @handle users tag a bot with. Multi-source rosters precompute the
- *  handle (bare name, or name-device when the profile exists on several
- *  registered sources) — prefer it when present. The primary profile's
- *  callable alias is 'hermes' — the mention middleware resolves it back to
- *  'default' — so the word 'default' never surfaces in the UI. */
-function botHandle(name, bot) {
-  if (bot?.handle && bot.handle !== name) {
-    return bot.handle
-  }
-
-  return (name || '').trim().toLowerCase() === 'default' ? 'hermes' : name
-}
-
-/** Taggable @-forms derived from a bot's friendly names — the core profile
- *  display name (`hermes profile rename`) and the Bot Mode title. Free text
- *  reduces to the mention charset two ways: slugified ("Research Buddy" →
- *  research-buddy, the form autocomplete inserts) and collapsed
- *  (researchbuddy). Reserved tokens are dropped so a bot renamed "Hermes"
- *  can never hijack the primary profile's @hermes alias. */
-function mentionNameForms(value) {
-  const name = String(value || '').trim().toLowerCase()
-
-  if (!name) {
-    return []
-  }
-
-  const slug = name.replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '')
-  const collapsed = name.replace(/[^a-z0-9_-]+/g, '')
-
-  return [...new Set([slug, collapsed])].filter(
-    form => /^[a-z0-9][a-z0-9_-]*$/.test(form) && !['all', 'everyone', 'user', 'default', 'hermes'].includes(form)
-  )
-}
-
-/** Every friendly (renameable) name a roster row carries: the Bot Mode title
- *  (server-synced via ui_meta, locally stored, or persisted on a durable
- *  group descriptor) and the core profile display_name — in displayName's
- *  precedence order. Remote rows never borrow local meta (two `default`s
- *  must not share a title) — EXCEPT the connection-exact alias identity
- *  (#89131): a backend row claimed by a configured alias route carries the
- *  alias's friendly names, so @moxie keeps resolving after handoff. */
-function botFriendlyNames(bot) {
-  const metaByName = typeof $botMeta !== 'undefined' ? $botMeta.get() : null
-  const localTitle = !bot?.remoteSource ? metaByName?.[bot?.name]?.title : null
-  const alias = aliasIdentityFor(bot)
-  const aliasTitle = alias
-    ? alias.metaKeys.map(key => metaByName?.[key]?.title).find(title => typeof title === 'string' && title.trim()) ||
-      alias.name
-    : null
-
-  return [bot?.ui_meta?.['hermes-bots']?.title, localTitle, aliasTitle, bot?.title, bot?.display_name]
-}
-
-/** The tag autocomplete inserts for a bot: the renamed (friendly) slug when
- *  the user gave the bot a real name, otherwise the profile @handle. The
- *  resolvers accept both, so older muscle memory keeps working. */
-function botMentionTag(bot) {
-  for (const friendly of botFriendlyNames(bot)) {
-    const forms = mentionNameForms(friendly)
-
-    if (forms.length) {
-      return forms[0]
-    }
-  }
-
-  return botHandle(bot?.name, bot)
-}
-
-function isActiveRosterBot(bot, active) {
-  if (!active) {
-    return false
-  }
-
-  const activeName = String(active.name || 'default').trim() || 'default'
-  const activeId = String(active?.connectionId || '').trim()
-  const botId = String(bot?.connectionId || '').trim()
-  const botName = String(bot?.name || '').trim() || 'default'
-
-  if (bot?.remoteSource) {
-    return Boolean(activeId) && activeId === botId && botName === activeName
-  }
-
-  if (activeId && activeId !== 'local' && botId && activeId !== botId) {
-    return false
-  }
-
-  return botName === activeName
-}
-
-function botSelectionKey(bot) {
-  return bot?.sourceScoped || bot?.remoteSource ? botRosterKey(bot) : bot?.name
-}
-
-function isDefaultBot(bot) {
-  const route = botConnectionRoute(bot)
-
-  return String(route?.profile || bot?.name || '').trim().toLowerCase() === 'default'
-}
-
-function newBotChat(bot) {
-  if (typeof host.newChat !== 'function') {
-    host.notify?.({ kind: 'error', message: 'Update Hermes Desktop to open another Bot chat.' })
-
-    return
-  }
-
-  const route = botConnectionRoute(bot)
-
-  if (!route) {
-    host.notify?.({ kind: 'error', message: 'Update Hermes Desktop to open another Bot chat.' })
-
-    return
-  }
-
-  const ownerKey = botWorkspaceOwnerKey(bot)
-  setBotsWorkspaceOwner(ownerKey, bot)
-  host.newChat(route, { workspaceMode: 'bots', workspaceOwnerKey: ownerKey })
-}
-
-/** Resolve @handles in prose against the Bot Mode roster (local + Connections).
- *  Skips the bot already speaking in this chat. Unique bare names match;
- *  duplicate names require the @name-device handle. */
-function resolveRosterMentions(text, roster, active = {}) {
-  const members = Array.isArray(roster) ? roster : []
-  const prose = String(text || '').replace(/```[\s\S]*?```/g, ' ').replace(/`[^`\n]*`/g, ' ')
-  const byForm = new Map()
-
-  for (const bot of members) {
-    if (!bot?.name || isActiveRosterBot(bot, active)) {
-      continue
-    }
-
-    const handle = String(botHandle(bot.name, bot) || '').toLowerCase()
-    const name = String(bot.name || '').toLowerCase()
-    const forms = new Set([handle, name])
-
-    if (bot.handle) {
-      forms.add(String(bot.handle).toLowerCase())
-    }
-
-    // Renamed bots are taggable by their friendly names too — the core
-    // profile display_name and the Bot Mode title (issue: renaming a bot
-    // didn't change what you @-tag it with).
-    for (const friendly of botFriendlyNames(bot)) {
-      for (const form of mentionNameForms(friendly)) {
-        forms.add(form)
-      }
-    }
-
-    for (const form of forms) {
-      if (!form) {
-        continue
-      }
-
-      const existing = byForm.get(form)
-
-      if (existing && existing !== bot) {
-        byForm.set(form, null)
-        continue
-      }
-
-      if (!existing) {
-        byForm.set(form, bot)
-      }
-    }
-  }
-
-  const mentioned = []
-  const seen = new Set()
-
-  for (const match of prose.matchAll(/(^|\s)@([a-z0-9][a-z0-9_-]*)/gi)) {
-    let token = match[2].toLowerCase()
-
-    if (token === 'hermes') {
-      token = byForm.has('hermes') ? 'hermes' : token
-    }
-
-    const bot = byForm.get(token)
-
-    if (!bot) {
-      continue
-    }
-
-    const key = botRosterKey(bot)
-
-    if (seen.has(key)) {
-      continue
-    }
-
-    seen.add(key)
-    mentioned.push(bot)
-  }
-
-  return mentioned
-}
-
-/** Source-qualified identity for a roster row — the React list key AND the
- *  cross-surface roster identity. Names alone are NOT unique in a
- *  multi-source roster (two connections can both expose 'default');
- *  duplicate keys make React reconciliation repeat whole blocks of the list
- *  on every poll repaint (the Aug 2026 dupe-bots smear). */
-function botRosterKey(bot) {
-  return `${bot?.connectionId || 'legacy'}::${bot?.name || 'default'}`
-}
-
-function botRouteKey(route) {
-  return `${route.connectionId}::${route.profile}`
-}
-
-function botMetaKey(bot) {
-  const route = botConnectionRoute(bot)
-
-  return route ? botRouteKey(route) : bot?.name
-}
-
-function persistBotMetaSnapshot(value, scoped = false) {
-  try {
-    const persisted = scoped
-      ? commitBotMetaV2(pluginCtx?.storage, value)
-      : Promise.resolve(pluginCtx?.storage?.set?.(BOT_META_V1_KEY, value))
-
-    return persisted.catch(() => undefined)
-  } catch {
-    return Promise.resolve()
-  }
-}
-
-function sourceByConnection(sources) {
-  return new Map(
-    (Array.isArray(sources) ? sources : [])
-      .filter(source => source?.connectionId)
-      .map(source => [String(source.connectionId), source])
-  )
-}
-
-/** Copy current source health onto a row without changing its owner. */
-function annotateBotSource(bot, sources) {
-  const id = String(bot?.connectionId || '').trim()
-
-  if (!id) {
-    return bot
-  }
-
-  const list = Array.isArray(sources) ? sources : []
-  const source = sourceByConnection(list).get(id)
-
-  if (!source) {
-    return list.length && bot?.sourceScoped ? { ...bot, sourceMissing: true, sourceReachable: false } : bot
-  }
-
-  return {
-    ...bot,
-    connectionKind: bot.connectionKind || source.kind,
-    connectionLabel: bot.connectionLabel || source.label,
-    sourceError: source.error || null,
-    sourceMissing: false,
-    sourceReachable: source.reachable
-  }
-}
-
-function botSourceStatus(bot) {
-  const error = String(bot?.sourceError || '').trim()
-
-  if (bot?.sourceMissing) {
-    return { available: false, key: 'missing', label: 'Gateway removed', tone: 'bad' }
-  }
-
-  if (error === 'connect-on-demand') {
-    return { available: true, key: 'on-demand', label: 'On demand', tone: 'muted' }
-  }
-
-  if (error || bot?.sourceReachable === false) {
-    return { available: false, key: 'unavailable', label: 'Unavailable', tone: 'warn' }
-  }
-
-  if (bot?.sourceReachable === true) {
-    return { available: true, key: 'ready', label: 'Ready', tone: 'good' }
-  }
-
-  return { available: true, key: 'unknown', label: 'Status unknown', tone: 'muted' }
-}
-
-/** Drop unreachable same-name copies from the top-level agent list.
- *
- *  Group rooms persist source-qualified members. After Desktop moves to the
- *  built-in This-device source, the old loopback row (127.0.0.1:port, not
- *  listening) still sits next to the live profile and looks like a second
- *  agent (#92286). Routing identities stay intact: this only filters sidebar
- *  tiles. $lastRoster, group members, and @-mentions still see every
- *  (connectionId, profile) row.
- *
- *  Ghosts stay: a selected-but-offline owner must remain visible rather than
- *  being replaced by a same-named twin on another gateway. A name with no
- *  reachable copy is kept, so a genuinely down source still has a row. */
-function preferReachableSameNameRows(bots) {
-  const rows = Array.isArray(bots) ? bots : []
-  const reachableNames = new Set()
-
-  for (const bot of rows) {
-    if (botSourceStatus(bot).available) {
-      reachableNames.add(bot?.name)
-    }
-  }
-
-  return rows.filter(bot => botSourceStatus(bot).available || bot?.ghost || !reachableNames.has(bot?.name))
-}
-// ── cross-connection routing ─────────────────────────────────────────────────
-// A bot from another registered connection (remoteSource rows) is reached
-// through host.requestProfile with a route descriptor; local bots keep the
-// active-gateway door. Feature-detected: older desktops without
-// requestProfile simply have no remote routes (callers fall back / disable).
-
-/** Non-throwing resolver behind botConnectionRoute(). Returns a typed status
- *  instead of throwing, so passive callers (display/meta lookups) can branch
- *  on `resolved | owner_removed | not_scoped` rather than catching whatever
- *  exception the strict wrapper below happens to throw. */
-function resolveBotConnectionRoute(bot) {
-  if (!bot?.sourceScoped && !bot?.remoteSource) {
-    return { status: 'not_scoped', route: null }
-  }
-
-  const candidate = bot.route || {
-    connectionId: bot.connectionId,
-    mode: bot.connectionKind === 'local' ? 'local' : 'remote',
-    profile: bot.name,
-    targetProfile: bot.targetProfile || bot.name
-  }
-  const connectionId = String(candidate?.connectionId || '').trim()
-  const profile = String(candidate?.profile || bot?.name || '').trim() || 'default'
-  const targetProfile = String(candidate?.targetProfile || profile).trim() || profile
-
-  if (!connectionId) {
-    return { status: 'owner_removed', route: null, profile }
-  }
-
-  return {
-    status: 'resolved',
-    route: Object.freeze({
-      connectionId,
-      mode: candidate.mode === 'local' || connectionId === 'local' ? 'local' : 'remote',
-      profile,
-      targetProfile
-    })
-  }
-}
-
-/** Immutable owner descriptor for every source-scoped row. The active
- *  gateway is presentation state and is never consulted here. Strict: throws
- *  when the owning connection is gone -- correct for real dispatch
- *  (requestForBot, session creation, etc.), covered by
- *  remote-routing-races.test.mjs. Passive lookups (rendering, meta) must call
- *  resolveBotConnectionRoute() directly instead of catching this throw. */
-function botConnectionRoute(bot) {
-  const resolved = resolveBotConnectionRoute(bot)
-
-  if (resolved.status === 'owner_removed') {
-    throw new Error(`Bot ${resolved.profile} has no connection owner`)
-  }
-
-  return resolved.route
-}
-
-const BOTS_HOME_OWNER_KEY = 'bots:home'
-
-function botWorkspaceOwnerKey(bot) {
-  // Render-reachable (sidebar sync, Bots home open, context menus): an
-  // orphaned row must yield a stable degraded key, never the dispatch throw.
-  const route = resolveBotConnectionRoute(bot).route
-
-  return `bot:${route ? botRouteKey(route) : String(bot?.name || 'default')}`
-}
-
-function groupWorkspaceOwnerKey(group) {
-  return `group:${groupChatRoomKey(group, $groupChats.get()[group])}`
-}
-
-function setBotsWorkspaceOwner(ownerKey, bot = null, blockedMessage = 'Select a Bot or group first.') {
-  // Render-reachable (sidebar listener fires on visibility flips). An
-  // orphaned row degrades to the blocked target instead of throwing.
-  const route = bot ? resolveBotConnectionRoute(bot).route : null
-  const target = route ? { kind: 'route', route } : { kind: 'blocked', message: blockedMessage }
-
-  host.setWorkspaceScope?.('bots', ownerKey || BOTS_HOME_OWNER_KEY, target)
-}
-function backendTargetProfile(route, fallbackProfile = 'default') {
-  if (!route) {
-    return fallbackProfile
-  }
-
-  return route.targetProfile || route.profile
-}
-
-function rewriteCliProfileOperands(argv, logical, target) {
-  const next = [...argv]
-
-  for (let index = 0; index < next.length; index += 1) {
-    if (next[index] === '--profile' && next[index + 1] === logical) {
-      next[index + 1] = target
-      index += 1
-    } else if (next[index] === `--profile=${logical}`) {
-      next[index] = `--profile=${target}`
-    }
-  }
-
-  const profileCommand = next.indexOf('profile')
-  const operand = profileCommand >= 0 ? profileCommand + 2 : -1
-  if (operand < next.length && next[operand] === logical) {
-    next[operand] = target
-  }
-
-  return next
-}
-
-function scopedBotParams(route, method, params) {
-  const logical = route.profile
-  const target = backendTargetProfile(route, logical)
-  let next = params
-
-  if (Object.prototype.hasOwnProperty.call(params, 'profile')) {
-    next = { ...next, profile: target }
-  }
-
-  if (method.startsWith('profiles.') && method !== 'profiles.create' && params.name === logical) {
-    next = { ...next, name: target }
-  }
-
-  if (params.clone_from === logical) {
-    next = { ...next, clone_from: target }
-  }
-
-  if (method === 'cli.exec' && Array.isArray(params.argv)) {
-    next = { ...next, argv: rewriteCliProfileOperands(params.argv, logical, target) }
-  }
-
-  return next
-}
-
-function botBackendProfileScope(route, fallbackProfile = 'default') {
-  if (!route) {
-    return fallbackProfile
-  }
-
-  return { connectionId: route.connectionId, profile: backendTargetProfile(route, fallbackProfile) }
-}
-
-/** Gateway RPC on the bot's OWN source. Source-scoped rows always use the
- * explicit descriptor, including a registered local source. */
-async function requestForBot(bot, method, params = {}) {
-  const route = botConnectionRoute(bot)
-
-  if (route) {
-    if (typeof host.requestProfile !== 'function') {
-      throw new Error(`Cannot route ${method} for ${route.connectionId}::${route.profile}`)
-    }
-
-    try {
-      return await host.requestProfile(route, method, scopedBotParams(route, method, params))
-    } catch (error) {
-      // React 19 formats query errors with `(error.name || '').trim()`. IPC /
-      // JSON-RPC rejections are often plain objects whose `name` is a number,
-      // which crashes the Routines pane and hides the original failure (#94471).
-      throw asRpcError(error, `Gateway request ${method} failed`)
-    }
-  }
-
-  try {
-    return await host.request(method, params)
-  } catch (error) {
-    throw asRpcError(error, `Gateway request ${method} failed`)
-  }
-}
-
-/** Coerce an IPC/JSON-RPC rejection into an Error with a string `name`.
- *
- *  React Query stores whatever the queryFn throws. React 19 then formats it
- *  with `(e.name || '').trim()`, which throws TypeError when `name` is a
- *  number (JSON-RPC codes) or another non-string — the Routines pane crash
- *  in #94471. Real Error instances are returned as-is when already safe.
- */
-function asRpcError(value, fallback) {
-  // Duck-type across realms (plugin tests run the source in `vm`, and IPC
-  // can deliver Error-like objects whose prototype is not this realm's
-  // Error). React 19 only needs a string `name`. Never mutate the rejection:
-  // frozen/sealed objects make `name = 'Error'` a silent no-op in sloppy
-  // mode, so a non-string name always becomes a fresh Error with cause.
-  const isObject = value != null && typeof value === 'object'
-  const name = isObject ? value.name : undefined
-  const message = isObject ? value.message : undefined
-  const hasStringName = typeof name === 'string'
-  const hasStringMessage = typeof message === 'string'
-  const hasStack = isObject && typeof value.stack === 'string'
-
-  if (isObject && hasStringName && (hasStack || hasStringMessage)) {
-    return value
-  }
-
-  if (isObject) {
-    const text = hasStringMessage && String(message).trim() ? String(message) : fallback
-    const error = new Error(text)
-    error.cause = value
-    return error
-  }
-
-  return new Error(value == null || value === '' ? fallback : String(value))
-}
-
-/** Stable per-member identity inside a group room. Local members keep their
- *  bare name (compat with rooms persisted before cross-connection groups);
- *  remote members get the source-qualified key so `dixie` on the Mini and a
- *  local `dixie` never share watermarks or sessions. */
-function groupMemberKey(member) {
-  return member?.sourceScoped || member?.remoteSource ? botRosterKey(member) : member?.name
-}
-
-/** Serializable immutable owner captured beside every group plumbing session. */
-function groupSessionOwner(member) {
-  const route = botConnectionRoute(member)
-  const name = String(route?.profile || member?.name || '').trim() || 'default'
-
-  if (!route) {
-    return { name }
-  }
-
-  return {
-    connectionId: route.connectionId,
-    name,
-    sourceScoped: true,
-    remoteSource: route.mode !== 'local',
-    route: { ...route }
-  }
-}
-
-// ── alias identity for connection rows (#89131) ─────────────────────────────
-// A Desktop per-profile alias (profile `moxie` with a Cloud/URL/SSH override)
-// routes to a remote backend's root profile: its route reads
-// { connectionId: C, profile: 'moxie', targetProfile: 'default' }. Once that
-// backend answers the roster itself, the row's identity is (C, 'default') —
-// a DIFFERENT key than the alias meta (C::moxie / 'moxie') — so the friendly
-// name fell off after source/session activation: the row regressed to the
-// raw Cloud hostname, or to generic 'Hermes' in Cloud-only mode.
-//
-// aliasRouteIndex bridges the backend row identity back to its configured
-// alias. It is keyed by (connectionId, targetProfile), so two same-named
-// `default` rows on different connections can never share a title, and it
-// fails closed when two aliases claim the same backend row (mirroring the
-// fail-closed route resolution). This is the one sanctioned exception to
-// "remote rows never borrow local meta": the alias IS the local identity of
-// exactly this connection row, proven by the configured route — never by a
-// bare name match.
-let aliasRouteIndex = new Map()
-
-/** Rebuild the alias index from the credential-free route inventory. Only
- *  genuine aliases (route.profile !== route.targetProfile) participate. */
-function indexAliasRoutes(routes) {
-  const next = new Map()
-
-  for (const route of Array.isArray(routes) ? routes : []) {
-    const connectionId = String(route?.connectionId || '').trim()
-    const profile = String(route?.profile || '').trim()
-    const target = String(route?.targetProfile || '').trim()
-
-    if (!connectionId || !profile || !target || profile === target) {
-      continue
-    }
-
-    const key = `${connectionId}::${target}`
-
-    // Two aliases pointing at the same backend row are ambiguous — neither
-    // may claim the identity.
-    next.set(key, next.has(key) ? null : {
-      name: profile,
-      // Alias meta can live under the source-qualified v2 key or the bare
-      // v1 name key (aliases predate the v2 migration on mixed setups).
-      metaKeys: [`${connectionId}::${profile}`, profile]
-    })
-  }
-
-  aliasRouteIndex = next
-}
-
-/** The configured alias identity claiming this roster row, or null. Matches
- *  strictly by (connectionId, backend target profile); the alias row itself
- *  keeps resolving its own meta directly. */
-function aliasIdentityFor(bot) {
-  if (!aliasRouteIndex.size) {
-    return null
-  }
-
-  const connectionId = String(
-    bot?.connectionId ||
-      bot?.route?.connectionId ||
-      // Unannotated rich rows (no host.agents on this build) still belong to
-      // the ACTIVE gateway — Cloud-only mode must resolve the alias too.
-      (!bot?.remoteSource && !bot?.sourceScoped ? host.state.connectionId?.get?.() || '' : '')
-  ).trim()
-
-  if (!connectionId) {
-    return null
-  }
-
-  const target = String(bot?.targetProfile || bot?.route?.targetProfile || bot?.name || '').trim() || 'default'
-  const entry = aliasRouteIndex.get(`${connectionId}::${target}`) || null
-
-  return entry && entry.name !== String(bot?.name || '').trim() ? entry : null
-}
-
-// Bot metadata is scoped to the active gateway until the server exposes a
-// union of rich profile rows. Never paint that metadata onto a thin row from
-// another source: two `default` agents must not borrow each other's title,
-// pin, avatar, group, unread state, or canonical-chat pointer. The ONE
-// exception is a configured alias route claiming the row — see
-// aliasRouteIndex above — which is connection-exact, never name-based.
-function botRosterMeta(bot, metaByName) {
-  if (bot?.sourceScoped || bot?.remoteSource) {
-    // Passive meta lookup: branch on the typed status instead of catching
-    // botConnectionRoute's throw, so an owner_removed row (e.g. a stale
-    // persisted group roster after its connection was deleted) reads as "no
-    // route" without masking an unrelated failure under the same catch.
-    const resolved = resolveBotConnectionRoute(bot)
-    const route = resolved.status === 'resolved' ? resolved.route : null
-
-    const direct = route ? metaByName?.[botRouteKey(route)] : null
-
-    if (direct) {
-      return direct
-    }
-
-    const alias = aliasIdentityFor(bot)
-
-    if (alias) {
-      for (const key of alias.metaKeys) {
-        if (metaByName?.[key]) {
-          return metaByName[key]
-        }
-      }
-    }
-
-    return direct
-  }
-
-  const own = metaByName?.[bot?.name]
-
-  if (own) {
-    return own
-  }
-
-  const alias = aliasIdentityFor(bot)
-
-  if (alias) {
-    for (const key of alias.metaKeys) {
-      if (metaByName?.[key]) {
-        return metaByName[key]
-      }
-    }
-  }
-
-  return own
-}
-
-function showsHandle(name, meta, bot) {
-  const display = displayName({ name }, meta)
-  return Boolean(name && display.toLowerCase() !== botHandle(name, bot).toLowerCase())
-}
-
-// ── canonical bot chat ───────────────────────────────────────────────────────
-// Each bot has ONE forever chat, identified by NAME, never by pointer: the
-// session titled exactly "Bot Chat" on that bot's profile. The core
-// UNIQUE(title) index makes (profile, "Bot Chat") an exact registry, so every
-// open consults that registry directly — there is nothing to verify, re-pin,
-// grandfather, or recover. Stored-id pins (ui_meta['hermes-bots'].chat) were
-// the previous identity and are REMOVED: every lost-chat incident traced to a
-// dangled or stolen pointer that later guards then welded in. Legacy
-// ui_meta.chat keys are simply ignored.
-
-// In-flight creations, keyed by bot name — double-clicking a row must not
-// mint two canonical chats.
-const canonicalCreations = new Map()
-
-/** Upper bound for per-profile session.list scans (hide sweep, canonical-chat
- *  adoption, stored-session lookups). */
-const PROFILE_SESSION_LIST_LIMIT = 200
-let botOpenGeneration = 0
-let botOpenInFlight = 0
-
-function beginBotOpen() {
-  const generation = ++botOpenGeneration
-  botOpenInFlight = generation
-  return generation
-}
-
-function finishBotOpen(generation) {
-  if (botOpenInFlight === generation) {
-    botOpenInFlight = 0
-  }
-}
-
-function cancelBotOpen() {
-  botOpenGeneration += 1
-  botOpenInFlight = 0
-}
-
-/** The one canonical title. (profile, CANONICAL_CHAT_TITLE) IS the bot's
- *  forever-chat identity — see the header above. */
-const CANONICAL_CHAT_TITLE = 'Bot Chat'
-
-async function openStoredBotChat(owner, storedId, summary) {
-  if (!storedId || typeof host.openSession !== 'function') {
-    throw new Error('This Hermes Desktop version cannot open stored sessions')
-  }
-
-  const { bot, name, route } = botOwner(owner)
-  const ownerKey = botWorkspaceOwnerKey(bot)
-
-  const hasAuthoritativeCount =
-    typeof summary?.message_count === 'number' && Number.isFinite(summary.message_count)
-  const expectHistory = hasAuthoritativeCount ? summary.message_count > 0 : true
-  // Current SDKs export the Bot-specific budget. The fallback preserves
-  // compatibility with older hosts and isolated plugin test harnesses.
-  const hydrationTimeoutMs =
-    typeof sdk !== 'undefined' && Number.isFinite(sdk.BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS)
-      ? sdk.BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS
-      : 60_000
-
-  // A profile backend that just woke up can lose the hydration-timeout race
-  // even though the session is fine (hermes-agent#89617) — clicking Retry
-  // succeeds because the backend is warm by then. retryHydrationTimeoutOnce
-  // asks the SDK layer to retry that same wait internally, BEFORE it arms the
-  // core stranded-session overlay: a plugin-side retry can't do this because
-  // only host.openSession sees the resume-exhausted latch that overlay reads.
-  //
-  // forceResume: an explicit bot switch must never trust a cached transcript.
-  // The SDK's surface-health check passes whenever ANY non-empty transcript is
-  // painted, including a stale snapshot the session-states cache kept from the
-  // previous time this bot was open — which left the pane showing old messages
-  // until an app restart (hermes-agent#93604). A resume is cheap and
-  // idempotent, so on this explicit user navigation we always request one.
-  await host.openSession(storedId, {
-    ...(route ? { route } : {}),
-    profile: name,
-    intent: 'tab',
-    awaitHydration: true,
-    expectHistory,
-    forceResume: true,
-    hydrationTimeoutMs,
-    keepAllProfilesScope: true,
-    workspaceMode: 'bots',
-    workspaceOwnerKey: ownerKey,
-    retryHydrationTimeoutOnce: true,
-    tabTitle: CANONICAL_CHAT_TITLE
-  })
-
-  return storedId
-}
-
-/** True when a session summary IS the canonical registry row. root_title is
- *  the durable lineage-root title reported by exact-lookup gateways; plain
- *  title covers windowed listings. */
-function isCanonicalBotChatHistory(history) {
-  const rootTitle = String(history?.root_title || '').trim()
-  const title = String(history?.title || '').trim()
-  return rootTitle === CANONICAL_CHAT_TITLE || (!rootTitle && title === CANONICAL_CHAT_TITLE)
-}
-
-function botModeGatewayNeedsUpdate(error) {
-  const message = String(error?.message || error || '')
-
-  return /(?:method not found|no handler for|unknown method|unsupported rpc)/i.test(message)
-}
-
-function notifyBotOpenFailure(error, bot, fallbackMessage) {
-  if (botModeGatewayNeedsUpdate(error)) {
-    const gateway = bot.connectionLabel || bot.connectionId || 'this gateway'
-
-    host.notify?.({
-      kind: 'error',
-      title: 'Update this gateway to use Bot Mode',
-      message: `Update ${gateway}, then try again.`
-    })
-
-    return
-  }
-
-  host.notifyError?.(error, fallbackMessage)
-}
-
-/** THE identity lookup: the profile's session titled exactly "Bot Chat",
- *  consulted on the bot's OWN source. The core UNIQUE title index guarantees
- *  at most ONE such row per profile db — Profile → Named Session is an exact
- *  registry, so consult it exactly: `title` asks the gateway for an indexed
- *  WHERE title = ? lookup (window-free; a busy profile can push the
- *  forever-chat past any recency window). include_hidden is required
- *  (canonical chats are always hidden). Remote bots route via requestForBot
- *  on the immutable captured owner — activation is a UI concern and never
- *  authorizes this RPC. */
-async function findExistingCanonicalChat(owner) {
-  const { bot, name, route } = botOwner(owner)
-  // FAIL CLOSED. A failed registry lookup MUST NOT read as "no Bot Chat
-  // exists" — that is the one remaining way to fork a bot's forever chat.
-  // The failure lives exactly in the post-update window: the desktop
-  // restarts every profile backend, the first bot click races the warm-up,
-  // the lookup RPC fails transiently, and a swallowed error here sent
-  // createCanonicalChat() straight to session.create — minting a fresh
-  // "Bot Chat" while the real one (data intact, hidden) still held the
-  // canonical title. Users read that as "my bot lost all context after the
-  // update". Cross-connection lookups fail MORE often (network), so this
-  // matters doubly for remote bots. Both open paths catch and toast "try
-  // again", which is the correct outcome: retry, never mint.
-  let res
-  try {
-    res = await requestForBot(bot, 'session.list', {
-      profile: backendTargetProfile(route, name),
-      title: CANONICAL_CHAT_TITLE,
-      limit: PROFILE_SESSION_LIST_LIMIT,
-      include_hidden: true
-    })
-  } catch (error) {
-    // Plugin tests and host bridges can return Error-like values from another
-    // JS realm, where `instanceof Error` is false. Preserve the provider/RPC
-    // message so update-required classification and diagnostics still work.
-    const message = typeof error?.message === 'string' ? error.message : ''
-    const detail = message ? ` (${message})` : ''
-    throw new Error(`Could not check ${name}'s Bot Chat registry${detail} — not starting a new chat`)
-  }
-
-  const rows = res?.sessions ?? []
-  return rows.find(row => isCanonicalBotChatHistory(row)) || null
-}
-
-/** Create the bot's ONE forever chat: a real session titled "Bot Chat".
- *  Adopts the existing "Bot Chat" row instead of creating when the profile
- *  already has one — minting while a "Bot Chat" row exists is always wrong
- *  twice over: it forks the forever-chat AND the new row can never take the
- *  (already held) canonical title. Creates on the bot's own source via
- *  requestForBot.
- *
- *  `kickoff` (New Agent creation ONLY): submit the self-introduction prompt
- *  so a brand-new bot greets its owner once. Every other caller — the bot
- *  row's click-path canonical resolution above all — must NOT pass it: a
- *  resolution miss (retitled row, hidden-listing gap, post-update skew)
- *  re-mints the session, and re-firing the intro there burned a model turn
- *  and stamped a user-attributed "Hey, tell me about yourself!" into the
- *  chat on every click (ScottFive report). The kickoff's original session-
- *  persistence job is done by the eager session.title write below on modern
- *  gateways; older gateways that reject the eager write keep a narrow
- *  compat kickoff, else the pruner reaps the empty lazy session and the
- *  chat never survives its own creation.
- *
- *  `openingStillCurrent` (click-path opens): a staleness probe consulted
- *  before every navigation — when the user has already moved on (opened a
- *  group, clicked another bot), the create still completes registry-side
- *  but never steals the workspace (#89834 family). */
-function createCanonicalChat(owner, { kickoff = false, openingStillCurrent = null } = {}) {
-  const { bot, name, key, route } = botOwner(owner)
-  const inflight = canonicalCreations.get(key)
-
-  if (inflight) {
-    if (!openingStillCurrent) {
-      return inflight.run
-    }
-
-    return inflight.run.then(async sid => {
-      if (sid && openingStillCurrent() && typeof host.openSession === 'function') {
-        await host.openSession(sid, {
-          ...(route ? { route } : {}),
-          profile: name,
-          intent: 'main',
-          keepAllProfilesScope: route ? true : false,
-          workspaceMode: 'bots',
-          workspaceOwnerKey: botWorkspaceOwnerKey(bot),
-          tabTitle: CANONICAL_CHAT_TITLE
-        })
-      }
-      return sid
-    })
-  }
-
-  const flight = { run: null }
-  const canNavigate = () => !openingStillCurrent || openingStillCurrent()
-
-  const run = (async () => {
-    const existing = await findExistingCanonicalChat(owner)
-
-    if (existing?.id) {
-      if (typeof host.openSession === 'function' && canNavigate()) {
-        // The exact-lookup gateway reports the compression-lineage tip as
-        // resolved_id; open the tip, the registry row stays the identity.
-        await openStoredBotChat(owner, existing.resolved_id || existing.id, existing)
-      }
-
-      return existing.id
-    }
-
-    const res = await requestForBot(bot, 'session.create', {
-      profile: backendTargetProfile(route, name),
-      title: CANONICAL_CHAT_TITLE,
-      // Always born hidden from the global sidebar — Bot Mode sessions are
-      // plugin-owned. Core applies this via the generic `hidden` flag
-      // (deferred as pending_hidden until the row exists); older gateways
-      // ignore the unknown param and it stays visible.
-      hidden: true,
-      // Explicit contract: this session's runtime always follows the member
-      // profile's CURRENT config. Resume must NOT restore the stored
-      // model/provider pin from an old row (that left bot DMs stuck on a
-      // stale provider — e.g. "out of Nous credits" — after a profile switch).
-      follow_profile_config: true
-    })
-    const sid = res?.stored_session_id
-    const runtime = res?.session_id
-
-    // session.create is intentionally lazy: its stored row does not exist until
-    // the first prompt. Mounting `sid` immediately therefore emits a noisy REST
-    // 404 ("Session not found"), and the turn-start auto-titler can win the race
-    // against the deferred `title: 'Bot Chat'` — under name-identity that is an
-    // identity outage: until the row is titled, the registry has no "Bot Chat"
-    // entry, so a second click during the intro turn mints a duplicate.
-    // session.title materializes the row now and records a user-authority title
-    // before either the open or kickoff, closing both the 404 race and the
-    // untitled window. Older gateways may not support the eager write; retain
-    // the kickoff-and-retry fallback below.
-    let titled = false
-
-    if (runtime) {
-      try {
-        await requestForBot(bot, 'session.title', { session_id: runtime, title: CANONICAL_CHAT_TITLE })
-        titled = true
-      } catch (error) {
-        // ADOPT-BEFORE-MINT: a title-uniqueness rejection is not an old
-        // gateway — it means another writer took the canonical title between
-        // our registry miss and this write (peer dm minting server-side, a
-        // second machine, cross-connection sync). Falling through to the
-        // compat path would prompt into OUR stray session and fork the
-        // forever chat. Re-consult the registry and adopt the winner; the
-        // stray lazy session holds zero messages and is simply abandoned
-        // (the gateway prunes it).
-        if (/already in use/i.test(String(error?.message || ''))) {
-          const winner = await findExistingCanonicalChat(owner)
-
-          if (winner?.id) {
-            if (typeof host.openSession === 'function') {
-              await openStoredBotChat(owner, winner.resolved_id || winner.id, winner)
-            }
-
-            return winner.id
-          }
-        }
-        /* compatibility fallback: prompt.submit will persist the lazy row */
-      }
-    }
-
-    // Mount the session view FIRST, then send the kickoff — submitting into
-    // an unmounted session left the intro reply invisible until reopen.
-    let opened = false
-
-    if (sid && typeof host.openSession === 'function' && canNavigate()) {
-      try {
-        await host.openSession(sid, {
-          ...(route ? { route } : {}),
-          profile: name,
-          intent: 'main',
-          keepAllProfilesScope: route ? true : false,
-          ...(openingStillCurrent
-            ? { workspaceMode: 'bots', workspaceOwnerKey: botWorkspaceOwnerKey(bot), tabTitle: CANONICAL_CHAT_TITLE }
-            : {})
-        })
-        opened = true
-      } catch {
-        // The stored row may not exist until the kickoff persists it. Retry
-        // after prompt.submit below instead of leaving the chat off-screen.
-      }
-    }
-
-    if (runtime) {
-      // Intro turn: only on genuine New Agent creation (`kickoff`), or as the
-      // COMPAT persistence write when the eager title failed — an old gateway
-      // prunes the zero-message lazy session, so without some first prompt
-      // the chat never survives its own creation. A titled row needs neither:
-      // the user speaks first.
-      const submitIntro = kickoff || !titled
-
-      if (submitIntro) {
-        await new Promise(resolve => window.setTimeout(resolve, 400))
-
-        try {
-          await requestForBot(bot, 'prompt.submit', { session_id: runtime, text: 'Hey, tell me about yourself!' })
-
-          if (!opened && sid && typeof host.openSession === 'function' && canNavigate()) {
-            await host.openSession(sid, {
-              ...(route ? { route } : {}),
-              profile: name,
-              intent: 'main',
-              keepAllProfilesScope: route ? true : false,
-              ...(openingStillCurrent
-                ? { workspaceMode: 'bots', workspaceOwnerKey: botWorkspaceOwnerKey(bot), tabTitle: CANONICAL_CHAT_TITLE }
-                : {})
-            })
-          }
-        } catch {
-          // The chat already exists under the canonical title — the next click
-          // finds it by name instead of making a second Bot Chat.
-        }
-      } else if (!opened && sid && typeof host.openSession === 'function' && canNavigate()) {
-        // No intro turn: still finish mounting the chat when the first open
-        // raced the (now titled) row.
-        try {
-          await host.openSession(sid, {
-            ...(route ? { route } : {}),
-            profile: name,
-            intent: 'main',
-            keepAllProfilesScope: route ? true : false,
-            ...(openingStillCurrent
-              ? { workspaceMode: 'bots', workspaceOwnerKey: botWorkspaceOwnerKey(bot), tabTitle: CANONICAL_CHAT_TITLE }
-              : {})
-          })
-        } catch {
-          /* row is titled and persistent — the next click opens it by name */
-        }
-      }
-    }
-
-    return sid || null
-  })().finally(() => {
-    if (canonicalCreations.get(key) === flight) {
-      canonicalCreations.delete(key)
-    }
-  })
-
-  flight.run = run
-  canonicalCreations.set(key, flight)
-
-  return run
-}
-
-/** Open the bot's ONE forever chat and return the opened registry id.
- *
- *  The whole resolution is one registry consultation ON THE BOT'S OWN
- *  SOURCE: the profile's session titled "Bot Chat" exists → open it
- *  (lineage tip); it doesn't → create it. No id pointer is read or written
- *  anywhere in this path — remote bots included. The owner route rides
- *  every RPC (requestForBot) and the open (openStoredBotChat), so a remote
- *  bot's chat opens without re-homing Desktop's chrome. */
-async function openBotCanonicalChat(owner, openingStillCurrent = null) {
-  const existing = await findExistingCanonicalChat(owner)
-
-  if (existing?.id && typeof host.openSession === 'function') {
-    if (openingStillCurrent && !openingStillCurrent()) {
-      return null
-    }
-    const openedId = existing.resolved_id || existing.id
-    await openStoredBotChat(owner, openedId, existing)
-    // Both identities matter downstream: the durable registry row names the
-    // chat; the resolved lineage tip is what actually takes session focus.
-    // Callers matching focus against only the registry id mistook every
-    // compressed Bot Chat for a stale open (first click bounced to the home).
-    return { registryId: String(existing.id), openedId: String(openedId) }
-  }
-
-  const created = await createCanonicalChat(owner, { openingStillCurrent })
-  return created ? { registryId: String(created), openedId: String(created) } : null
-}
-
-async function prepareBotSource(bot) {
-  if (!bot.sourceScoped) {
-    return
-  }
-
-  // Cross-connection RPCs ride the immutable captured route (requestForBot →
-  // host.requestProfile) — Desktop's active connection does not move, and
-  // activation is a UI concern that never authorizes the calls. All this
-  // gate does is refuse when the desktop predates routed profile requests.
-  const route = botConnectionRoute(bot)
-
-  if (route && typeof host.requestProfile !== 'function') {
-    throw new Error('Update Hermes Desktop to chat with agents on other connections.')
-  }
-
-  if (!route && typeof host.ensureAgent === 'function') {
-    // Source-annotated row on the ACTIVE connection (no captured route):
-    // legacy activation path, unchanged.
-    await host.ensureAgent(bot.connectionId, bot.name)
-  }
-}
-
-async function ensureBotMetadata(bot) {
-  if (!bot?.sourceScoped) {
-    return botRosterMeta(bot, $botMeta.get()) || {}
-  }
-
-  const route = botConnectionRoute(bot)
-  const backendProfile = backendTargetProfile(route, bot.name)
-  const result = await requestForBot(bot, 'profiles.list', {})
-  const row = (result?.profiles || []).find(profile => profile?.name === backendProfile)
-  const server = row?.ui_meta?.['hermes-bots']
-
-  if (server && typeof server === 'object') {
-    const key = botMetaKey(bot)
-    $botMeta.set({ ...$botMeta.get(), [key]: { ...($botMeta.get()[key] || {}), ...server } })
-    persistBotMetaSnapshot($botMeta.get(), true)
-  }
-
-  return botRosterMeta(bot, $botMeta.get()) || {}
-}
-
-/** The tab this bot's workspace already has open, fronted — or null when it
- *  has none. A roster click consults this BEFORE the canonical registry so a
- *  bot with open tabs simply comes back to the one the user left. It is what
- *  lets a closed Bot Chat STAY closed: the click path used to re-open the
- *  forever-chat beside every newer thread on every bot switch, and nothing
- *  records a close (this plugin keeps no closed set; core's tile bucket only
- *  forgets), so the only honest signal is the open set itself. Feature-
- *  detected — older shells fall through to the canonical open. */
-function focusExistingBotTab(bot) {
-  if (typeof host.focusOpenWorkspaceSession !== 'function') {
-    return null
-  }
-
-  try {
-    const focused = host.focusOpenWorkspaceSession(botWorkspaceOwnerKey(bot))
-
-    return typeof focused === 'string' && focused ? focused : null
-  } catch {
-    return null
-  }
-}
-
-/** Select one exact roster owner, then open its named canonical chat only when
- *  the current Desktop can route that owner without guessing. The workspace
- *  remembers only this transient opened-view observation; it never stores or
- *  resolves a canonical-chat id.
- *
- *  `canonical`: the user asked for the forever-chat itself (Bots home "Open
- *  chat", the row menu's "Open Bot Chat"). A plain row click is "go to this
- *  bot": when its workspace already holds tabs, the one the user last had
- *  active is fronted and no chat is resolved or opened — see
- *  focusExistingBotTab. */
-async function openRosterBot(bot, { canonical = false } = {}) {
-  const generation = beginBotOpen()
-  const key = botRosterKey(bot)
-  const meta = botRosterMeta(bot, $botMeta.get())
-  // Keep the currently visible group as a fallback until this explicit action
-  // has actually fronted a new owner; a failed home open must not steal the
-  // center from a group the user was reading.
-  const previousGroup = $groupChatWorkspace.get()
-  const previousGroupRef = previousGroup
-    ? { group: previousGroup, roomId: String($groupChats.get()[previousGroup]?.roomId || '') }
-    : null
-
-  haptic('tap')
-  saveSelectedRosterBot(bot)
-  setBotsWorkspaceOwner(botWorkspaceOwnerKey(bot), bot)
-
-  const dismissedGroup = bot.remoteSource ? null : dismissGroupChatForLocalBotOpen()
-
-  if (!dismissedGroup) {
-    $groupChatWorkspace.set(null)
-  }
-
-  const restorePreviousGroup = () => {
-    if (!previousGroupRef || $groupChatWorkspace.get()) {
-      return
-    }
-
-    const restoreRef = dismissedGroup || previousGroupRef
-    const rooms = $groupChats.get()
-    const currentGroup = restoreRef.roomId
-      ? Object.keys(rooms).find(name => !rooms[name]?.tombstone && String(rooms[name]?.roomId || '') === restoreRef.roomId)
-      : liveGroupChatNames().includes(restoreRef.group)
-        ? restoreRef.group
-        : null
-
-    if (!currentGroup) {
-      return
-    }
-
-    openGroupChat(currentGroup)
-  }
-
-  if ($botUnread.get()[key]) {
-    const next = { ...$botUnread.get() }
-    delete next[key]
-    $botUnread.set(next)
-  }
-
-  if (!canonical) {
-    const focused = focusExistingBotTab(bot)
-
-    if (focused) {
-      // Open tabs win: no source activation, no registry consult, no open.
-      // The claim carries only the fronted tab so the focus edge it fires
-      // keeps it (releaseStaleOpenBotChat) and the home yields.
-      // The handoff is complete the moment the tab fronts — release the
-      // bot-open guard (#95917) so passive home reconciliation resumes.
-      finishBotOpen(generation)
-      $openBotChat.set({ key, openedRegistryId: '', openedSessionId: focused })
-      closeBotsHomeWorkspace()
-
-      return true
-    }
-  }
-
-  try {
-    // Activation selects this row's source only. Canonical identity is resolved
-    // after that by the owner profile's "Bot Chat" title registry.
-    await prepareBotSource(bot)
-  } catch (error) {
-    if (generation === botOpenGeneration) {
-      finishBotOpen(generation)
-      $openBotChat.set(null)
-      restorePreviousGroup()
-      syncBotsHomeWorkspace()
-
-      notifyBotOpenFailure(error, bot, `Could not reach ${bot.connectionLabel || 'the gateway'}`)
-    }
-
-    return false
-  }
-
-  if (generation !== botOpenGeneration) {
-    finishBotOpen(generation)
-    return false
-  }
-
-  try {
-    const opened = await openBotCanonicalChat(bot, () => generation === botOpenGeneration)
-
-    if (generation !== botOpenGeneration) {
-      finishBotOpen(generation)
-      return false
-    }
-
-    if (opened) {
-      // This is not an identity preference: opening already completed through
-      // the name registry. Keep only enough ephemeral state to release the
-      // home if another tab later claims the center. Track BOTH identities —
-      // session focus reports the compression-lineage tip (openedId), not the
-      // durable registry row, and matching focus against the registry id
-      // alone released this claim on the first click of every compressed
-      // Bot Chat (home bounced over the chat; a second click stuck only
-      // because no new focus edge fired).
-      $openBotChat.set({
-        key,
-        openedRegistryId: opened.registryId,
-        openedSessionId: opened.openedId
-      })
-      finishBotOpen(generation)
-      closeBotsHomeWorkspace()
-      return true
-    }
-  } catch (error) {
-    if (generation === botOpenGeneration) {
-      finishBotOpen(generation)
-      $openBotChat.set(null)
-      restorePreviousGroup()
-      syncBotsHomeWorkspace()
-
-      notifyBotOpenFailure(error, bot, `Could not open ${displayName(bot, meta)}'s chat — try again`)
-    }
-
-    return false
-  }
-
-  // An older Desktop without the profile-scoped draft API has no safe fallback:
-  // do not navigate the current workspace or create a draft on the wrong owner.
-  if (typeof host.newChat !== 'function') {
-    finishBotOpen(generation)
-    $openBotChat.set(null)
-    restorePreviousGroup()
-    syncBotsHomeWorkspace()
-    return false
-  }
-
-  $openBotChat.set({ key, openedRegistryId: '' })
-  finishBotOpen(generation)
-  closeBotsHomeWorkspace()
-  newBotChat(bot)
-  return true
-}
-
-function displayName(bot, meta) {
-  // A configured alias route claiming this row overrides source-derived
-  // identity: the friendly alias name must survive hosted-session
-  // activation and Cloud-only rosters (#89131).
-  const alias = aliasIdentityFor(bot)
-
-  // Only THIN rows from another source trade the friendly name for their
-  // connection label — the active gateway's own default must keep reading
-  // "Hermes". Annotated active rows carry sourceScoped too, and keying this
-  // off sourceScoped renamed the user's main agent to an IP-derived label
-  // (community report, Aug 17 2026).
-  if (bot?.remoteSource && (bot.name || '').trim().toLowerCase() === 'default' && bot.connectionLabel && !alias && !meta?.title?.trim()) {
-    return bot.connectionLabel
-  }
-
-  if (meta?.title?.trim()) {
-    return meta.title.trim()
-  }
-
-  // Core-profile display name (profile.yaml, set via `hermes profile rename
-  // default <name>` or the dashboard) — the CLI-level equivalent of a Bot
-  // Mode title. Rides the profiles.list row; presentation-only.
-  if (typeof bot?.display_name === 'string' && bot.display_name.trim()) {
-    return bot.display_name.trim()
-  }
-
-  // An untitled backend row claimed by an alias reads as the alias name —
-  // never generic "Hermes" or a hostname-derived label.
-  if (alias) {
-    const raw = alias.name.replace(/[-_]+/g, ' ').trim()
-
-    return raw.replace(/\b\w/g, ch => ch.toUpperCase())
-  }
-
-  // The primary profile is literally named "default" — as a bot identity
-  // that reads like nobody bothered. Present it as Hermes (the agent it is)
-  // unless the user gives it a real title.
-  if ((bot.name || '').trim().toLowerCase() === 'default' && !bot.title) {
-    return 'Hermes'
-  }
-
-  const raw = (bot.title || bot.name || '').replace(/[-_]+/g, ' ').trim()
-  return raw.replace(/\b\w/g, ch => ch.toUpperCase())
-}
-
-/** Filter by the two stable identities rendered in every roster row: the
- * customizable display name and the profile's @handle. Keep the current
- * activity order — search narrows the roster, it never re-ranks it. */
-function filterBots(roster, metaByName, query) {
-  const needle = query.trim().toLowerCase().replace(/^@/, '')
-
-  if (!needle) {
-    return roster
-  }
-
-  return roster.filter(bot => {
-    const meta = botRosterMeta(bot, metaByName)
-    const display = displayName(bot, meta).toLowerCase()
-    const profile = (bot.name || '').toLowerCase()
-    const handle = botHandle(bot.name, bot).toLowerCase()
-    // Multi-source rows also match on their device name ("homelab" finds
-    // every bot living on the Homelab connection).
-    const sourceLabel = (bot.connectionLabel || '').toLowerCase()
-    const role = `${meta?.description || ''} ${bot.description || ''}`.toLowerCase()
-    const preview = String(botActivitySession(bot)?.preview || '').toLowerCase()
-    return (
-      display.includes(needle) ||
-      profile.includes(needle) ||
-      handle.includes(needle) ||
-      sourceLabel.includes(needle) ||
-      role.includes(needle) ||
-      preview.includes(needle)
-    )
-  })
-}
-
-function filterBotsByGateway(roster, connectionId) {
-  if (!connectionId || connectionId === 'all') {
-    return roster
-  }
-
-  return (roster || []).filter(bot => String(bot?.connectionId || '') === connectionId)
-}
-
-function botNeedsHandleLabel(bot, roster, metaByName) {
-  const identity = displayName(bot, botRosterMeta(bot, metaByName)).trim().toLowerCase()
-  const connectionId = String(bot?.connectionId || '')
-
-  return (roster || []).some(
-    candidate =>
-      botRosterKey(candidate) !== botRosterKey(bot) &&
-      String(candidate?.connectionId || '') === connectionId &&
-      displayName(candidate, botRosterMeta(candidate, metaByName)).trim().toLowerCase() === identity &&
-      botHandle(candidate.name, candidate) !== botHandle(bot.name, bot)
-  )
-}
-
-function groupMatchesRosterFilters(name, members, metaByName, query, connectionId) {
-  const inGateway = filterBotsByGateway(members, connectionId)
-
-  if (connectionId && connectionId !== 'all' && inGateway.length === 0) {
-    return false
-  }
-
-  const needle = String(query || '').trim().toLowerCase().replace(/^@/, '')
-
-  return !needle || String(name || '').toLowerCase().includes(needle) || filterBots(inGateway, metaByName, needle).length > 0
-}
-
-function rosterGatewayOptions(sources, roster) {
-  const byId = new Map()
-
-  for (const source of Array.isArray(sources) ? sources : []) {
-    const id = String(source?.connectionId || '').trim()
-
-    if (id) {
-      byId.set(id, { ...source, connectionId: id, count: 0 })
-    }
-  }
-
-  for (const bot of roster || []) {
-    const id = String(bot?.connectionId || '').trim()
-
-    if (!id) {
-      continue
-    }
-
-    const source = byId.get(id) || {
-      connectionId: id,
-      kind: bot.connectionKind,
-      label: bot.connectionLabel || id,
-      reachable: bot.sourceReachable,
-      error: bot.sourceError,
-      count: 0
-    }
-    source.count += 1
-    byId.set(id, source)
-  }
-
-  return [...byId.values()].sort((a, b) =>
-    String(a.label || a.connectionId).localeCompare(String(b.label || b.connectionId), undefined, {
-      sensitivity: 'base'
-    })
-  )
-}
-
-function rosterGatewaySections(botRows, gatewayOptions, gatewayFilter = 'all') {
-  const rows = Array.isArray(botRows) ? botRows : []
-  const options = Array.isArray(gatewayOptions) ? gatewayOptions : []
-
-  if (gatewayFilter !== 'all' || options.length <= 1) {
-    return { sectioned: false, sections: [{ id: 'all', option: null, rows }] }
-  }
-
-  const byId = new Map()
-
-  for (const row of rows) {
-    const bot = row?.bot || row
-    const id = String(bot?.connectionId || 'legacy').trim() || 'legacy'
-    const bucket = byId.get(id) || []
-    bucket.push(row)
-    byId.set(id, bucket)
-  }
-
-  const known = new Set()
-  const sections = []
-
-  for (const option of options) {
-    const id = String(option?.connectionId || '').trim()
-    const sectionRows = byId.get(id)
-
-    if (!id || !sectionRows?.length) {
-      continue
-    }
-
-    known.add(id)
-    sections.push({ id, option, rows: sectionRows })
-  }
-
-  for (const [id, sectionRows] of byId) {
-    if (known.has(id)) {
-      continue
-    }
-
-    const bot = sectionRows[0]?.bot || sectionRows[0]
-    sections.push({
-      id,
-      option: {
-        connectionId: id,
-        kind: bot?.connectionKind || 'remote',
-        label: bot?.connectionLabel || (id === 'legacy' ? 'Current gateway' : id),
-        reachable: bot?.sourceReachable,
-        error: bot?.sourceError
-      },
-      rows: sectionRows
-    })
-  }
-
-  return { sectioned: true, sections }
-}
-
-function gatewayKindIcon(kind) {
-  const icons = (typeof sdk === 'undefined' ? null : sdk.icons) || {}
-
-  if (kind === 'local') return icons.Monitor
-  if (kind === 'cloud') return icons.Cloud
-  if (kind === 'ssh') return icons.Terminal
-  return icons.Network
-}
-
-function gatewayKindCodicon(kind) {
-  if (kind === 'local') return 'device-desktop'
-  if (kind === 'cloud') return 'cloud'
-  if (kind === 'ssh') return 'terminal'
-  return 'remote-explorer'
-}
-
-/** Match the gateway switcher's Tabler glyphs while keeping older SDK shells
- * usable until they expose the shared icon namespace. */
-function GatewayKindGlyph({ className, kind }) {
-  const Icon = gatewayKindIcon(kind)
-
-  return jsx('span', {
-    'aria-hidden': true,
-    className: cn('grid size-3.5 shrink-0 place-items-center', className),
-    'data-connection-kind': kind || 'remote',
-    'data-slot': 'connection-glyph',
-    children: Icon
-      ? jsx(Icon, { className: 'size-3' })
-      : jsx(Codicon, { name: gatewayKindCodicon(kind), className: 'text-[0.75rem]' })
-  })
-}
-
-function slugify(value) {
-  return value
-    .toLowerCase()
-    .replace(/[^a-z0-9_-]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 64)
-}
-
-/** Flatten markdown syntax out of a one-line roster preview so rows read
- *  like Discord's — no raw **bold**, `code`, > quotes, or [link](url)
- *  characters in the preview line. */
-function stripPreviewMarkdown(text) {
-  return String(text || '')
-    .replace(/```[\s\S]*?```/g, ' ')
-    .replace(/`([^`\n]*)`/g, '$1')
-    .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
-    .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
-    .replace(/(\*\*|__)(.*?)\1/g, '$2')
-    .replace(/(^|\s)[*_](\S(?:.*?\S)?)[*_](?=\s|$|[.,;:!?])/g, '$1$2')
-    .replace(/~~(.*?)~~/g, '$1')
-    .replace(/^\s{0,3}#{1,6}\s+/gm, '')
-    .replace(/^\s{0,3}>\s?/gm, '')
-    .replace(/\s+/g, ' ')
-    .trim()
-}
-
-/** Canonical multi-group read with legacy scalar compatibility. Profiles that
- *  predate `groups` still fall back to `group`; once the canonical array exists,
- *  it is authoritative. Writes keep `group` as a first-membership projection so
- *  older desktops can still display one room without corrupting the array. */
-function botGroups(meta) {
-  const groups = []
-  const seen = new Set()
-  const values = Array.isArray(meta?.groups) ? meta.groups : [meta?.group]
-
-  for (const value of values) {
-    if (typeof value !== 'string') {
-      continue
-    }
-
-    const group = value.trim()
-
-    if (group && !seen.has(group)) {
-      seen.add(group)
-      groups.push(group)
-    }
-  }
-
-  return groups
-}
-
-function groupMembershipPatch(meta, group, enabled) {
-  const name = String(group || '').trim()
-  let groups = botGroups(meta)
-
-  if (enabled) {
-    if (name && !groups.includes(name)) {
-      groups = [...groups, name]
-    }
-  } else {
-    groups = groups.filter(existing => existing !== name)
-  }
-
-  return { groups, group: groups[0] || null }
-}
-
-/** Build the exact metadata cleanup for a room disband. The rendered member
- *  list is only a presentation snapshot and can already be empty on a remote
- *  connection while bot metadata still names the room. Durable room members
- *  and the full roster recover source-qualified owners; every remaining
- *  metadata record is still cleared locally, but an unresolved scoped key is
- *  never guessed into a server route. */
-function groupDisbandMetadataPlan(group, members, room, roster, metaByName) {
-  const owners = new Map()
-  const patches = new Map()
-
-  const rememberOwner = (owner, required = false) => {
-    if (!owner?.name) {
-      return
-    }
-
-    let key
-    try {
-      key = botMetaKey(owner)
-    } catch {
-      return
-    }
-
-    const meta = metaByName?.[key] || botRosterMeta(owner, metaByName) || {}
-    if (!required && !botGroups(meta).includes(group)) {
-      return
-    }
-
-    if (!owners.has(key)) {
-      owners.set(key, owner)
-    }
-    patches.set(key, groupMembershipPatch(meta, group, false))
-  }
-
-  for (const owner of members || []) {
-    rememberOwner(owner, true)
-  }
-  for (const owner of room?.members || []) {
-    rememberOwner(owner, true)
-  }
-  for (const owner of roster || []) {
-    rememberOwner(owner)
-  }
-
-  // Metadata itself is the final source of a metadata-only `0 bots` row.
-  // Clear every record that names the room even when its exact server owner is
-  // temporarily absent from the roster. Known owners still get a routed
-  // profiles.configure write below; unknown scoped records remain local-only.
-  for (const [key, meta] of Object.entries(metaByName || {})) {
-    if (botGroups(meta).includes(group)) {
-      patches.set(key, groupMembershipPatch(meta, group, false))
-    }
-  }
-
-  return { owners, patches }
-}
-
-/** Group chats that should hold a roster row: every group named in bot meta
- *  (local members) plus every room record that still has stored members or
- *  log — cross-connection rooms whose members can't ride bot-meta. */
-function groupChatNames(metaByName, rooms) {
-  const names = new Set(knownGroups(metaByName))
-
-  for (const [name, room] of Object.entries(rooms || {})) {
-    if (room?.tombstone) {
-      continue
-    }
-
-    if ((Array.isArray(room?.members) && room.members.length) || (Array.isArray(room?.log) && room.log.length)) {
-      names.add(name)
-    }
-  }
-
-  return [...names]
-}
-
-/** Names of REAL rooms in the atom — disband tombstones excluded. Feeds the
- *  create/rename collision sets so a just-disbanded name is immediately
- *  reusable even while an in-flight drive's tombstone still holds its key. */
-function liveGroupChatNames() {
-  return Object.entries($groupChats.get())
-    .filter(([, room]) => !room?.tombstone)
-    .map(([name]) => name)
-}
-
-/** Millisecond timestamp of a room's newest log entry (0 for a silent room) —
- *  the group's recency key, competing in the same ordering as bot rows. */
-function groupLastActivity(room) {
-  const log = Array.isArray(room?.log) ? room.log : []
-
-  return log.length ? log[log.length - 1].at || 0 : 0
-}
-
-/** Seat a group's member roster: local bots whose meta names the group, plus
- *  the room record's stored descriptors (remote members can't ride bot-meta).
- *  Prefers the LIVE roster row for a stored descriptor when present. */
-function groupChatMemberBots(group, roster, metaByName) {
-  const local = (roster || []).filter(
-    bot => botGroups(botRosterMeta(bot, metaByName)).includes(group)
-  )
-  const stored = ($groupChats.get()[group] || {}).members || []
-  const seated = new Set(local.map(botRosterKey))
-  const remote = []
-
-  for (const descriptor of stored) {
-    // Legacy descriptors can carry a FRIENDLY name as `name` (older builds
-    // persisted display names — #92794: `name: '大司命'` for slug `taiyi`).
-    // Key-matching alone then seats the descriptor as a ghost NEXT TO its own
-    // live row ("4 bots" in a 2-bot room), and anything that passes ghost
-    // identity onward targets a profile that does not exist on disk.
-    // Normalize first: a same-connection roster row whose friendly names
-    // include the descriptor's name IS this member. The next persistence
-    // pass (durableGroupChatMembers writes from the seated roster) rewrites
-    // the stored descriptor to the slug, so the repair is self-healing.
-    const resolved = resolveLegacyMemberDescriptor(descriptor, roster)
-    const key = botRosterKey(resolved)
-
-    if (seated.has(key)) {
-      continue
-    }
-
-    seated.add(key)
-    // A selected-but-offline ghost intentionally carries only enough identity
-    // to paint the roster. Never let it replace the room's durable descriptor,
-    // which owns the full handle/title used by mentions and remote sync.
-    remote.push((roster || []).find(bot => !bot?.ghost && botRosterKey(bot) === key) || resolved)
-  }
-
-  return [...local, ...remote]
-}
-
-/** A stored member descriptor, resolved against the live roster when its
- *  `name` is not a real slug (#92794). Exact key matches pass through
- *  untouched; only a descriptor whose key matches NO roster row is re-tried
- *  by friendly name against rows on the same connection. Unresolvable
- *  descriptors return as-is — they stay visible-but-degraded ghosts and must
- *  never be used as a `profile:` target. */
-function resolveLegacyMemberDescriptor(descriptor, roster) {
-  const rows = roster || []
-
-  if (rows.some(bot => botRosterKey(bot) === botRosterKey(descriptor))) {
-    return descriptor
-  }
-
-  const wanted = String(descriptor?.name || '').trim().toLowerCase()
-
-  if (!wanted) {
-    return descriptor
-  }
-
-  // Connection scope: a descriptor WITH a connectionId only matches rows on
-  // that connection (two `default`s on different machines must never merge).
-  // A descriptor WITHOUT one predates connection scoping entirely — those
-  // rooms only ever contained this machine's bots, so local (non-remote)
-  // rows are the legal candidate set.
-  const descriptorConnection = String(descriptor?.connectionId || '')
-  const candidates = rows.filter(bot => {
-    if (bot?.ghost) {
-      return false
-    }
-
-    return descriptorConnection
-      ? String(bot?.connectionId || '') === descriptorConnection
-      : !bot?.remoteSource
-  })
-  const match = candidates.find(
-    bot =>
-      // Case-drifted slug ('Testbot' persisted for profile 'testbot') …
-      String(bot?.name || '').trim().toLowerCase() === wanted ||
-      // … or a friendly name persisted as `name` ('大司命' for 'taiyi').
-      botFriendlyNames(bot).some(name => String(name || '').trim().toLowerCase() === wanted)
-  )
-
-  return match || descriptor
-}
-
-/** Persist source-qualified identities for every selected member. The active
- *  source's row may become remote after a connection switch, so retaining it
- *  here is what keeps the same room intact across machines. */
-function durableGroupChatMembers(bots) {
-  return (bots || []).map(bot => {
-    // Persistence pass over the whole seated roster: an orphaned member
-    // (connection deleted) keeps its identity and simply persists with no
-    // route — the same degraded shape the hydrate annotate produces. The
-    // strict throw here would lose the entire room update over one row.
-    const route = resolveBotConnectionRoute(bot).route
-    // Keep the friendly identity on the stored descriptor: after a
-    // connection switch the live roster row may be gone, and renamed-tag
-    // mentions must still resolve against the persisted member.
-    const title = String(botRosterMeta(bot, $botMeta.get())?.title || bot.ui_meta?.['hermes-bots']?.title || bot.title || '').trim()
-
-    return {
-      name: bot.name,
-      handle: bot.handle || bot.name,
-      ...(title ? { title } : {}),
-      ...(bot.display_name ? { display_name: bot.display_name } : {}),
-      connectionId: bot.connectionId,
-      connectionKind: bot.connectionKind,
-      connectionLabel: bot.connectionLabel,
-      ...(route ? { route, targetProfile: route.targetProfile } : {}),
-      // A swept/annotated member keeps its degraded mark across the rebuild —
-      // otherwise the next room send would silently un-mark an orphaned row.
-      ...(bot.sourceMissing ? { sourceMissing: true, sourceReachable: false } : {}),
-      remoteSource: true,
-      sourceScoped: Boolean(route)
-    }
-  })
-}
-
-/** Existing group names, alphabetical — feeds the Manage-groups dialog. */
-function knownGroups(metaByName) {
-  const names = new Set()
-
-  for (const meta of Object.values(metaByName || {})) {
-    for (const group of botGroups(meta)) {
-      names.add(group)
-    }
-  }
-
-  return [...names].sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }))
-}
-
-// ── group chats: bounded round-robin coordination over a shared room log ─────
-//
-// Behavioral model (clean-room): a group conversation is ONE ordered room log
-// owned by the plugin. A user send triggers at most GROUP_CHAT_MAX_ROUNDS
-// serial round-robin rounds over the member roster — never parallel, no LLM
-// router. Who speaks each round is a deterministic @mention parse since the
-// last user message (mentioned members only, else everyone); whether a member
-// actually speaks is its own turn's choice — replying with exactly "(pass)"
-// (or nothing, or failing) is silence. Hard caps end every turn; a round in
-// which everyone passed means the conversation settled. Each member runs its
-// turn in its OWN persistent per-group Hermes session and is fed only the
-// room messages that are NEW since it last saw the room.
-
-const GROUP_CHAT_MAX_ROUNDS = 3
-
-// #94478 review: continuation rounds are bounded independently of the message cap so a pathological mention chain can't consume the room's whole budget on handoffs.
-const GROUP_CHAT_MAX_MESSAGES = 10
-const GROUP_CHAT_MAX_CONTINUATIONS = 2
-const GROUP_CHAT_HISTORY_LIMIT = 24
-const GROUP_CHAT_MAX_MEMBERS = 6
-
-/** "(pass)" (loosely: pass / (pass) / pass.) or empty = the member stayed silent. */
-function isGroupPassText(text) {
-  const trimmed = String(text || '').trim()
-
-  if (!trimmed) {
-    return true
-  }
-
-  return /^\(?\s*pass\s*\)?\.?$/i.test(trimmed)
-}
-
-/** #94376: pick the reply a finished turn should surface among the messages
- *  appended since `before`. Scans newest-first and prefers the last
- *  substantive (non-pass) assistant answer over a trailing pass — a Codex
- *  intent-ack continuation nudge can land a complete answer and then get a
- *  synthetic "(pass)" to the nudge itself, which must not hide the answer.
- *  When only pass text exists in range, returns the newest (last
- *  chronological) one rather than the oldest. Returns null only when no
- *  assistant message appears in that range. */
-function pickGroupTurnReply(messages, before) {
-  let passText = null
-
-  for (let i = messages.length - 1; i >= before; i--) {
-    const msg = messages[i]
-
-    if (msg?.role !== 'assistant') {
-      continue
-    }
-
-    const text = typeof msg.content === 'string'
-      ? msg.content
-      : Array.isArray(msg.content)
-        ? msg.content.map(p => (typeof p === 'string' ? p : p?.text || '')).join('')
-        : msg?.text || ''
-    const replyText = String(text).trim()
-
-    if (isGroupPassText(replyText)) {
-      if (passText === null) {
-        passText = replyText
-      }
-      continue
-    }
-
-    return replyText
-  }
-
-  return passText
-}
-
-/** Deterministic @mention parse. Handles @name, @"two words" via display
- *  titles, and @everyone/@all. Names match case-insensitively against member
- *  profile names, display titles, and collapsed no-space forms. */
-function parseGroupChatMentions(text, members) {
-  const source = String(text || '')
-  const mentioned = new Set()
-  let everyone = false
-  const handles = new Map()
-
-  for (const member of members) {
-    const title = String(member.title || '').trim()
-    // Cross-connection members are also addressable by their @name-device
-    // handle (the roster's disambiguated form) — same-named agents on two
-    // machines resolve to the right one.
-    const handle = String(member.handle || botHandle(member.name, member) || '').trim()
-    const forms = new Set([
-      member.name.toLowerCase(),
-      member.name.toLowerCase().replace(/[\s_-]+/g, ''),
-      ...(handle ? [handle.toLowerCase(), handle.toLowerCase().replace(/[\s_-]+/g, '')] : []),
-      ...(title
-        ? [title.toLowerCase(), title.toLowerCase().replace(/[\s_-]+/g, ''), title.split(/\s+/)[0].toLowerCase()]
-        : [])
-    ])
-
-    // Renamed members answer to their friendly names too (profile
-    // display_name and Bot Mode title), in slugged and collapsed forms —
-    // the same tags the roster autocomplete inserts.
-    for (const friendly of botFriendlyNames(member)) {
-      for (const form of mentionNameForms(friendly)) {
-        forms.add(form)
-      }
-    }
-
-    for (const form of forms) {
-      if (form) {
-        handles.set(form, groupMemberKey(member))
-      }
-    }
-  }
-
-  for (const match of source.matchAll(/@([a-z0-9][a-z0-9._-]*)/gi)) {
-    const handle = match[1].toLowerCase()
-
-    if (handle === 'everyone' || handle === 'all') {
-      everyone = true
-      continue
-    }
-
-    if (handle === 'user') {
-      continue
-    }
-
-    const resolved = handles.get(handle) || handles.get(handle.replace(/[._-]+/g, ''))
-
-    if (resolved) {
-      mentioned.add(resolved)
-    }
-  }
-
-  return { everyone, mentioned }
-}
-
-/** Members that should take a turn this round: everyone when no member is
- *  @-mentioned in messages since the last user entry (or @everyone appears),
- *  otherwise only the mentioned members. Recomputed every round so a member
- *  pulled in mid-conversation joins the next round. */
-function resolveGroupResponders(log, members) {
-  let sinceLastUser = []
-
-  for (let i = log.length - 1; i >= 0; i--) {
-    if (log[i].from.kind === 'user') {
-      sinceLastUser = log.slice(i)
-      break
-    }
-  }
-
-  const mentioned = new Set()
-  let everyone = false
-
-  for (const entry of sinceLastUser) {
-    const parsed = parseGroupChatMentions(entry.text, members)
-
-    if (parsed.everyone) {
-      everyone = true
-    }
-
-    for (const name of parsed.mentioned) {
-      mentioned.add(name)
-    }
-  }
-
-  if (everyone || mentioned.size === 0) {
-    return members
-  }
-
-  return members.filter(member => mentioned.has(groupMemberKey(member)))
-}
-
-/** Rotate the roster so a different member leads each round. */
-function rotateGroupSpeakers(members, round) {
-  if (members.length < 2) {
-    return members
-  }
-
-  const shift = round % members.length
-
-  return [...members.slice(shift), ...members.slice(0, shift)]
-}
-
-/** Transcript form of a room speaker's profile name. Friendly identity wins:
- *  a Bot Mode title or a core profile display_name (e.g. default renamed to
- *  "Lucy") labels the speaker everywhere this helper feeds — the "X is
- *  thinking…" working line, the activity feed, and transcript lines — so a
- *  renamed bot never shows up as its raw profile id or a stale "Hermes"
- *  (community report, Aug 21 2026: renamed default still read "Hermes is
- *  thinking…" in group rooms). The untitled primary profile is literally
- *  named "default" — render it as Hermes (matching displayName and the
- *  @hermes handle) so the main agent never loses its name in rooms. */
-function groupSpeakerLabel(name) {
-  const trimmed = (name || '').trim()
-
-  if (!trimmed) {
-    return trimmed
-  }
-
-  // Bot Mode title (edit dialog) — same first rung as displayName().
-  const title = String($botMeta.get()?.[trimmed]?.title || '').trim()
-
-  if (title) {
-    return title
-  }
-
-  // Core profile display_name (`hermes profile rename …` / dashboard) from
-  // the ACTIVE gateway's roster row. Source-scoped remote speakers carry
-  // their device suffix separately and keep their raw name here.
-  const roster = $lastRoster.get()
-  const row = Array.isArray(roster)
-    ? roster.find(bot => bot?.name === trimmed && !bot?.remoteSource && !bot?.sourceScoped)
-    : null
-  const renamed = typeof row?.display_name === 'string' ? row.display_name.trim() : ''
-
-  if (renamed) {
-    return renamed
-  }
-
-  return trimmed.toLowerCase() === 'default' ? 'Hermes' : trimmed
-}
-
-/** Room-log line as a member sees it: `Name (user): …` / `Name: …` /
- *  `Name (you): …`. */
-function formatGroupChatLine(entry, viewerName) {
-  // Attachments are staged into each member's session as real payloads; the
-  // transcript line names them so the delta text and the bytes line up.
-  const attached = Array.isArray(entry.images) && entry.images.length
-    ? ` ${entry.images
-        .map(img => {
-          const label = img.kind === 'pdf' ? 'attached PDF' : img.kind === 'file' ? 'attached file' : 'attached image'
-          return `[${label}: ${img.name || 'image'}]`
-        })
-        .join(' ')}`
-    : ''
-
-  if (entry.from.kind === 'user') {
-    return `${entry.from.name || 'User'} (user): ${entry.text}${attached}`
-  }
-
-  const suffix = entry.from.name === viewerName ? ' (you)' : ''
-  // Cross-connection speakers carry their device so same-named agents on
-  // two machines stay tellable apart in every member's transcript.
-  const source = entry.from.source ? ` [${entry.from.source}]` : ''
-
-  return `${groupSpeakerLabel(entry.from.name)}${suffix}${source}: ${entry.text}${attached}`
-}
-
-/** The full per-turn payload for one member: participation rules + the room
- *  delta. Rules travel in the turn payload (not SOUL) so every existing bot
- *  can join a group chat without a profile migration. */
-function buildGroupChatTurnPrompt({ groupName, members, viewer, deltaLines }) {
-  const viewerKey = groupMemberKey(viewer)
-  const peers = members.filter(m => groupMemberKey(m) !== viewerKey)
-  const peerNames = peers
-    .map(m => {
-      const handle = m.title ? `${m.title} (@${botHandle(m.name, m)})` : `@${botHandle(m.name, m)}`
-      return m.remoteSource ? `${handle} [on ${m.connectionLabel || m.connectionId}]` : handle
-    })
-    .join(', ')
-
-  return [
-    `[Group chat: "${groupName}"] You are @${botHandle(viewer.name, viewer)}, one participant in a group chat with ${peerNames || 'no one else yet'} and the user.`,
-    '',
-    'New messages in the room since your last turn (oldest first):',
-    ...deltaLines.map(line => `  ${line}`),
-    '',
-    'Rules for this room:',
-    '- Reply with ONE conversational message ONLY if you have something new worth adding: build on what was just said, claim or hand off work, answer a question aimed at you, or report a real result. Keep chatter short (1-3 sentences) — but when you are delivering a result, an answer the user asked for, or substantive work, give it at full quality and length; never thin out real content to fit the room.',
-    '- If you have nothing new to add, reply with exactly "(pass)". Passing is good — it lets the conversation settle.',
-    '- Mention a teammate as @name to pull them in; mention @user only for a judgment call or a result the user needs. Do not repeat points already made.',
-    '- Never reveal content from your private 1:1 chats. Your reply text goes to the room verbatim — no preamble, no meta-commentary.'
-  ].join('\n')
-}
-
-/** Trim a room log + its watermarks to the retained window, keeping
- *  watermark indices consistent with the trimmed array. */
-function trimGroupChatLog(log, watermarks, limit = GROUP_CHAT_HISTORY_LIMIT * 4) {
-  if (log.length <= limit) {
-    return { log, watermarks }
-  }
-
-  const drop = log.length - limit
-  const trimmed = {}
-
-  for (const [name, index] of Object.entries(watermarks || {})) {
-    trimmed[name] = Math.max(0, index - drop)
-  }
-
-  return { log: log.slice(drop), watermarks: trimmed }
-}
-
-/** Mutate one group's room state through the atom + persist the durable part. */
-function updateGroupChat(group, mutate, { sync = true } = {}) {
-  const all = { ...$groupChats.get() }
-  const current = all[group] || { log: [], watermarks: {}, epoch: 0, running: false }
-  const next = mutate({ ...current, log: [...current.log], watermarks: { ...current.watermarks } })
-  const bounded = trimGroupChatLog(next.log, next.watermarks)
-
-  next.log = bounded.log
-  next.watermarks = bounded.watermarks
-  all[group] = next
-  $groupChats.set(all)
-
-  try {
-    const durable = {}
-
-    for (const [name, room] of Object.entries(all)) {
-      // Disband tombstones are runtime-only coordination state (they hold the
-      // epoch bump for an in-flight drive). Persisting one would resurrect
-      // the room as an empty record on the next load AND keep its name
-      // "taken" for same-name recreates.
-      if (room.tombstone) {
-        continue
-      }
-
-      durable[name] = {
-        log: room.log,
-        watermarks: room.watermarks,
-        sessions: room.sessions || {},
-        sessionOwners: room.sessionOwners || {},
-        // Timed-out turns awaiting a late reply — keyed by member, valued
-        // with the pre-turn message baseline. Survives reloads so finished
-        // work is still harvested after a window restart.
-        stranded: room.stranded || {},
-        // #93129: sticky per-member stop holds. Watermarks persist, so holds
-        // must too — otherwise a window restart silently releases a bot the
-        // user explicitly stopped.
-        holds: room.holds || {},
-        // Source-qualified member descriptors keep the room whole when the
-        // active connection changes and today's local members become remote.
-        members: Array.isArray(room.members) ? room.members : [],
-        // Immutable room identity: the member-session title for new rooms.
-        roomId: typeof room.roomId === 'string' && room.roomId ? room.roomId : null,
-        // Room picture (small data URL, same normalization as bot avatars).
-        image: room.image || null,
-        syncRevision: Math.max(0, Number(room.syncRevision || 0))
-      }
-    }
-
-    Promise.resolve(pluginCtx?.storage?.set?.('group-chats', durable)).catch(() => undefined)
-  } catch {
-    /* storage unavailable — room survives for this window only */
-  }
-  if (sync) {
-    scheduleGroupChatServerSync(all, { changedRooms: [group] })
-  }
-
-  return next
-}
-
-/** Soft-disband a group chat: remove only this group from every local member's
- *  membership list (the metadata syncs cross-machine via ui_meta), drop the
- *  room log from the atom + plugin storage, and close the room view if it's
- *  open. Other group memberships and the members' per-group gateway sessions
- *  ("Group: <roomId>", or legacy "Group: <name>") are intentionally KEPT. */
-async function disbandGroupChat(group, members) {
-  // Invalidate any in-flight round-robin FIRST: bump the epoch so a running
-  // drive bails at its next member boundary instead of appending to a room
-  // the user just discarded.
-  const all = { ...$groupChats.get() }
-  const prior = all[group] || {}
-  const metaBefore = $botMeta.get()
-  const cleanup = groupDisbandMetadataPlan(group, members, prior, $lastRoster.get(), metaBefore)
-  let metadataPersistence = Promise.resolve()
-
-  if (cleanup.patches.size) {
-    const nextMeta = { ...metaBefore }
-
-    for (const [key, patch] of cleanup.patches) {
-      nextMeta[key] = { ...(nextMeta[key] || {}), ...patch }
-      noteBotMetaWrite(key)
-    }
-
-    // Paint the deletion before any remote write can stall. This also removes
-    // orphaned legacy metadata that cannot safely be routed to a source.
-    $botMeta.set(nextMeta)
-    metadataPersistence = persistBotMetaSnapshot(
-      nextMeta,
-      botMetaV2Active || Object.keys(nextMeta).some(key => key.includes('::'))
-    )
-  }
-
-  delete all[group]
-  // Keep a runtime-only tombstone while a drive may still be mid-turn; it
-  // carries no log and is flagged so persistence and name-dedup skip it —
-  // updateGroupChat writes the WHOLE atom map, so an unflagged tombstone
-  // would be persisted by the next unrelated room write and its name would
-  // count as taken, suffixing a same-name recreate to "<name> 2" forever.
-  if (prior.running) {
-    all[group] = { log: [], watermarks: {}, sessions: {}, epoch: (prior.epoch || 0) + 1, running: false, tombstone: true }
-  }
-
-  $groupChats.set(all)
-
-  if ($groupChatWorkspace.get() === group) {
-    $groupChatWorkspace.set(null)
-  }
-
-  // Retire the room's MAIN-window tab too (host.openWorkspace path).
-  closeGroupChatMainTab(group)
-
-  const needs = { ...$groupNeedsYou.get() }
-
-  delete needs[group]
-  $groupNeedsYou.set(needs)
-  clearGroupClarify(group)
-
-  // Persist the room map WITHOUT the disbanded room so it can't come back
-  // on the next window load.
-  try {
-    const durable = {}
-
-    for (const [name, room] of Object.entries($groupChats.get())) {
-      if (name !== group && Array.isArray(room.log)) {
-        durable[name] = {
-          log: room.log,
-          watermarks: room.watermarks,
-          sessions: room.sessions || {},
-          sessionOwners: room.sessionOwners || {},
-          members: Array.isArray(room.members) ? room.members : [],
-          roomId: typeof room.roomId === 'string' && room.roomId ? room.roomId : null,
-          image: room.image || null,
-          syncRevision: Math.max(0, Number(room.syncRevision || 0))
-        }
-      }
-    }
-
-    await Promise.resolve(pluginCtx?.storage?.set?.('group-chats', durable))
-  } catch {
-    /* storage unavailable — the atom reset above still empties the room */
-  }
-  scheduleGroupChatServerSync($groupChats.get(), { allowEmpty: true, deletedRooms: [group] })
-  await metadataPersistence
-
-  // Persist the cleanup to every exact owner we can prove. saveBotMeta never
-  // throws (local storage + best-effort profiles.configure per owner), so a
-  // flaky gateway cannot strand the local disband halfway.
-  for (const [key, owner] of cleanup.owners) {
-    const patch = cleanup.patches.get(key)
-    if (patch) {
-      await saveBotMeta(owner, patch)
-    }
-  }
-
-  // Converge on server truth: the cached roster still carries the pre-disband
-  // ui_meta (the write-fence in mergeServerMeta keeps it from resurrecting
-  // the membership, but a fresh snapshot is what makes every surface agree).
-  if (typeof queryClient !== 'undefined' && queryClient?.invalidateQueries) {
-    queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-  }
-}
-
-/** Set or clear a group chat's room picture (small data URL, normalized by
- *  the same pipeline as bot avatars). Persists with the room record. */
-function setGroupChatImage(group, image) {
-  updateGroupChat(group, room => {
-    room.image = image || null
-    return room
-  })
-}
-
-/** Rename a group chat. The group's NAME is its identity everywhere — the
- *  room-map key, each local member's ui_meta membership list, and derived
- *  state — so a rename re-keys all of them. Member gateway sessions are kept
- *  as-is: stored sids keep resuming, so no history is lost. The room's
- *  immutable roomId (the member-session title) is preserved across the
- *  rename, so even a member whose sid is later lost falls back to the same
- *  "Group: <roomId>" title lookup instead of a fresh "Group: <new name>".
- *  Returns the new name, or null when the target name is taken. */
-async function renameGroupChat(oldName, newName, members) {
-  const next = String(newName || '').trim().slice(0, 64)
-
-  if (!next || next === oldName) {
-    return oldName
-  }
-
-  // Renames are explicit user intent: reject a collision honestly instead of
-  // silently suffixing like creation does. Disband tombstones don't hold
-  // their name — the room is gone, only its epoch survives briefly.
-  const taken = new Set(liveGroupChatNames())
-
-  for (const meta of Object.values($botMeta.get() || {})) {
-    for (const existing of botGroups(meta)) {
-      taken.add(existing)
-    }
-  }
-
-  taken.delete(oldName)
-
-  if (taken.has(next)) {
-    host.notify({ kind: 'error', message: `A group named “${next}” already exists.` })
-    return null
-  }
-
-  // Move the room record wholesale — log, watermarks, sessions, members,
-  // picture, and runtime flags all belong to the same room under its new name.
-  const all = { ...$groupChats.get() }
-  const room = all[oldName]
-
-  if (room) {
-    migrateGroupComposerDraft(groupComposerDraftKey(oldName, room), groupComposerDraftKey(next, room))
-  }
-
-  delete all[oldName]
-
-  if (room) {
-    all[next] = room
-  }
-
-  $groupChats.set(all)
-
-  const needs = { ...$groupNeedsYou.get() }
-
-  if (oldName in needs) {
-    needs[next] = needs[oldName]
-    delete needs[oldName]
-    $groupNeedsYou.set(needs)
-  }
-
-  // Mirrored clarify cards key by group name; drop the old room's — the
-  // next poll re-mirrors any still-blocking question under the new name.
-  clearGroupClarify(oldName)
-
-  // Local memberships: swap the name inside each member's canonical groups
-  // list (syncs cross-machine via ui_meta). Remote members' seating lives in
-  // the room record we just moved.
-  for (const member of members || []) {
-    if (!member?.name) {
-      continue
-    }
-
-    const meta = botRosterMeta(member, $botMeta.get()) || {}
-    const groups = [...new Set(botGroups(meta).map(g => (g === oldName ? next : g)))]
-
-    await saveBotMeta(member, { groups, group: groups[0] || null })
-  }
-
-  // Persist the re-keyed map (updateGroupChat writes the whole durable map).
-  updateGroupChat(next, r => r, { sync: false })
-  // A rename is one revisioned state transition: the new identity is updated
-  // and the old identity is tombstoned together, so cold hydration cannot
-  // merge the pre-rename room back into the roster.
-  scheduleGroupChatServerSync($groupChats.get(), {
-    changedRooms: [next],
-    deletedRooms: [oldName]
-  })
-
-  // Follow the open views to the new identity.
-  if ($groupChatWorkspace.get() === oldName) {
-    $groupChatWorkspace.set(next)
-  }
-
-  if (groupChatMainTabs.has(oldName)) {
-    closeGroupChatMainTab(oldName)
-    openGroupChat(next)
-  }
-
-  // Same convergence as disband: drop the pre-rename roster snapshot so the
-  // old name can't linger anywhere the fence doesn't cover.
-  if (typeof queryClient !== 'undefined' && queryClient?.invalidateQueries) {
-    queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-  }
-
-  return next
-}
-
-function groupChatEntryId() {
-  if (globalThis.crypto && typeof globalThis.crypto.randomUUID === 'function') {
-    return globalThis.crypto.randomUUID()
-  }
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`
-}
-
-/** The agent loop's "(empty)" terminal sentinel (empty_response_exhausted) is
- *  a FAILURE marker, never bot text. Mirror gateway/run.py's user-friendly
- *  substitution so the room log never shows the raw sentinel. */
-const GROUP_EMPTY_SENTINEL = '(empty)'
-const GROUP_EMPTY_FRIENDLY =
-  '⚠️ The model returned no response after processing tool results. ' +
-  'This can happen with some models — try again or rephrase your question.'
-function normalizeGroupChatText(text) {
-  const trimmed = String(text || '').trim()
-  return trimmed === GROUP_EMPTY_SENTINEL ? GROUP_EMPTY_FRIENDLY : trimmed
-}
-
-function appendGroupChatEntry(group, from, text, thread, images) {
-  const entry = {
-    id: groupChatEntryId(),
-    at: Date.now(),
-    from,
-    text: normalizeGroupChatText(text),
-    thread: thread || 'legacy'
-  }
-
-  if (Array.isArray(images) && images.length) {
-    // [{ name, data }] — data URLs. Persisted with the room log so reloads
-    // keep showing what the members were shown.
-    entry.images = images
-  }
-
-  // #93127 insurance: a residual double-append path (stale loop + fresh
-  // loop both committing the same member reply) lands back-to-back and
-  // byte-identical. Drop the echo instead of flooding the room. User
-  // entries and non-adjacent repeats are never touched.
-  const priorLog = ($groupChats.get()[group] || {}).log || []
-  const lastEntry = priorLog[priorLog.length - 1]
-
-  if (isDuplicateGroupAppend(lastEntry, from, entry.text, entry.thread)) {
-    return lastEntry
-  }
-
-  updateGroupChat(group, room => {
-    room.log.push(entry)
-    return room
-  })
-
-  // Needs-you: a member addressing @user badges the group header.
-  if (from.kind === 'member' && /@user\b/i.test(entry.text)) {
-    $groupNeedsYou.set({ ...$groupNeedsYou.get(), [group]: true })
-  }
-
-  return entry
-}
-
-/** Fresh room identity for a group. Independent of the editable display
- *  name: a disbanded-and-recreated group mints a new roomId even when the
- *  display name is identical, so member sessions never resume by title. */
-function mintGroupRoomId() {
-  return `r${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`
-}
-
-/** Unique display name for a NEW group. Collisions get a " 2", " 3", …
- *  suffix; the BASE is truncated (never the joined string), so a 64-char
- *  base keeps its suffix instead of colliding with the original. */
-function uniqueGroupChatName(base, taken) {
-  if (!taken.has(base)) {
-    return base
-  }
-
-  for (let n = 2; n < 100; n++) {
-    const suffix = ` ${n}`
-    const candidate = base.slice(0, 64 - suffix.length) + suffix
-
-    if (!taken.has(candidate)) {
-      return candidate
-    }
-  }
-
-  throw new Error('No free name for the group.')
-}
-
-/** Ensure the member's per-group session exists and return a LIVE runtime
- *  session id for it. Gateway-native: session.create mints the session
- *  (lazy until its first message), session.resume by stored id — or by
- *  title, which also covers rehydrated rooms whose sid was lost — reopens
- *  it after restarts. Cross-connection members route to their OWN source
- *  via requestForBot; the window's gateway never switches. */
-async function ensureGroupChatSession(group, member) {
-  const room = $groupChats.get()[group] || {}
-  // New rooms title member sessions by their immutable roomId so a
-  // same-name recreate never resumes the old room's sessions by title;
-  // legacy rooms without a roomId fall back to the display name.
-  const title = `Group: ${room.roomId || group}`
-  const key = groupMemberKey(member)
-  const known = room.sessions && room.sessions[key]
-
-  // Try resuming what we know (stored sid first, then title lookup).
-  //
-  // FAIL CLOSED on a transient lookup failure — mirrors the sibling fix in
-  // findExistingCanonicalChat (87b645f52c). session.resume signals "this
-  // target genuinely doesn't exist" with JSON-RPC code 4007; every other
-  // failure (network blip, the backend still warming up after a restart,
-  // an oversized-resume refusal) means the real session might still be
-  // there and must not be read as "no session, mint a new one" — that
-  // forks the member's real history, and the fork silently overwrites
-  // room.sessions[key] so the old session becomes unreachable from the
-  // room. Only a genuine 4007 on BOTH targets means there truly is nothing
-  // to resume yet, so the loop falls through to session.create below.
-  for (const target of [known, title]) {
-    if (!target || target === true) {
-      continue
-    }
-
-    try {
-      const res = await requestForBot(member, 'session.resume', {
-        session_id: target,
-        profile: member.name,
-        omit_messages: true
-      })
-
-      if (res?.session_id) {
-        const stored = res.session_key || known
-
-        if (stored) {
-          updateGroupChat(group, current => {
-            current.sessions = { ...(current.sessions || {}), [key]: stored }
-            current.sessionOwners = { ...(current.sessionOwners || {}), [key]: groupSessionOwner(member) }
-            return current
-          })
-        }
-
-        return { runtime: res.session_id, stored }
-      }
-    } catch (error) {
-      if (error?.code !== 4007) {
-        const detail = error instanceof Error && error.message ? ` (${error.message})` : ''
-        throw new Error(`Could not check ${member?.name || 'member'}'s group session${detail} — not starting a new one`)
-      }
-      /* genuinely doesn't exist (4007) — try the next target / fall through to create */
-    }
-  }
-
-  const created = await requestForBot(member, 'session.create', {
-    profile: member.name,
-    title,
-    // Room member sessions are plumbing — always hidden from the sidebar.
-    hidden: true,
-    // Explicit contract: this session's runtime always follows the member
-    // profile's CURRENT config. Resume must NOT restore the stored
-    // model/provider pin from an old row (that left room bots stuck on a
-    // stale provider — e.g. "out of Nous credits" — after a profile switch).
-    room_plumbing: true,
-    // Same follow-profile-config contract as the canonical Bot Chat: a room
-    // member's runtime always follows the member profile's CURRENT config,
-    // never a stale stored model/provider pin from an old row.
-    follow_profile_config: true
-  })
-  const stored = created?.stored_session_id || null
-
-  if (stored) {
-    updateGroupChat(group, r => {
-      r.sessions = { ...(r.sessions || {}), [key]: stored }
-      r.sessionOwners = { ...(r.sessionOwners || {}), [key]: groupSessionOwner(member) }
-      return r
-    })
-  }
-
-  return { runtime: created?.session_id || null, stored }
-}
-
-const GROUP_TURN_TIMEOUT_MS = 180000
-const GROUP_TURN_POLL_MS = 2000
-
-// --- group-turn session-lease helpers (#93602) ------------------------------
-// A member turn is a session-scoped RPC SEQUENCE (resume → attach → submit →
-// poll) issued with the runtime id its first RPC minted. requestForBot routes
-// each RPC through a per-request socket lease (retained:false secondaries in
-// store/gateway), so between two RPCs the refcount can hit 0, the leased
-// socket closes, the gateway detaches the runtime session on WS disconnect,
-// and the orphan reaper frees it — the next RPC then fails 4001 "not in
-// memory" and the bot goes silent in the room.
-
-/** 4001-class "the runtime session was reaped" failure. Distinct from 4007
- *  ("genuinely never existed"), which must keep flowing to session.create. */
-function isSessionGoneError(error) {
-  if (!error || error.code === 4007) {
-    return false
-  }
-
-  if (error.code === 4001) {
-    return true
-  }
-
-  // Duck-typed (not instanceof): gateway errors can cross realm boundaries.
-  const message = typeof error?.message === 'string' ? error.message : typeof error === 'string' ? error : ''
-
-  return message.includes('not in memory') || /session not found/i.test(message)
-}
-// --- end group-turn session-lease helpers ---
-
-/** Hold the member's pooled socket open for the WHOLE turn. Feature-detected:
- *  hosts without retainProfile (or members on the active gateway, which never
- *  closes mid-turn) get a no-op release. A failed acquire must not kill the
- *  turn — the catch-retry on submit still covers the race. */
-async function retainGroupTurnRoute(member) {
-  const noop = () => undefined
-
-  let route = null
-
-  try {
-    route = botConnectionRoute(member)
-  } catch {
-    return noop
-  }
-
-  if (!route || typeof host.retainProfile !== 'function') {
-    return noop
-  }
-
-  try {
-    const release = await host.retainProfile(route)
-
-    return typeof release === 'function' ? release : noop
-  } catch {
-    return noop
-  }
-}
-
-/** prompt.submit with one belt-and-braces retry: when the runtime session was
- *  reaped between minting and submitting (4001 class), re-resume via the
- *  STORED id — the durable identity — to mint a fresh runtime id, and submit
- *  exactly once more. Returns the runtime id the submit actually landed on so
- *  the poll loop keeps a live fallback target. */
-async function submitGroupTurnPrompt(member, runtime, stored, text) {
-  try {
-    await requestForBot(member, 'prompt.submit', { session_id: runtime, text })
-
-    return runtime
-  } catch (error) {
-    if (!isSessionGoneError(error) || !stored) {
-      throw error
-    }
-
-    const res = await requestForBot(member, 'session.resume', {
-      session_id: stored,
-      profile: member.name,
-      omit_messages: true
-    })
-    const fresh = res?.session_id
-
-    if (!fresh) {
-      throw error
-    }
-
-    await requestForBot(member, 'prompt.submit', { session_id: fresh, text })
-
-    return fresh
-  }
-}
-
-// A member turn that is VISIBLY still working (session reports
-// inflight/running) keeps its slot alive up to this hard cap. The base
-// timeout alone silently dropped long real turns: a 7-minute research run
-// timed out at 3 minutes, read as a pass, and its finished result never
-// reached the room (db's Aug 2026 report).
-const GROUP_TURN_HARD_CAP_MS = 20 * 60000
-
-/** Mirror a member's pending prompt — clarify question OR command approval —
- *  from its resume snapshot into the room store, keyed
- *  `${group}::${memberKey}` (#90694). Returns true while a prompt is
- *  blocking, so the turn poll can extend its deadline — a waiting prompt
- *  must not be eaten by the group-turn timeout. Feature-detected: older
- *  backends without `pending_clarify`/`pending_approval` in the resume
- *  payload always sync to "no prompt". Clarify wins when both are somehow
- *  present (approvals resolve inside tool batches; clarify is the outer
- *  blocker). */
-function syncGroupClarify(group, member, state) {
-  const key = `${group}::${groupMemberKey(member)}`
-  const clarify = state && typeof state.pending_clarify === 'object' ? state.pending_clarify : null
-  const approval = state && typeof state.pending_approval === 'object' ? state.pending_approval : null
-  const pending = clarify || approval
-  const requestId = pending?.request_id || null
-  const all = $groupClarify.get()
-  const current = all[key]
-
-  if (!requestId) {
-    if (current) {
-      const next = { ...all }
-      delete next[key]
-      $groupClarify.set(next)
-    }
-
-    return false
-  }
-
-  // Same request already mirrored — keep the object identity so the card
-  // doesn't lose its draft to a re-render.
-  if (current?.requestId === requestId) {
-    return true
-  }
-
-  const base = {
-    requestId,
-    group,
-    member: member.name,
-    memberKey: groupMemberKey(member),
-    // approval.respond keys on the session, not just the request — carry the
-    // runtime id the snapshot came from.
-    sessionId: state?.session_id || null,
-    at: Date.now()
-  }
-
-  $groupClarify.set({
-    ...all,
-    [key]: clarify
-      ? {
-          ...base,
-          kind: 'clarify',
-          question: typeof clarify.question === 'string' ? clarify.question : '',
-          choices: Array.isArray(clarify.choices) ? clarify.choices.filter(c => typeof c === 'string' && c) : [],
-          multiSelect: Boolean(clarify.multi_select),
-          // Batch clarifies carry `questions`; the room card answers them
-          // one wire call per question, mirroring the 1:1 batch contract.
-          questions: Array.isArray(clarify.questions) ? clarify.questions : null
-        }
-      : {
-          ...base,
-          kind: 'approval',
-          question: typeof approval.description === 'string' ? approval.description : '',
-          command: typeof approval.command === 'string' ? approval.command : '',
-          // The server precomputes the choice set from allow_permanent
-          // (once/session/always/deny); fall back to the minimal pair.
-          choices: Array.isArray(approval.choices) && approval.choices.length
-            ? approval.choices.filter(c => typeof c === 'string' && c)
-            : ['once', 'deny'],
-          multiSelect: false,
-          questions: null
-        }
-  })
-  // A blocked member is a question for the human — badge the room.
-  $groupNeedsYou.set({ ...$groupNeedsYou.get(), [group]: true })
-
-  return true
-}
-
-/** Drop every mirrored clarify belonging to `group` (disband/rename). */
-function clearGroupClarify(group) {
-  const all = $groupClarify.get()
-  const next = {}
-  let changed = false
-
-  for (const [key, value] of Object.entries(all)) {
-    if (value?.group === group) {
-      changed = true
-    } else {
-      next[key] = value
-    }
-  }
-
-  if (changed) {
-    $groupClarify.set(next)
-  }
-}
-
-/** Answer a member's pending prompt from the room. Routes to the member's
- *  OWN source (requestForBot), so cross-connection members work.
- *  - clarify: `clarify.respond`; batch questions send one respond per
- *    question, sequentially — the LAST lock resolves the blocked tool
- *    server-side (same contract as the 1:1 batch card). allow_expired
- *    server-side makes racing the timeout harmless.
- *  - approval: `approval.respond` with the choice (once/session/always/deny),
- *    keyed by session + request_id — the same wire the 1:1 approval card
- *    and native notifications use. */
-async function answerGroupClarify(entry, member, answers) {
-  if (entry.kind === 'approval') {
-    await requestForBot(member, 'approval.respond', {
-      session_id: entry.sessionId || undefined,
-      request_id: entry.requestId,
-      choice: typeof answers === 'string' && answers ? answers : 'deny'
-    })
-  } else if (entry.questions && entry.questions.length) {
-    for (const question of entry.questions) {
-      const qid = question?.qid ?? question?.id
-      await requestForBot(member, 'clarify.respond', {
-        request_id: entry.requestId,
-        question_id: qid,
-        answer: answers?.[qid] ?? ''
-      })
-    }
-  } else {
-    await requestForBot(member, 'clarify.respond', {
-      request_id: entry.requestId,
-      answer: typeof answers === 'string' ? answers : ''
-    })
-  }
-
-  const all = $groupClarify.get()
-  const key = `${entry.group}::${entry.memberKey}`
-
-  if (all[key]?.requestId === entry.requestId) {
-    const next = { ...all }
-    delete next[key]
-    $groupClarify.set(next)
-  }
-}
-
-/** One member turn, gateway-native: submit the room delta as a prompt into
- *  the member's per-group session, then poll the session until a NEW
- *  assistant message lands (or timeout → pass). While the session visibly
- *  reports work in flight the deadline extends (bounded by the hard cap),
- *  so slow models aren't cut off mid-run. A turn that still times out
- *  records a stranded marker so the finished reply can be harvested into
- *  the room at the member's next turn instead of being lost. */
-async function runGroupChatMemberTurn(group, member, prompt, thread, images) {
-  // #93602: hold the member's route socket for the whole turn. Without the
-  // lease, every RPC below rides its own request-scoped socket lease; the
-  // socket that minted `runtime` can close between RPCs, the gateway reaps
-  // the runtime session, and prompt.submit dies 4001 — the bot goes silent.
-  const releaseTurnLease = await retainGroupTurnRoute(member)
-
-  try {
-    return await runGroupChatMemberTurnLeased(group, member, prompt, thread, images)
-  } finally {
-    releaseTurnLease()
-  }
-}
-
-async function runGroupChatMemberTurnLeased(group, member, prompt, thread, images) {
-  const { runtime, stored } = await ensureGroupChatSession(group, member)
-
-  if (!runtime) {
-    return null
-  }
-
-  // #91868/#94569: remember the epoch this turn was dispatched under so the
-  // poll loop below can tell an explicit stop from ordinary room churn.
-  const dispatchEpoch = ($groupChats.get()[group] || {}).epoch || 0
-  const memberKey = groupMemberKey(member)
-
-  recordGroupActivity(group, { kind: 'working', member: member.name, thread })
-
-  // Baseline: how many messages exist before our submit.
-  let before = 0
-
-  try {
-    const pre = await requestForBot(member, 'session.resume', {
-      session_id: stored || runtime,
-      profile: member.name
-    })
-    before = Array.isArray(pre?.messages) ? pre.messages.length : pre?.message_count || 0
-  } catch {
-    /* lazy session — zero messages */
-  }
-
-  // Stage this delta's attachments into the member's session so the model
-  // receives the actual payload with the prompt — the same attach RPCs the
-  // 1:1 chat uses (they also work cross-connection, where the member's
-  // gateway can't see this machine's files). Images queue as vision tiles,
-  // PDFs render per-page via pdf.attach, and other files materialize in the
-  // session workspace (their @file: refs are appended to the prompt so the
-  // member's file tools can read them). A failed attach degrades that
-  // member to text-only; the transcript line still names the attachment so
-  // the member knows something was shared.
-  const fileRefs = []
-
-  for (const img of Array.isArray(images) ? images : []) {
-    if (!img || typeof img.data !== 'string' || !img.data) {
-      continue
-    }
-
-    try {
-      if (img.kind === 'pdf') {
-        await requestForBot(member, 'pdf.attach', {
-          session_id: runtime,
-          content_base64: img.data,
-          filename: img.name || 'attachment.pdf'
-        })
-      } else if (img.kind === 'file') {
-        const res = await requestForBot(member, 'file.attach', {
-          session_id: runtime,
-          data_url: img.data,
-          name: img.name || 'attachment'
-        })
-
-        if (res?.ref_text) {
-          fileRefs.push(`${img.name || 'attachment'} → ${res.ref_text}`)
-        }
-      } else {
-        await requestForBot(member, 'image.attach_bytes', {
-          session_id: runtime,
-          content_base64: img.data,
-          filename: img.name || 'attachment.png'
-        })
-      }
-    } catch {
-      /* text-only fallback for this member */
-    }
-  }
-
-  const turnText = fileRefs.length
-    ? `${prompt}\n\nAttached files staged in your session workspace:\n${fileRefs.join('\n')}`
-    : prompt
-
-  // #93602: one-shot recovery when the runtime session was reaped between
-  // minting and submitting. Tracks the runtime id the submit landed on so
-  // the poll fallback below targets a live session.
-  const liveRuntime = await submitGroupTurnPrompt(member, runtime, stored, turnText)
-
-  const started = Date.now()
-  let deadline = started + GROUP_TURN_TIMEOUT_MS
-
-  while (Date.now() < deadline) {
-    await new Promise(resolve => setTimeout(resolve, GROUP_TURN_POLL_MS))
-
-    // #91868/#94569: an explicit stop (stopGroupThread) bumped the epoch AND
-    // held this member — the member's session was interrupted, so nothing is
-    // coming; abandon the poll instead of grinding until the deadline. Both
-    // conditions on purpose: an ordinary newer send bumps the epoch WITHOUT
-    // a hold, and that turn must keep polling so finished work can still be
-    // delivered (the #93127 commit check decides its fate, not this loop).
-    const roomDuringPoll = $groupChats.get()[group] || {}
-
-    if ((roomDuringPoll.epoch || 0) !== dispatchEpoch && (roomDuringPoll.holds || {})[memberKey]) {
-      return null
-    }
-
-    let state = null
-
-    try {
-      state = await requestForBot(member, 'session.resume', {
-        session_id: stored || liveRuntime,
-        profile: member.name
-      })
-    } catch {
-      continue
-    }
-
-    const messages = Array.isArray(state?.messages) ? state.messages : []
-    const busy = Boolean(state?.inflight || state?.running)
-    // A clarify blocking inside the member's session is a question for the
-    // HUMAN (#90694) — mirror it into the room store so a card renders, and
-    // hold the turn open: the member isn't stalling, it's waiting on us.
-    const awaitingUser = syncGroupClarify(group, member, state)
-    const done = !busy && !awaitingUser
-
-    if (messages.length > before && done) {
-      const replyText = pickGroupTurnReply(messages, before)
-
-      if (replyText !== null) {
-        recordGroupActivity(group, {
-          kind: isGroupPassText(replyText) ? 'passed' : 'replied',
-          member: member.name,
-          thread
-        })
-
-        return replyText
-      }
-
-      recordGroupActivity(group, { kind: 'passed', member: member.name, thread })
-
-      return null
-    }
-
-    // Still visibly working — or waiting on the user's answer to a clarify:
-    // extend the deadline (never past the hard cap). A pending question must
-    // outlive the base turn timeout or it dies unanswered at 3 minutes.
-    if (busy || awaitingUser) {
-      deadline = Math.min(started + GROUP_TURN_HARD_CAP_MS, Math.max(deadline, Date.now() + GROUP_TURN_TIMEOUT_MS))
-    }
-  }
-
-  // Timeout — clear any still-mirrored question card (the server-side
-  // clarify timeout runs its own course) and read as a pass, but remember the baseline + thread
-  // (runtime-only) so the finished reply can be posted late into the RIGHT
-  // thread instead of vanishing.
-  recordGroupActivity(group, { kind: 'timed-out', member: member.name, thread })
-  syncGroupClarify(group, member, null)
-  updateGroupChat(group, r => {
-    r.stranded = { ...(r.stranded || {}), [groupMemberKey(member)]: { before, thread } }
-    return r
-  })
-
-  return null
-}
-
-/** Post a timed-out member's finished reply into the room, if it landed
- *  after we stopped waiting. Called at the member's next turn boundary and
- *  on user sends, so long-running work is delivered late rather than lost. */
-async function harvestStrandedGroupReply(group, member) {
-  const memberKey = groupMemberKey(member)
-  const room = $groupChats.get()[group] || {}
-  const marker = room.stranded?.[memberKey]
-  // Markers were a bare number before threads; normalize both shapes.
-  const strandedBefore = typeof marker === 'number' ? marker : marker?.before
-  const strandedThread = (typeof marker === 'object' && marker?.thread) || 'legacy'
-
-  if (typeof strandedBefore !== 'number') {
-    return
-  }
-
-  let state = null
-
-  try {
-    const stored = room.sessions?.[memberKey]
-    state = await requestForBot(member, 'session.resume', {
-      session_id: stored || `Group: ${room.roomId || group}`,
-      profile: member.name
-    })
-  } catch {
-    return // source unreachable — leave the marker for the next boundary
-  }
-
-  if (state?.inflight || state?.running) {
-    return // still grinding — keep waiting
-  }
-
-  // A stranded member blocked on a clarify is not "grinding" — surface the
-  // question card (#90694) and keep the marker until it resolves.
-  if (syncGroupClarify(group, member, state)) {
-    return
-  }
-
-  // Done (or dead): the marker is consumed either way.
-  updateGroupChat(group, r => {
-    const next = { ...(r.stranded || {}) }
-    delete next[memberKey]
-    r.stranded = next
-    return r
-  })
-
-  const messages = Array.isArray(state?.messages) ? state.messages : []
-
-  if (messages.length <= strandedBefore) {
-    return
-  }
-
-  const reply = pickGroupTurnReply(messages, strandedBefore)
-
-  if (reply && !isGroupPassText(reply)) {
-    recordGroupActivity(group, { kind: 'delivered', member: member.name, thread: strandedThread })
-    appendGroupChatEntry(
-      group,
-      { kind: 'member', name: member.name, ...(member.remoteSource ? { source: member.connectionLabel || member.connectionId } : {}) },
-      reply,
-      strandedThread
-    )
-    updateGroupChat(group, r => {
-      r.watermarks[`${strandedThread}::${memberKey}`] = r.log.length
-      return r
-    })
-  }
-}
-
-// --- room-turn decision helpers (#93127) — pure, vm-sliced by tests ---
-
-/** #93127: whether a finished member turn may still commit (append its reply
- *  and advance its watermark). A turn dispatched under an older epoch was
- *  superseded mid-flight by a newer user send — its late result must be
- *  dropped, because the new send's own loop re-drives this member with the
- *  full delta and committing both is exactly the double-delivery bug.
- *
- *  The re-drive premise is only true for a send in the SAME thread (delta
- *  filters are thread-scoped): a cross-thread epoch bump must NOT discard
- *  finished work no fresh loop will regenerate. Callers pass whether a newer
- *  USER entry landed in this thread since dispatch; the default (true)
- *  preserves the conservative drop when the caller can't tell. */
-function shouldCommitMemberTurn(epochAtDispatch, currentEpoch, newerUserEntryInThread = true) {
-  if (epochAtDispatch === currentEpoch) {
-    return true
-  }
-
-  return !newerUserEntryInThread
-}
-
-/** #93127 insurance: byte-identical member echo detection. TRUE only when
- *  the immediately-preceding log entry has the same author (kind + name +
- *  source), same thread, and identical text, within a short recency window —
- *  a residual double-append fires back-to-back; two legitimately identical
- *  replies hours apart (or with anything in between) are never dropped. */
-const GROUP_DUPLICATE_APPEND_WINDOW_MS = 10 * 60 * 1000
-
-function isDuplicateGroupAppend(lastEntry, from, text, thread, now = Date.now()) {
-  if (!lastEntry || !from || from.kind !== 'member' || lastEntry.from?.kind !== 'member') {
-    return false
-  }
-
-  if (String(lastEntry.from?.name || '') !== String(from.name || '')) {
-    return false
-  }
-
-  if (String(lastEntry.from?.source || '') !== String(from.source || '')) {
-    return false
-  }
-
-  if (String(lastEntry.thread || 'legacy') !== String(thread || 'legacy')) {
-    return false
-  }
-
-  if (now - (lastEntry.at || 0) > GROUP_DUPLICATE_APPEND_WINDOW_MS) {
-    return false
-  }
-
-  return String(lastEntry.text || '') === String(text || '').trim()
-}
-
-// --- end room-turn decision helpers ---
-
-// --- member-hold helpers (#93129) — pure, vm-sliced by tests ---
-
-/** #93129: classify a USER room message's effect on member holds. Only user
- *  sends ever reach this (bot replies are appended by the round loop, never
- *  through sendToGroupChat), so a bot saying "stopped working on it" can
- *  never set a hold. Conservative on purpose: any standalone stop/halt/pause
- *  word next to a mention holds those members — "don't stop @x" therefore
- *  also holds, which errs toward the bot staying quiet until re-addressed
- *  (a wrongly-held bot is one mention away from release; a wrongly-running
- *  one keeps doing work it was told to stop). A non-stop direct mention
- *  releases the mentioned members — the user addressing a bot directly
- *  overrides its hold. */
-function classifyGroupHoldDirective(text, mentionedKeys, everyone) {
-  const value = String(text || '')
-  const mentioned = [...(mentionedKeys || [])]
-  const stop = /\b(stop|halt|pause)\b/i.test(value)
-  const resume = /\b(resume|continue|go|proceed)\b/i.test(value)
-
-  if (stop) {
-    // "@all stop" holds every member — symmetric with "@all resume".
-    return { hold: mentioned, holdAll: Boolean(everyone), release: [], releaseAll: false }
-  }
-
-  if (resume) {
-    return { hold: [], holdAll: false, release: mentioned, releaseAll: Boolean(everyone) }
-  }
-
-  return { hold: [], holdAll: false, release: mentioned, releaseAll: false }
-}
-
-/** #93129: next holds map after one user message. Holds are keyed by
- *  memberKey at ROOM scope (not thread scope): every main-composer send
- *  mints a NEW thread, so a thread-scoped hold would never block the next
- *  send's turns and the stop would not stick. Returns the same object when
- *  nothing changed. */
-function applyGroupHoldDirective(holds, mentions, text, stamp, allMemberKeys = []) {
-  const prior = holds && typeof holds === 'object' ? holds : {}
-  const action = classifyGroupHoldDirective(text, mentions?.mentioned || [], Boolean(mentions?.everyone))
-
-  if (action.releaseAll) {
-    return Object.keys(prior).length ? {} : prior
-  }
-
-  // "@all stop": expand to every member key the caller knows about.
-  const toHold = action.holdAll ? [...allMemberKeys] : action.hold
-
-  let next = prior
-
-  for (const key of toHold) {
-    if (next === prior) {
-      next = { ...prior }
-    }
-
-    next[key] = { at: stamp?.at || Date.now(), byMessageId: stamp?.byMessageId || null, thread: stamp?.thread || null }
-  }
-
-  for (const key of action.release) {
-    if (Object.prototype.hasOwnProperty.call(next, key)) {
-      if (next === prior) {
-        next = { ...prior }
-      }
-
-      delete next[key]
-    }
-  }
-
-  return next
-}
-
-/** #93129: a held member's skip must consume its delta exactly once —
- *  advance the watermark past the current log so the same entries never
- *  re-trigger the skip. Null = nothing to consume (no write, no spin). */
-function heldMemberWatermarkAdvance(seen, logLength) {
-  return logLength > (seen || 0) ? logLength : null
-}
-
-// --- end member-hold helpers ---
-
-/** Members cited by @mention in a thread who have not posted any entry after
- *  the citing one — the unresolved-handoff detector for #94478. A mention
- *  inside a member reply is visible to the NEXT round's responder selection,
- *  but the round loop exits first when nobody has new delta to read
- *  (`spokeThisRound === 0`) or a cap lands, so the room settles while a
- *  called bot never answers. Returns member keys still owed a turn. */
-function unaddressedGroupMentions(group, members, thread) {
-  const room = $groupChats.get()[group] || { log: [] }
-  const log = (room.log || []).filter(e => groupThreadOf(e) === thread)
-
-  // key → log INDEX of the entry that most recently cited this member.
-  // Entry ids are UUIDs (groupChatEntryId), NOT monotonic — index order is
-  // the only guaranteed ordering, and it is what "answered after the citing
-  // entry" actually means. (#94478 review)
-  const citedAt = new Map()
-
-  for (const entry of log) {
-    const parsed = parseGroupChatMentions(entry.text || '', members)
-
-    // A user send re-drives everyone anyway; only member-to-member handoffs
-    // can strand here.
-    if (entry.from.kind !== 'member') {
-      continue
-    }
-
-    for (const key of parsed.mentioned) {
-      const citingMemberKey = (() => {
-        const m = members.find(mm => mm.name === entry.from?.name)
-
-        return m ? groupMemberKey(m) : null
-      })()
-
-      // Never count a bot citing itself as a pending handoff.
-      if (citingMemberKey && citingMemberKey !== key) {
-        citedAt.set(key, log.indexOf(entry))
-      }
-    }
-  }
-
-  // A citation is answered when the cited member posts any entry after the
-  // citing one (its turn, whatever the content).
-  const lastPostAt = new Map()
-
-  for (const entry of log) {
-    if (entry.from.kind !== 'member') {
-      continue
-    }
-
-    const speakerKey = (() => {
-      const m = members.find(mm => mm.name === entry.from?.name)
-
-      return m ? groupMemberKey(m) : null
-    })()
-
-    if (speakerKey) {
-      lastPostAt.set(speakerKey, log.indexOf(entry))
-    }
-  }
-
-  return [...citedAt.keys()].filter(key => {
-    const citedIdx = citedAt.get(key)
-    const answeredIdx = lastPostAt.get(key)
-
-    return answeredIdx === undefined || answeredIdx <= citedIdx
-  })
-}
-
-/** #91868/#94569: the REAL stop path for a group round. The round loop's only
- *  cancellation primitives were the epoch bump (checked at member boundaries)
- *  and #93129 holds (skip FUTURE turns) — neither touches the member whose
- *  model call is in flight RIGHT NOW, so "stop" meant "finish this turn
- *  first". This primitive does all three legs atomically enough to matter:
- *
- *  1. Bumps the room epoch — the driving loop bails at its next boundary and
- *     never selects another member (`isCurrent()` in runGroupChatRounds).
- *  2. Sets a #93129 hold for EVERY member — future turns stay skipped until
- *     the user explicitly releases (resume / @all resume / direct mention),
- *     the exact contract user-typed "@all stop" already has.
- *  3. Sends session.interrupt to the member currently ON TURN (room.turn,
- *     runtime-only) via its own route, so the in-flight model call actually
- *     dies instead of grinding to completion in the background. Best-effort:
- *     an unreachable member still leaves the room stopped — the poll loop's
- *     staleness check (epoch moved AND member held) abandons the turn.
- *
- *  `members` is the live roster when the caller has one (the workspace);
- *  falls back to the room's durable roster so a two-arg call still works. */
-async function stopGroupThread(group, thread, members = null) {
-  const room = $groupChats.get()[group] || {}
-  const roster = Array.isArray(members) && members.length ? members : room.members || []
-  const turnName = room.turn || null
-  const stamp = { at: Date.now(), byMessageId: null, thread: thread || null }
-
-  updateGroupChat(group, r => {
-    r.epoch = (r.epoch || 0) + 1
-    r.running = false
-    r.turn = null
-
-    // Same hold shape applyGroupHoldDirective mints for "@all stop" — the
-    // held-skip path (watermark consume + 'held' activity note) and every
-    // release gesture apply unchanged. An existing hold keeps its stamp.
-    const holds = { ...(r.holds || {}) }
-
-    for (const member of roster) {
-      const key = groupMemberKey(member)
-
-      if (key && !holds[key]) {
-        holds[key] = { ...stamp }
-      }
-    }
-
-    r.holds = holds
-    return r
-  })
-
-  // Recorded AFTER the bump so the event is tagged with the new epoch — it
-  // stays visible as the current run's outcome instead of dropping out of
-  // view with the superseded run's events.
-  recordGroupActivity(group, { kind: 'stopped', member: 'You', thread: thread || null })
-
-  // Interrupt the member actually mid-turn. room.turn is runtime-only and
-  // names exactly one member (the loop is serial); a settled room has none.
-  const onTurn = turnName ? roster.find(member => member?.name === turnName) : null
-  const sessionId = onTurn ? (room.sessions || {})[groupMemberKey(onTurn)] : null
-
-  if (onTurn && sessionId) {
-    try {
-      await requestForBot(onTurn, 'session.interrupt', { session_id: sessionId })
-    } catch {
-      /* best-effort — the epoch/hold legs above already stopped the room;
-         the abandoned poll loop exits on its staleness check */
-    }
-  }
-}
-
-/** Drive one bounded round-robin turn for ONE THREAD. Serial — one member at
- *  a time. A newer user send bumps the room epoch; this loop notices at the
- *  next member boundary, bails, and the newest send's own loop takes over.
- *  Watermarks are per thread+member (`${thread}::${memberKey}`), so parallel
- *  topics never eat each other's deltas. */
-async function runGroupChatRounds(group, members, thread) {
-  const startEpoch = ($groupChats.get()[group] || {}).epoch || 0
-  const isCurrent = () => (($groupChats.get()[group] || {}).epoch || 0) === startEpoch
-  let posted = 0
-  let continuations = 0
-  // #94478: how this drive ended. 'settled' means quiet consensus (everyone
-  // passed with nothing pending); 'capped' means a round/message/continuation
-  // cap forced the exit — the activity feed must tell those apart.
-  let exitKind = 'settled'
-
-  try {
-    for (let round = 0; round < GROUP_CHAT_MAX_ROUNDS; round++) {
-      // Deliver any replies that finished after their turn timed out —
-      // every member, not just this round's responders, so long work is
-      // late, never lost.
-      for (const member of members) {
-        if (!isCurrent()) {
-          recordGroupActivity(group, { kind: 'cancelled', member: null, thread })
-          return
-        }
-
-        await harvestStrandedGroupReply(group, member)
-      }
-
-      const roomLog = (($groupChats.get()[group] || {}).log || []).filter(e => groupThreadOf(e) === thread)
-      // Exclude members the harvest pass just above confirmed are STILL
-      // running (their stranded marker survived harvest because
-      // state.inflight/running was true). Re-selecting one here would
-      // prompt.submit into their live session — the gateway's default busy
-      // policy redirects or hard-interrupts that turn (tui_gateway's
-      // _handle_busy_submit), killing exactly the long-running work this
-      // stranded/harvest mechanism exists to protect. Skip them; the next
-      // harvest pass picks the reply up once it actually lands. A marker's
-      // mere presence means "still stranded" (harvestStrandedGroupReply
-      // deletes it once the member is confirmed done/dead) — presence, not
-      // value shape, since markers are a bare number pre-thread or
-      // {before, thread} post-thread.
-      const strandedNow = ($groupChats.get()[group] || {}).stranded || {}
-      const responders = rotateGroupSpeakers(resolveGroupResponders(roomLog, members), round)
-        .filter(member => !Object.prototype.hasOwnProperty.call(strandedNow, groupMemberKey(member)))
-      let spokeThisRound = 0
-
-      for (const member of responders) {
-        if (!isCurrent() || posted >= GROUP_CHAT_MAX_MESSAGES) {
-          if (!isCurrent()) {
-            recordGroupActivity(group, { kind: 'cancelled', member: null, thread })
-          } else {
-            exitKind = 'capped' // message cap, not consensus (#94478)
-          }
-          return
-        }
-
-        const room = $groupChats.get()[group] || { log: [], watermarks: {} }
-        const memberKey = groupMemberKey(member)
-        const markKey = `${thread}::${memberKey}`
-        const seen = room.watermarks[markKey] || 0
-        // Delta: NEW room entries, narrowed to this thread — the member's
-        // turn sees only the conversation it's part of.
-        const delta = room.log.slice(seen).filter(e => groupThreadOf(e) === thread)
-
-        if (!delta.length) {
-          continue
-        }
-
-        // #93129: a member the user told to stop is HELD — no turn until an
-        // explicit release (resume / @all resume / a direct non-stop
-        // mention). Consume the delta exactly once (watermark past the
-        // current log) so the same entries never re-trigger this skip, and
-        // surface WHY the bot is silent in the activity feed the first time.
-        const heldEntry = (room.holds || {})[memberKey]
-
-        if (heldEntry) {
-          const advance = heldMemberWatermarkAdvance(seen, room.log.length)
-
-          updateGroupChat(group, r => {
-            if (advance !== null) {
-              r.watermarks[markKey] = advance
-            }
-
-            if (r.holds?.[memberKey] && !r.holds[memberKey].noted) {
-              r.holds = { ...r.holds, [memberKey]: { ...r.holds[memberKey], noted: true } }
-            }
-
-            return r
-          })
-
-          if (!heldEntry.noted) {
-            recordGroupActivity(group, { kind: 'held', member: member.name, thread })
-          }
-
-          continue
-        }
-
-        const prompt = buildGroupChatTurnPrompt({
-          groupName: group,
-          members,
-          viewer: member,
-          deltaLines: delta.slice(-GROUP_CHAT_HISTORY_LIMIT).map(e => formatGroupChatLine(e, member.name))
-        })
-
-        // Images riding this delta (user attachments — member entries don't
-        // carry images today, but flatMap keeps this future-proof) get staged
-        // into the member's session so the model sees the pixels, not just
-        // the transcript's [attached image: …] marker.
-        const deltaImages = delta.flatMap(e => (Array.isArray(e.images) ? e.images : []))
-
-        // Surface WHO is on turn (runtime-only, like running/epoch) so the
-        // room shows "Radar is thinking…" instead of a generic working line —
-        // long model turns otherwise read as the room being stuck.
-        updateGroupChat(group, r => {
-          r.turn = member.name
-          return r
-        })
-
-        let reply = null
-
-        try {
-          reply = await runGroupChatMemberTurn(group, member, prompt, thread, deltaImages)
-
-          // Needs-attention hook (#93091 item 3): a turn that produced a real
-          // reply (or an explicit pass) is a good turn — clear the badge.
-          // A timed-out turn also returns null but never threw; leaving any
-          // prior badge in place there is the conservative choice.
-          if (reply !== null) {
-            clearBotAttention(groupMemberKey(member))
-          }
-        } catch (error) {
-          const reason = String(error?.data?.reason || '').trim()
-          recordGroupActivity(group, {
-            kind: 'failed',
-            member: member.name,
-            thread,
-            ...(reason ? { reason } : {})
-          })
-          noteBotAttention(groupMemberKey(member), reason || error?.message || error)
-          reply = null // a failed turn is a pass, never a room error
-        }
-
-        // #93127: the turn may have finished AFTER a newer user send bumped
-        // the room epoch. That newer send's loop re-drives this member with
-        // the full delta, so committing this stale result (watermark advance
-        // + append) would double-deliver the same reply. Drop it here —
-        // BEFORE the watermark advance and BEFORE the append. Only a newer
-        // USER entry in THIS thread makes the re-drive premise true: a
-        // cross-thread send bumps the epoch too, but its loop filters this
-        // thread out and would never regenerate the finished reply. The
-        // during-turn tail is anchored by entry id, not index — the history
-        // trim drops entries from the FRONT, so an index slice could
-        // overshoot after a mid-turn trim and silently commit a stale turn.
-        const roomNow = $groupChats.get()[group] || { log: [] }
-        const epochNow = roomNow.epoch || 0
-        const anchorId = room.log.length ? room.log[room.log.length - 1].id : null
-        const anchorIdx = anchorId === null ? -1 : roomNow.log.findIndex(e => e.id === anchorId)
-        // Anchor trimmed away ⇒ every pre-turn entry was dropped, so every
-        // surviving entry is newer — scanning the whole log stays exact.
-        const turnTail = anchorIdx >= 0 ? roomNow.log.slice(anchorIdx + 1) : roomNow.log
-        const newerUserEntryInThread = turnTail.some(
-          e => e.from?.kind === 'user' && groupThreadOf(e) === thread
-        )
-
-        if (!shouldCommitMemberTurn(startEpoch, epochNow, newerUserEntryInThread)) {
-          recordGroupActivity(group, { kind: 'cancelled', member: member.name, thread })
-          return
-        }
-
-        // The member has now seen everything up to the pre-reply log length.
-        updateGroupChat(group, r => {
-          r.watermarks[markKey] = r.log.length
-          return r
-        })
-
-        if (reply !== null && !isGroupPassText(reply)) {
-          appendGroupChatEntry(
-            group,
-            { kind: 'member', name: member.name, ...(member.remoteSource ? { source: member.connectionLabel || member.connectionId } : {}) },
-            reply,
-            thread
-          )
-          // Its own message counts as seen too.
-          updateGroupChat(group, r => {
-            r.watermarks[markKey] = r.log.length
-            return r
-          })
-          posted += 1
-          spokeThisRound += 1
-        }
-      }
-
-      if (spokeThisRound === 0) {
-        // #94478: "everyone passed" is NOT the only way a round can go quiet —
-        // responders can be narrowed to members with no new delta while the
-        // thread's tail carries an @mention handoff that was never answered.
-        // Before settling, check for cited members still owed a turn and run
-        // one bounded continuation round for exactly those members. If none
-        // exist (or the continuation also goes quiet), the room genuinely
-        // settled.
-        const pendingKeys = unaddressedGroupMentions(group, members, thread)
-
-        // #94478 review: bound continuation rounds independently of the
-        // message cap so a pathological mention chain can't consume the
-        // room's entire budget on back-and-forth handoffs.
-        continuations += 1
-
-        if (pendingKeys.length && continuations <= GROUP_CHAT_MAX_CONTINUATIONS) {
-          const citedMembers = members.filter(member => pendingKeys.includes(groupMemberKey(member)))
-
-          if (citedMembers.length && posted < GROUP_CHAT_MAX_MESSAGES) {
-            const strandedNow = ($groupChats.get()[group] || {}).stranded || {}
-            const continuationResponders = citedMembers.filter(
-              member => !Object.prototype.hasOwnProperty.call(strandedNow, groupMemberKey(member))
-            )
-
-            for (const member of continuationResponders) {
-              if (!isCurrent() || posted >= GROUP_CHAT_MAX_MESSAGES || continuations > GROUP_CHAT_MAX_CONTINUATIONS) {
-                break
-              }
-
-              const room = $groupChats.get()[group] || { log: [], watermarks: {} }
-              const memberKey = groupMemberKey(member)
-              const markKey = `${thread}::${memberKey}`
-              const seen = room.watermarks[markKey] || 0
-              const delta = room.log.slice(seen).filter(e => groupThreadOf(e) === thread)
-
-              // A cited member always has delta here (the citing reply IS in
-              // its tail); skip defensively anyway so an empty prompt never
-              // fires.
-              if (!delta.length) {
-                continue
-              }
-
-              const heldEntry = (room.holds || {})[memberKey]
-
-              if (heldEntry) {
-                continue // holds still apply to continuation turns (#93129)
-              }
-
-              const prompt = buildGroupChatTurnPrompt({
-                groupName: group,
-                members,
-                viewer: member,
-                // The continuation prompt centers on what the member missed:
-                // everything since its watermark, which includes the reply
-                // that cites it.
-                deltaLines: delta.slice(-GROUP_CHAT_HISTORY_LIMIT).map(e => formatGroupChatLine(e, member.name))
-              })
-
-              updateGroupChat(group, r => {
-                r.turn = member.name
-                return r
-              })
-
-              let continuationReply = null
-
-              try {
-                continuationReply = await runGroupChatMemberTurn(group, member, prompt, thread)
-
-                if (continuationReply !== null) {
-                  clearBotAttention(memberKey)
-                }
-              } catch (error) {
-                recordGroupActivity(group, { kind: 'failed', member: member.name, thread })
-                noteBotAttention(memberKey, error?.message || error)
-                continuationReply = null
-              }
-
-              if (!isCurrent()) {
-                return
-              }
-
-              updateGroupChat(group, r => {
-                r.watermarks[markKey] = r.log.length
-                return r
-              })
-
-              if (continuationReply !== null && !isGroupPassText(continuationReply)) {
-                appendGroupChatEntry(
-                  group,
-                  { kind: 'member', name: member.name, ...(member.remoteSource ? { source: member.connectionLabel || member.connectionId } : {}) },
-                  continuationReply,
-                  thread
-                )
-                updateGroupChat(group, r => {
-                  r.watermarks[markKey] = r.log.length
-                  return r
-                })
-                posted += 1
-
-                // The continuation's own reply may cite someone else — fall
-                // through to the normal loop so the next round handles it via
-                // the same responder machinery. Reaching here means the loop
-                // continues rather than settling; the outer for-loop's next
-                // iteration re-evaluates everything.
-                spokeThisRound += 1
-              }
-            }
-          }
-        }
-
-        if (spokeThisRound === 0) {
-          // Genuinely nothing left to say — including after the continuation
-          // attempt above produced no spoken turns. Settle honestly, but if
-          // cited members are STILL owed a turn and only the continuation /
-          // message caps stopped us from driving them, this is a capped
-          // exit, not consensus. (#94478)
-          if (pendingKeys.length && (continuations > GROUP_CHAT_MAX_CONTINUATIONS || posted >= GROUP_CHAT_MAX_MESSAGES)) {
-            exitKind = 'capped'
-          }
-          return
-        }
-      }
-    }
-
-    // All GROUP_CHAT_MAX_ROUNDS rounds ran with someone still speaking —
-    // the round cap ended the drive, not consensus. (#94478)
-    exitKind = 'capped'
-  } finally {
-    if (isCurrent()) {
-      recordGroupActivity(group, { kind: exitKind, member: null, thread })
-      updateGroupChat(group, r => {
-        r.running = false
-        r.turn = null
-        return r
-      })
-
-      // #89545: the loop's harvest pass only ran at the top of each round of
-      // an ACTIVE loop — a member whose turn timed out after the final round
-      // stayed stranded until the user's NEXT send. Poll for the late reply
-      // in the background (bounded) so long work is late, never lost.
-      // (window feature-detect: the engine also runs under node in tests.)
-      const strandedLeft = Object.keys(($groupChats.get()[group] || {}).stranded || {})
-
-      if (strandedLeft.length && typeof window !== 'undefined') {
-        void harvestStrandedUntilSettled(group, members, thread)
-      }
-    }
-  }
-}
-
-/** Bounded background harvest for members whose replies outlived the turn
- *  loop. Polls every 5s for up to 5 minutes; stops early when nothing is
- *  stranded, a new loop takes the room over (it harvests on its own), or the
- *  room record disappears (disband). */
-async function harvestStrandedUntilSettled(group, members, thread) {
-  const HARVEST_INTERVAL_MS = 5000
-  const HARVEST_MAX_TRIES = 60
-
-  for (let attempt = 0; attempt < HARVEST_MAX_TRIES; attempt++) {
-    await new Promise(resolve => window.setTimeout(resolve, HARVEST_INTERVAL_MS))
-
-    const room = $groupChats.get()[group]
-
-    if (!room || room.running) {
-      return
-    }
-
-    const stranded = room.stranded || {}
-
-    if (!Object.keys(stranded).length) {
-      return
-    }
-
-    for (const member of members) {
-      if (Object.prototype.hasOwnProperty.call(stranded, groupMemberKey(member))) {
-        try {
-          await harvestStrandedGroupReply(group, member)
-        } catch {
-          // Best-effort: the next tick retries; the bound stops runaways.
-        }
-      }
-    }
-  }
-
-  recordGroupActivity(group, { kind: 'failed', member: null, thread })
-}
-
-/** User send into a group room. `thread` continues that thread (its reply
- *  box); omitted/null mints a NEW thread — the main composer's Slack shape.
- *  Appends, bumps the room epoch (supersedes any running loop at its next
- *  member boundary), and starts the turn drive for the target thread.
- *  Returns the thread id the message landed in. */
-function sendToGroupChat(group, members, text, thread, images) {
-  const trimmed = String(text || '').trim()
-  const attached = Array.isArray(images) ? images.filter(img => img && img.data) : []
-
-  if ((!trimmed && !attached.length) || !members.length) {
-    return null
-  }
-
-  const target = thread || mintGroupThreadId()
-
-  $groupNeedsYou.set({ ...$groupNeedsYou.get(), [group]: false })
-  // Refresh the durable room roster on every send. This backfills rooms made
-  // by older Desktop builds and keeps the gateway mirror complete even when
-  // members overlap across multiple groups.
-  updateGroupChat(group, room => {
-    room.members = durableGroupChatMembers(members)
-    return room
-  })
-  const sent = appendGroupChatEntry(group, { kind: 'user', name: 'You' }, trimmed, target, attached)
-
-  const wasRunning = ($groupChats.get()[group] || {}).running === true
-
-  updateGroupChat(group, room => {
-    room.epoch = (room.epoch || 0) + 1
-    room.running = true
-    // #93129: user text is the ONLY input that changes member holds. An
-    // explicit "stop @member" sets a sticky hold; "@member resume" (or
-    // @all resume, or any direct non-stop mention of the held member)
-    // releases it. Bot replies never flow through this function.
-    room.holds = applyGroupHoldDirective(
-      room.holds,
-      parseGroupChatMentions(trimmed, members),
-      trimmed,
-      { at: sent?.at, byMessageId: sent?.id, thread: target },
-      members.map(member => groupMemberKey(member))
-    )
-    return room
-  })
-
-  recordGroupActivity(group, { kind: 'queued', member: 'You', thread: target })
-
-  if (!wasRunning) {
-    void runGroupChatRounds(group, members, target).catch(() => {
-      updateGroupChat(group, r => {
-        r.running = false
-        return r
-      })
-    })
-  } else {
-    // A loop is live; it bails at its next boundary. Chain the fresh loop
-    // after a short settle so exactly one drive owns the room.
-    setTimeout(() => {
-      void runGroupChatRounds(group, members, target).catch(() => {
-        updateGroupChat(group, r => {
-          r.running = false
-          return r
-        })
-      })
-    }, 250)
-  }
-
-  return target
-}
-
-/** Share one in-flight async operation across concurrent callers. Failures
- * clear the slot so a later attempt can retry. */
-function singleFlight(ref, start) {
-  if (ref.current) {
-    return ref.current
-  }
-
-  let flight
-  try {
-    flight = Promise.resolve(start())
-  } catch (err) {
-    flight = Promise.reject(err)
-  }
-  ref.current = flight
-  flight.catch(() => {
-    if (ref.current === flight) {
-      ref.current = null
-    }
-  })
-  return flight
-}
-
-/** The agent-to-agent messaging protocol, reusable so a CUSTOM SOUL keeps
- *  the handoff protocol too — a custom SOUL used to silently drop it,
- *  breaking @mentions for customized bots (@wesleysimplicio, #16). */
-function messagingProtocolSection(name, roster) {
-  const teammates = (roster || []).filter(b => b.name !== name)
-  const handle = botHandle(name)
-
-  return [
-    '## Messaging other agents',
-    '',
-    'You work alongside other named agents. Every agent (including you) has',
-    'ONE canonical conversation titled "Bot Chat" — created with the agent,',
-    'so it always exists. Agent-to-agent messages are delivered straight',
-    'into it, like a DM. To message a teammate, run:',
-    '',
-    '```',
-    'hermes -p <agent-name> chat --in ~ -c "Bot Chat" --create-if-missing -Q -q "Message from \uD83E\uDD16 ' + handle + ' (@' + handle + '): your message"',
-    '',
-    'Run the send with background=true and notify_on_complete=true on the',
-    'terminal tool, then finish your turn — the reply arrives later as a',
-    'background process notification. Never block waiting for it.',
-    '```',
-    '',
-    '(`--in ~ -c "Bot Chat" --create-if-missing` resumes their canonical',
-    'conversation in the home workspace, creating it if the target has no',
-    '"Bot Chat" yet. `-Q` keeps output clean. Always open with the',
-    '"Message from \uD83E\uDD16 ' + handle + ' (@' + handle + '):" prefix so they know',
-    'who is talking (the @handle lets the app show your avatar to them).',
-    'Their reply prints to stdout — relay the relevant part back to the',
-    'user, and say which agent it came from.)',
-    '',
-    'If a message in YOUR chat starts with "Message from \uD83E\uDD16 <name>", it is',
-    'a teammate messaging you, not the user. Answer it directly — your reply',
-    'reaches them via their own delivery — and use the same command if you',
-    'need to start a conversation yourself.',
-    '',
-    'When the user writes @<agent-name> or says "ask <name> to ..." /',
-    '"tell <name> ...", that is a handoff: message that agent, wait for the',
-    'reply, and report back.',
-    '',
-    'The roster grows over time — run `hermes profile list` for the LIVE',
-    'teammate list before a handoff. Teammates when you were created:',
-    ...(teammates.length
-      ? teammates.map(b => `- \`${b.name}\`${b.description ? ` — ${b.description}` : ''}`)
-      : ['- (none yet)'])
-  ].join('\n')
-}
-
-/** True when SOUL.md already carries the Bot Mode handoff section.
- *  #16 appends this at create-time; pre-existing profiles (especially
- *  `default`) never went through composeSoul and silently lack it. */
-function hasMessagingProtocol(soul) {
-  return /(^|\n)## Messaging other agents(\s|$)/.test(soul || '')
-}
-
-/** Idempotent: append the protocol once, never duplicate a custom SOUL
- *  that already has it (clone-from-default after a backfill, Edit save).
- *  No-op when the backend injects the protocol into the system prompt
- *  itself (bot_mode_protocol) — SOUL.md stays the user's identity text. */
-function ensureMessagingProtocol(soul, name, roster) {
-  const text = (soul || '').trim()
-  if (serverInjectsProtocol || hasMessagingProtocol(text)) return text
-  const section = messagingProtocolSection(name, roster)
-  return text ? text + '\n\n' + section : section
-}
-
-const soulProtocolChecked = new Set()
-const soulProtocolInflight = new Set()
-
-/** One-shot per profile per session: if an existing SOUL has no protocol,
- *  append it. This is the install-time fix for default / pre-Bot-Mode
- *  personas that #16 never touched. Never overwrites identity text. */
-function backfillMessagingProtocol(roster) {
-  // Newer backends teach the protocol via the system prompt — never touch
-  // user SOUL files when the server already covers every session.
-  if (serverInjectsProtocol) {
-    return
-  }
-
-  for (const bot of roster || []) {
-    const name = bot && bot.name
-    if (!name || soulProtocolChecked.has(name) || soulProtocolInflight.has(name)) {
-      continue
-    }
-
-    soulProtocolInflight.add(name)
-    host
-      .request('profiles.describe', { name })
-      .then(res => {
-        const soul = (res && res.soul) || ''
-        if (hasMessagingProtocol(soul)) {
-          soulProtocolChecked.add(name)
-          return null
-        }
-        return host
-          .request('profiles.configure', { name, soul: ensureMessagingProtocol(soul, name, roster) })
-          .then(() => {
-            soulProtocolChecked.add(name)
-          })
-      })
-      .catch(() => {
-        // Older gateway or a one-off describe/configure miss — do not hammer.
-        soulProtocolChecked.add(name)
-      })
-      .finally(() => {
-        soulProtocolInflight.delete(name)
-      })
-  }
-}
-
-/** SOUL.md for a new bot: identity (or the user's custom SOUL) + the
- *  messaging protocol — which ships UNLESS the backend injects it into the
- *  system prompt itself (bot_mode_protocol capability). */
-function composeSoul({ name, title, description, roster, customSoul }) {
-  if (customSoul && customSoul.trim()) {
-    return ensureMessagingProtocol(customSoul, name, roster)
-  }
-
-  const lines = [
-    `# ${displayName({ name, title })}`,
-    '',
-    title ? `**Role:** ${title}` : null,
-    description ? `**Mission:** ${description}` : null,
-    '',
-    `You are ${displayName({ name, title })}, a persistent named agent (profile \`${name}\`) on this machine.`,
-    'You keep your own memory, skills, and conversation history across sessions.'
-  ]
-
-  const identity = lines.filter(line => line !== null).join('\n')
-
-  return serverInjectsProtocol ? identity : identity + '\n\n' + messagingProtocolSection(name, roster)
-}
-
-// ── human-readable row helpers ───────────────────────────────────────────────
-
-/** Bot-to-bot delivery prefix (see messagingProtocolSection): either the
- *  current "Message from 🤖 name (@handle):" form or the older
- *  "[Message from agent 'name']" shape. Captures the sender's handle. */
-const A2A_RE = /^Message from (?:agent '([^']+)'|🤖\s*([^\s(@]+))/i
-
-/** Strip the delivery prefix so a DM preview reads like a DM, not a log line. */
-const A2A_PREFIX_RE = /^Message from (?:agent '[^']+'|🤖[^:]+):\s*/i
-
-/** Classify a roster preview: `{ fromBot: handle|null }`. A preview that
- *  starts with the delivery prefix is a bot-to-bot message — the receiving
- *  bot's row should show WHO sent it, not present it as the human's chat. */
-function previewKind(preview) {
-  const text = (preview || '').trim()
-  if (!text) {
-    return { fromBot: null }
-  }
-  const match = text.match(A2A_RE)
-  if (match) {
-    // The captured name is whatever the delivery prefix carried — a raw
-    // profile name. Map it the way every other surface does so the primary
-    // profile reads @hermes, never @default (#89484).
-    const sender = (match[1] || match[2] || '').trim().toLowerCase()
-    return { fromBot: sender ? botHandle(sender) : null }
-  }
-  return { fromBot: null }
-}
-
-/** Session titles the gateway auto-assigns that carry no information. */
-const GENERIC_TITLES = new Set(['', 'bot chat', 'new chat', 'new conversation', 'conversation', 'chat', 'untitled'])
-
-function isGenericTitle(title) {
-  return GENERIC_TITLES.has((title || '').trim().toLowerCase())
-}
-
-/** Title for the session chip: the real session title when it means
- *  something, otherwise a short label generated from the newest message
- *  (delivery prefixes stripped) so "Bot Chat" rows still say what the
- *  conversation is actually about. */
-function generatedSessionTitle(session, preview) {
-  const raw = (session?.title || '').trim()
-  if (raw && !isGenericTitle(raw)) {
-    return raw
-  }
-  const cleaned = (preview || '').trim().replace(A2A_PREFIX_RE, '').trim()
-  if (!cleaned) {
-    return raw || 'Conversation'
-  }
-  const words = cleaned.split(/\s+/).slice(0, 5).join(' ').replace(/[,;:.]+$/, '')
-  if (!words) {
-    return raw || 'Conversation'
-  }
-  return words.length > 34 ? `${words.slice(0, 33)}…` : words
-}
-
-/** Roster liveness window: a bot whose last message landed within this many
- *  seconds is treated as "active now" (pulsing dot in its row). */
-const ACTIVE_WINDOW_S = 90
-const RECENT_ACTIVITY_WINDOW_S = 7 * 24 * 60 * 60
-const BOT_ROSTER_SEARCH_THRESHOLD = 8
-
-/** The session whose activity best represents this bot — the FRESHER of the
- *  canonical Bot Chat (canonical_session, the profile's "Bot Chat" registry
- *  row resolved server-side by name) and the profile's newest visible
- *  conversation (last_session).
- *
- *  Canonical Bot Chats are hidden from the session list by design, so
- *  last_session alone never sees them: a bot you talk to all day through its
- *  Bot Chat reads "6d ago" because its newest VISIBLE session is a week old.
- *  Every activity signal (age label, pulse dot, unread watermark, recency
- *  sort) keys off this helper. Older gateways without the canonical_session
- *  field degrade to last_session unchanged. */
-function botActivitySession(bot) {
-  const preferred = bot?.canonical_session
-  const last = bot?.last_session
-
-  if (!preferred || !last) {
-    return preferred || last || null
-  }
-
-  return (preferred.last_active || 0) >= (last.last_active || 0) ? preferred : last
-}
-
-/** Worker liveness window: kanban/tool workers heartbeat last_activity_at
- *  at least every 60s while running (agent/session_activity.py), so a
- *  worker whose stamp is older than this is finished or stalled. Wider
- *  than ACTIVE_WINDOW_S to bridge one missed heartbeat. */
-const WORKER_ACTIVE_WINDOW_S = 150
-
-/** True while this bot's freshest kanban/tool worker looks alive. Workers
- *  never surface in conversation lists, so without this a profile grinding
- *  through a 30-minute kanban task reads idle ("3 hr ago") the whole time
- *  (hermes-agent#90268). Older gateways omit worker_session — always false. */
-function workerActiveAt(bot, now = Date.now()) {
-  const ts = bot?.worker_session?.last_active || 0
-  return Boolean(ts && now / 1000 - ts < WORKER_ACTIVE_WINDOW_S)
-}
-
-/** Bots that are working right now: the profile the gateway is running a
- *  turn for (busy), any bot whose last message landed inside the liveness
- *  window, plus any bot with a live kanban/tool worker. Pure — output
- *  follows the input roster's order, so presence never reorders or hides
- *  the normal list. */
-function activeBots(roster, activeProfile, gatewayState, now = Date.now()) {
-  return (roster || []).filter(bot => {
-    const busyTurn = !bot.remoteSource && bot.name === activeProfile && gatewayState === 'busy'
-    const last = botActivitySession(bot)?.last_active || 0
-    const inWindow = Boolean(last && now / 1000 - last < ACTIVE_WINDOW_S)
-
-    return busyTurn || inWindow || workerActiveAt(bot, now)
-  })
-}
-
-function rosterActivityMatches(row, filter, now = Date.now()) {
-  if (!filter || filter === 'all') {
-    return true
-  }
-
-  if (filter === 'active') {
-    return Boolean(row?.active)
-  }
-
-  const activity = Number(row?.activity || 0)
-  const recent = Boolean(activity && now - activity <= RECENT_ACTIVITY_WINDOW_S * 1000)
-
-  return filter === 'recent' ? recent : !recent
-}
-
-function botRowOwnsWorkspace(
-  bot,
-  activeGroup,
-  botChatFocused,
-  botsHomeFronted,
-  focusedOwner,
-  selectedRosterKey
-) {
-  if (activeGroup) {
-    return false
-  }
-
-  if (botsHomeFronted || !botChatFocused) {
-    return selectedRosterKey === botRosterKey(bot)
-  }
-
-  return isActiveRosterBot(bot, focusedOwner)
-}
-
-// ── bot row ──────────────────────────────────────────────────────────────────
-
-function BotRow({ bot, onDelete, onEdit, onGroup, showHandle }) {
-  const activeProfile = useValue(host.state.profile)
-  const focusedOwner = focusedRosterOwner(useValue($focusedBotOwner))
-  const selectedRosterKey = useValue($selectedRosterKey)
-  const botChatFocused = useValue($botChatFocused)
-  const botsHomeFronted = useValue($botsHomeFronted)
-  const activeGroup = useValue($groupChatWorkspace)
-  const allMeta = useValue($botMeta)
-  const meta = botRosterMeta(bot, allMeta)
-  const hidden = isBotHidden(bot, allMeta)
-  const pinned = isBotPinned(bot, allMeta)
-  const sourceStatus = botSourceStatus(bot)
-  const groups = botGroups(meta)
-  const last = bot.last_session
-  // Highlight follows the chat on screen (focused session's owner), not the
-  // gateway socket's home — a focused tab doesn't swap the socket, and on the
-  // old keying the wrong bot stayed highlighted while you read another's chat.
-  // A selected group chat suppresses every bot-row highlight: the group row
-  // owns the selection then (#88979).
-  const activeConnectionId = String(host.state.connectionId?.get?.() || 'local').trim()
-  // The highlight follows whoever owns the MAIN workspace. While a chat owns
-  // it, that chat's profile wins (a stale roster click must not key the
-  // highlight to a bot you are not reading). While the Bots home owns it, the
-  // source-qualified selection is the owner — and it is the only rule that
-  // can highlight a remote row, which has no focusable local chat.
-  const isActive = botRowOwnsWorkspace(
-    bot,
-    activeGroup,
-    botChatFocused,
-    botsHomeFronted,
-    focusedOwner,
-    selectedRosterKey
-  )
-  // Turn-busy is a SOCKET fact: only the gateway-home profile can be mid-turn.
-  const isGatewayHome = !bot.remoteSource && bot.name === activeProfile &&
-    isActiveRosterBot(bot, { name: activeProfile, connectionId: activeConnectionId })
-  const { shape, color, image } = botAppearance(bot.name, meta)
-  // Keep user photos/pets. Drop the 160px SVG backfill so the math face can move.
-  const photo = Boolean(image && !isBackfilledFacePng(image))
-  const gatewayState = useValue(host.state.gateway)
-  // Preview identity must match click identity (#88200): when the backend
-  // resolved the pinned canonical chat, preview THAT session — not the
-  // profile's most recent (but unrelated) activity. Activity signals
-  // (age label, pulse dot) follow the same rule via botActivitySession:
-  // the canonical Bot Chat is hidden from last_session, so keying age off
-  // last_session alone shows "6d ago" on a bot you just messaged.
-  const previewSession = bot.canonical_session || last
-  const activitySession = botActivitySession(bot)
-  // A live kanban/tool worker counts as activity (#90268): fresh age while it
-  // runs, falling back to chat activity when it ends.
-  const workerActive = workerActiveAt(bot)
-  const rowAgeTs = workerActive
-    ? Math.max(activitySession?.last_active || 0, bot.worker_session?.last_active || 0)
-    : activitySession?.last_active || 0
-  const botMood = workerActive || (isGatewayHome && gatewayState === 'busy') ? 'work' : 'idle'
-  // Subscribe on every render. A source switch turns the same keyed row from
-  // thin to rich; conditionally calling useValue here breaks React hook order.
-  const unreadByName = useValue($botUnread)
-  const unread = Boolean(unreadByName[botSelectionKey(bot)])
-  // Needs-attention badge (#93091 item 3): background failures record under
-  // the selection key (group turns) or the route key (relay deliveries) —
-  // check both. Local/unannotated rows carry no connectionId, so their relay
-  // failures live under `<activeConnectionId>::<name>` — resolve that shape
-  // too or active-gateway bots never badge. Hidden bots keep their entry;
-  // hiding is display-only.
-  const attentionByKey = useValue($botAttention)
-  const attention =
-    attentionByKey[botSelectionKey(bot)] ||
-    attentionByKey[botRosterKey(bot)] ||
-    attentionByKey[`${bot?.connectionId || activeConnectionId}::${bot?.name || 'default'}`] ||
-    null
-  // WHO sent the last message (bot-to-bot DM vs human) — the full stored
-  // history lives in the canonical chat, not inline.
-  // Preview identity must match click identity (#88200): when the backend
-  // resolved the pinned canonical chat, preview THAT session — not the
-  // profile's most recent (but unrelated) activity. Liveness checks above
-  // keep last_session semantics: any recent activity means the bot is alive.
-  const { fromBot } = previewKind(previewSession?.preview)
-  // DM previews read like DMs: strip the delivery prefix, keep the message.
-  const displayPreview = stripPreviewMarkdown(
-    fromBot
-      ? (previewSession?.preview || '').replace(A2A_PREFIX_RE, '').trim() || '…'
-      : previewSession?.preview || ''
-  )
-  const handle = botHandle(bot.name, bot)
-  const gatewayLabel = bot.connectionLabel || (bot.connectionId === 'local' ? 'This device' : '')
-  const showDetailsRow = Boolean(showHandle || displayPreview || fromBot)
-  const rowTooltip = [displayName(bot, meta), `@${handle}`, gatewayLabel, sourceStatus.label]
-    .filter(Boolean)
-    .join(' · ')
-
-  const warm = () => {
-    // Multi-source row: pre-dial the agent's OWN source (feature-detected).
-    if (bot.sourceScoped && typeof host.warmAgent === 'function') {
-      try {
-        host.warmAgent(bot.connectionId, bot.name)
-      } catch {
-        /* warm is best-effort */
-      }
-
-      return
-    }
-
-    if (typeof host.warmProfile !== 'function') {
-      return
-    }
-
-    try {
-      host.warmProfile(bot.name)
-    } catch {
-      /* warm is best-effort */
-    }
-  }
-
-  // Rows and Active Now share the exact-owner open path; only that path may
-  // activate a source and resolve the canonical Bot Chat.
-  const open = () => void openRosterBot(bot)
-
-  const row = jsxs('button', {
-    type: 'button',
-    onPointerEnter: warm,
-    onClick: open,
-    className: cn(
-      'flex w-full min-w-0 max-w-full items-center gap-2.5 overflow-hidden rounded-md px-2 py-2 text-left transition-colors',
-      'hover:bg-(--chrome-action-hover)',
-      isActive && 'bg-(--ui-row-active-background)'
-    ),
-    'aria-label': rowTooltip,
-    children: [
-      jsx('div', {
-        className: cn('shrink-0', !sourceStatus.available && 'grayscale opacity-60'),
-        children: jsx(BotFace, {
-          shape,
-          color,
-          image: photo ? image : null,
-          size: 34,
-          name: bot.name,
-          mood: botMood
-        })
-      }),
-      jsxs('div', {
-        className: 'min-w-0 flex-1',
-        children: [
-          jsxs('div', {
-            className: 'flex items-baseline justify-between gap-2',
-            children: [
-              jsxs('div', {
-                className: 'flex min-w-0 items-center gap-1.5',
-                children: [
-                  pinned
-                    ? jsx(Tip, {
-                        label: 'Pinned',
-                        children: jsx(Codicon, {
-                          name: 'pinned',
-                          className: 'shrink-0 text-[0.6875rem] text-(--ui-text-quaternary)'
-                        })
-                      })
-                    : null,
-                  hidden
-                    ? jsx(Tip, {
-                        label: 'Hidden from the roster',
-                        children: jsx(Codicon, {
-                          name: 'eye-closed',
-                          className: 'shrink-0 text-[0.6875rem] text-(--ui-text-quaternary)'
-                        })
-                      })
-                    : null,
-                  jsx(Tip, {
-                    label: rowTooltip,
-                    children: jsx('span', {
-                      className: 'min-w-0 truncate text-[0.8125rem] font-medium',
-                      children: displayName(bot, meta)
-                    })
-                  }),
-                ]
-              }),
-              attention
-                ? jsx(Tip, {
-                    label: BOT_ATTENTION_HINTS[attention.reason] || 'Needs attention',
-                    children: jsx(Codicon, {
-                      name: 'warning',
-                      className: 'shrink-0 text-[0.6875rem] text-(--ui-warning,#f59e0b)',
-                      'aria-label': 'needs attention'
-                    })
-                  })
-                : null,
-              unread
-                ? jsx('span', {
-                    className: 'size-2 shrink-0 rounded-full bg-(--ui-accent)',
-                    'aria-label': 'unread'
-                  })
-                : null,
-              rowAgeTs
-                ? jsx('span', {
-                    className: 'shrink-0 text-[0.6875rem] text-(--ui-text-quaternary)',
-                    children: relativeTime(rowAgeTs * 1000)
-                  })
-                : null
-            ]
-          }),
-          showDetailsRow
-            ? jsxs('div', {
-                className: 'flex min-w-0 items-center gap-1.5 text-xs text-(--ui-text-tertiary)',
-                children: [
-                  showHandle
-                    ? jsx('span', {
-                        className: 'shrink-0 font-mono text-[0.6875rem] text-(--ui-text-quaternary)',
-                        children: `@${handle}`
-                      })
-                    : null,
-                  showHandle && displayPreview
-                    ? jsx('span', { className: 'shrink-0 text-(--ui-text-quaternary)', children: '·' })
-                    : null,
-                  displayPreview
-                    ? jsx('span', {
-                        className: cn('min-w-0 truncate', fromBot && 'italic'),
-                        children: displayPreview
-                      })
-                    : null
-                ]
-              })
-            : null
-        ]
-      })
-    ]
-  })
-
-  return jsxs(ContextMenu, {
-    children: [
-      jsx(ContextMenuTrigger, { asChild: true, children: row }),
-      jsxs(ContextMenuContent, {
-        children: [
-          jsx(ContextMenuItem, {
-            onSelect: () => {
-              void ensureBotMetadata(bot).then(current => {
-                const pinned = Boolean(current.pinned)
-                void saveBotMeta(bot, { pinned: !pinned })
-                host.notify({
-                  kind: 'info',
-                  message: `${displayName(bot, current)} ${pinned ? 'unpinned' : 'pinned to top'}`
-                })
-              }).catch(error => host.notifyError?.(error, 'Could not load bot metadata'))
-            },
-            children: pinned ? 'Unpin' : 'Pin to top'
-          }),
-          jsx(ContextMenuItem, {
-            onSelect: () => {
-              void ensureBotMetadata(bot).then(current => {
-                const hidden = Boolean(current.hidden)
-                void saveBotMeta(bot, { hidden: !hidden })
-
-                if (!hidden) {
-                  fallbackSelectionAfterHide(botSelectionKey(bot))
-                }
-
-                host.notify({
-                  kind: 'info',
-                  message: hidden
-                    ? `${displayName(bot, current)} is back in the roster`
-                    : `${displayName(bot, current)} hidden — use the eye button in the Bots header to see hidden bots`
-                })
-              }).catch(error => host.notifyError?.(error, 'Could not load bot metadata'))
-            },
-            children: hidden ? 'Unhide' : 'Hide'
-          }),
-          jsx(ContextMenuSeparator, {}),
-          jsx(ContextMenuItem, {
-            onSelect: () => void ensureBotMetadata(bot).then(() => onEdit(bot)).catch(error => host.notifyError?.(error, 'Could not load bot')),
-            children: 'Edit Profile'
-          }),
-          jsx(ContextMenuItem, {
-            onSelect: () => void ensureBotMetadata(bot).then(() => onGroup(bot)).catch(error => host.notifyError?.(error, 'Could not load bot groups')),
-            children: groups.length ? `Groups: ${groups.join(', ')}…` : 'Manage groups…'
-          }),
-          jsx(ContextMenuItem, {
-            onSelect: () => {
-              host.notify({ kind: 'info', message: `Duplicating ${displayName(bot, meta)}…` })
-              duplicateBot(bot, $lastRoster.get())
-                .then(name => {
-                  queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-                  host.notify({ kind: 'success', message: `Created ${name} — full copy of ${bot.name}` })
-                })
-                .catch(err => host.notifyError(err, 'Duplicate failed'))
-            },
-            children: 'Duplicate'
-          }),
-          jsx(ContextMenuSeparator, {}),
-          jsx(ContextMenuItem, {
-            // The explicit ask for the forever-chat: a plain row click only
-            // comes back to the tabs already open (a closed Bot Chat stays
-            // closed), so this is how it is re-opened on purpose.
-            onSelect: () => void openRosterBot(bot, { canonical: true }),
-            children: 'Open Bot Chat'
-          }),
-          jsx(ContextMenuItem, {
-            onSelect: () => {
-              saveSelectedRosterBot(bot)
-              setBotsWorkspaceOwner(botWorkspaceOwnerKey(bot), bot)
-              newBotChat(bot)
-            },
-            children: 'New chat with this agent'
-          }),
-          isDefaultBot(bot) ? null : jsx(ContextMenuSeparator, {}),
-          isDefaultBot(bot)
-            ? null
-            : jsx(ContextMenuItem, {
-                onSelect: () => onDelete(bot),
-                variant: 'destructive',
-                children: 'Delete'
-              })
-        ]
-      })
-    ]
-  })
-}
-
-// ── model picker (provider/model dropdowns via model.options) ───────────────
-
-// #95279: the picker's catalog read rides the BOT's own socket — a lazily
-// dialed second backend that can wedge (cold pool spawn, dropped remote hop)
-// without the primary socket ever noticing. An unbounded RPC there left the
-// query pending forever and the picker spinning ("never settles"). Bound every
-// attempt: past the budget the query rejects and ModelPicker falls back to its
-// free-text inputs instead of an eternal GlyphSpinner.
-const MODEL_OPTIONS_SETTLE_MS = 20000
-
-function boundedModelOptionsFetch(fetch, settleMs = MODEL_OPTIONS_SETTLE_MS) {
-  // window.setTimeout (not bare setTimeout): bare vm test harnesses expose
-  // timers only through the window shim. With no scheduler at all, degrade to
-  // the old unbounded behavior rather than not fetching.
-  const scope = typeof window === 'undefined' ? null : window
-
-  if (!scope || typeof scope.setTimeout !== 'function') {
-    return fetch
-  }
-
-  let timerId = null
-  const deadline = new Promise((_, reject) => {
-    timerId = scope.setTimeout(() => {
-      reject(new Error(`model.options did not answer within ${Math.round(settleMs / 1000)}s (#95279 settle guard)`))
-    }, settleMs)
-  })
-
-  return Promise.race([fetch, deadline]).finally(() => scope.clearTimeout(timerId))
-}
-
-function useModelOptions(bot = null) {
-  // Hook body runs during render: an orphaned row must paint the picker
-  // disabled/erroring, not throw into the pane's error boundary.
-  const resolved = bot ? resolveBotConnectionRoute(bot) : null
-  const route = resolved?.status === 'resolved' ? resolved.route : null
-  const orphaned = resolved?.status === 'owner_removed'
-
-  return useQuery({
-    queryKey: [ID, 'model-options', route ? botRouteKey(route) : 'active'],
-    // No forced `refresh`: forcing a network read on EVERY mount bypassed the
-    // staleTime cache, so each Bots view remount (tab re-front, dialog reopen,
-    // pane visibility flip) knocked the picker back into its loading state and
-    // discarded the user's staged selection mid-edit (#95279). The cached read
-    // still refreshes per staleTime like every other surface's catalog.
-    queryFn: () =>
-      boundedModelOptionsFetch(
-        requestForBot(bot, 'model.options', {
-          include_unconfigured: true,
-          explicit_only: false
-        })
-      ),
-    enabled: !orphaned,
-    staleTime: 120000,
-    retry: false
-  })
-}
-
-/**
- * Provider + model dropdowns from the gateway's configured inventory — the
- * same data the core model picker shows. `value = {provider, model}`;
- * onChange receives the merged patch.
- */
-function ModelPicker({ bot = null, value, onChange, placeholderModel = 'gateway default' }) {
-  const { data, isLoading, error } = useModelOptions(bot)
-
-  // Hooks are ALWAYS declared up front, before any conditional return.
-  // Declaring them after a return trips React error #310.
-  const NONE = '__default__'
-  const CUSTOM = '__custom__'
-  const providers = (data?.providers || []).filter(p => p && p.slug)
-  const isKnown =
-    !value.provider || value.provider === NONE || providers.some(p => p.slug === value.provider)
-  const [useFreeText, setUseFreeText] = useState(!isKnown)
-
-  if (isLoading) {
-    return jsx('div', {
-      className: 'flex justify-center py-2',
-      children: jsx(GlyphSpinner, { spinner: 'breathe', className: 'text-(--ui-text-tertiary)' })
-    })
-  }
-
-  if (error || !providers.length) {
-    // Fallback: free text (older gateway or empty inventory).
-    return jsxs('div', {
-      style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '10px' },
-      children: [
-        labeled(
-          'Provider',
-          jsx(Input, {
-            placeholder: 'omnirouter / 9router / nous \u2026',
-            value: value.provider,
-            onChange: event => onChange({ provider: event.target.value })
-          })
-        ),
-        labeled(
-          'Model',
-          jsx(Input, {
-            placeholder: 'antigravity/gemini-3.6-flash-high',
-            value: value.model,
-            onChange: event => onChange({ model: event.target.value })
-          })
-        )
-      ]
-    })
-  }
-
-  if (useFreeText) {
-    return jsxs('div', {
-      style: { display: 'flex', flexDirection: 'column', gap: '8px' },
-      children: [
-        jsxs('div', {
-          style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '10px' },
-          children: [
-            labeled(
-              'Provider (Custom)',
-              jsx(Input, {
-                placeholder: 'e.g. omnirouter, inferx, 9router',
-                value: value.provider,
-                onChange: event => onChange({ provider: event.target.value })
-              })
-            ),
-            labeled(
-              'Model (Custom)',
-              jsx(Input, {
-                placeholder: 'e.g. antigravity/gemini-3.6-flash-high',
-                value: value.model,
-                onChange: event => onChange({ model: event.target.value })
-              })
-            )
-          ]
-        }),
-        jsx(Button, {
-          variant: 'ghost',
-          size: 'sm',
-          className: 'h-6 self-start text-xs text-(--ui-text-tertiary)',
-          onClick: () => setUseFreeText(false),
-          children: '← Back to dropdowns'
-        })
-      ]
-    })
-  }
-
-  const activeProvider = providers.find(p => p.slug === value.provider) || null
-  const models = activeProvider
-    ? (activeProvider.models || []).map(m => (typeof m === 'string' ? m : m.id || m.name || ''))
-    : []
-
-  return jsxs('div', {
-    style: { display: 'grid', gridTemplateColumns: '1fr 1.4fr', gap: '10px' },
-    children: [
-      labeled(
-        'Provider',
-        jsxs(Select, {
-          value: value.provider || NONE,
-          onValueChange: v => {
-            if (v === NONE) {
-              onChange({ provider: '', model: '' })
-            } else if (v === CUSTOM) {
-              setUseFreeText(true)
-            } else {
-              const prov = providers.find(p => p.slug === v)
-              const provModels = (prov?.models || []).map(m =>
-                typeof m === 'string' ? m : m.id || m.name || ''
-              )
-              const first = provModels[0] || ''
-              onChange({
-                provider: v,
-                model: prov && provModels.includes(value.model) ? value.model : first
-              })
-            }
-          },
-          children: [
-            jsx(SelectTrigger, { className: 'h-8 rounded-md', children: jsx(SelectValue, {}) }),
-            jsxs(SelectContent, {
-              children: [
-                jsx(SelectItem, { value: NONE, children: 'Inherit (launch profile)' }),
-                ...providers.map(p =>
-                  jsx(
-                    SelectItem,
-                    { value: p.slug, children: p.name ? `${p.name} (${p.slug})` : p.slug },
-                    p.slug
-                  )
-                ),
-                jsx(SelectItem, { value: CUSTOM, children: '✏️ Enter manually…' })
-              ]
-            })
-          ]
-        })
-      ),
-      labeled(
-        'Model',
-        activeProvider && models.length > 0
-          ? jsxs(Select, {
-              value: value.model || (models[0] ?? ''),
-              onValueChange: v => onChange({ model: v }),
-              children: [
-                jsx(SelectTrigger, { className: 'h-8 rounded-md', children: jsx(SelectValue, {}) }),
-                jsx(SelectContent, {
-                  children: models.map(m => jsx(SelectItem, { value: m, children: m }, m))
-                })
-              ]
-            })
-          : jsx(Input, {
-              placeholder: placeholderModel || 'e.g. model name',
-              value: value.model,
-              onChange: event => onChange({ model: event.target.value })
-            })
-      )
-    ]
-  })
-}
-
-// ── advanced profile config (skills / toolsets / model / SOUL) ──────────────
-//
-// Shared by Edit Profile and New Bot (edit mode only for skills/toolsets —
-// a not-yet-created profile has nothing installed to toggle). Backed by
-// profiles.describe / profiles.configure; feature-detects older gateways.
-
-function CheckList({ items, onToggle, columns = 2 }) {
-  return jsx('div', {
-    style: {
-      display: 'grid',
-      gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))`,
-      gap: '2px 12px'
-    },
-    children: items.map(item =>
-      jsxs(
-        'label',
-        {
-          className: 'flex min-w-0 cursor-pointer items-center gap-1.5 py-0.5 text-xs text-(--ui-text-secondary)',
-          title: item.description || item.name,
-          children: [
-            jsx(Checkbox, {
-              checked: item.enabled,
-              onCheckedChange: value => onToggle(item.name, Boolean(value))
-            }),
-            jsx('span', { className: 'truncate', children: item.name }),
-            item.tool_count
-              ? jsx('span', {
-                  className: 'shrink-0 text-[0.6rem] text-(--ui-text-quaternary)',
-                  children: `${item.tool_count}`
-                })
-              : null
-          ]
-        },
-        item.name
-      )
-    )
-  })
-}
-
-function AdvancedProfileConfig({ bot, state, setState }) {
-  const [loaded, setLoaded] = useState(false)
-  const [unsupported, setUnsupported] = useState(false)
-  const [skillFilter, setSkillFilter] = useState('')
-  // Component body = render path: degrade an orphaned row to the bot's own
-  // name scope instead of throwing into the dialog's error boundary.
-  const botRoute = resolveBotConnectionRoute(bot).route
-  const backendProfile = botRoute?.targetProfile || botRoute?.profile || bot.name
-  const backendScope = botBackendProfileScope(botRoute, bot.name)
-
-  if (!loaded) {
-    setLoaded(true)
-    Promise.all([
-      requestForBot(bot, 'profiles.describe', { name: bot.name }),
-      requestForBot(bot, 'mcp.catalog', { profile: bot.name }).catch(() => null)
-    ])
-      .then(([res, cat]) => {
-        const configured = res.mcp_servers || []
-        const have = new Set(configured.map(m => m.name))
-        const catalog = ((cat && cat.servers) || []).filter(s => !have.has(s.name))
-        setState(prev => ({
-          ...prev,
-          provider: res.model?.provider || '',
-          model: res.model?.default || '',
-          soul: res.soul || '',
-          skills: res.skills || [],
-          toolsets: res.toolsets || [],
-          mcp: [
-            ...configured.map(m => ({ ...m, enabled: m.enabled !== false })),
-            ...catalog.map(s => ({
-              name: s.name,
-              enabled: false,
-              fromCatalog: true,
-              installed: s.installed,
-              auth: s.auth,
-              requires: s.requires || [],
-              description: s.description || ''
-            }))
-          ],
-          loaded: true
-        }))
-      })
-      .catch(() => setUnsupported(true))
-  }
-
-  if (unsupported) {
-    return jsx('div', {
-      className: 'px-2 py-3 text-center text-xs text-(--ui-text-tertiary)',
-      children: 'Full configuration needs a newer gateway (restart it after updating Hermes).'
-    })
-  }
-
-  if (!state.loaded) {
-    return jsx('div', {
-      className: 'flex justify-center py-4',
-      children: jsx(GlyphSpinner, { spinner: 'breathe', className: 'text-(--ui-text-tertiary)' })
-    })
-  }
-
-  const visibleSkills = skillFilter.trim()
-    ? state.skills.filter(s => s.name.toLowerCase().includes(skillFilter.trim().toLowerCase()))
-    : state.skills
-
-  const toggleSkill = (name, enabled) =>
-    setState(prev => ({
-      ...prev,
-      dirtySkills: true,
-      skills: prev.skills.map(s => (s.name === name ? { ...s, enabled } : s))
-    }))
-
-  const toggleToolset = (name, enabled) =>
-    setState(prev => ({
-      ...prev,
-      dirtyToolsets: true,
-      toolsets: prev.toolsets.map(t => (t.name === name ? { ...t, enabled } : t))
-    }))
-
-  const toggleMcp = (name, enabled) =>
-    setState(prev => ({
-      ...prev,
-      dirtyMcp: true,
-      mcp: (prev.mcp || []).map(m => (m.name === name ? { ...m, enabled } : m))
-    }))
-
-  const enabledSkills = state.skills.filter(s => s.enabled).length
-  const enabledToolsets = state.toolsets.filter(t => t.enabled).length
-  const mcpList = state.mcp || []
-  const enabledMcp = mcpList.filter(m => m.enabled).length
-
-  // Newer desktop builds export the WHOLE core Capabilities surface
-  // (hermes-agent#87317): Skills (installed list + one-click hub installs +
-  // full-skill detail), Tools (per-toolset config), and MCP — pinned to this
-  // bot via fixedProfile, tab state kept out of the page router via embedded.
-  // Render THAT instead of the checkbox stand-ins; writes go straight to the
-  // bot's backend, so the dirty-section staging below only carries
-  // model + SOUL on these builds. Older builds keep the full checklist UI.
-  if (SkillsView && (!botRoute || skillsViewRoutesConnections)) {
-    return jsxs('div', {
-      className: 'grid gap-4',
-      children: [
-        jsx(ModelPicker, {
-          bot,
-          value: { provider: state.provider, model: state.model },
-          onChange: patch => setState(prev => ({ ...prev, dirtyModel: true, ...patch }))
-        }),
-        labeled(
-          'Capabilities (applies immediately — skills, tools, MCP)',
-          jsx('div', {
-            className: 'overflow-hidden rounded-md border border-(--ui-stroke-secondary)',
-            style: { height: 460, minHeight: 300, resize: 'vertical', overflow: 'auto' },
-            children: jsx(SkillsView, {
-              embedded: true,
-              fixedProfile: backendProfile,
-              ...(botRoute ? { fixedConnection: botRoute.connectionId } : {})
-            })
-          })
-        ),
-        labeled(
-          'SOUL.md (persona + agent-messaging protocol)',
-          jsx(Textarea, {
-            className: 'min-h-28 font-mono text-xs leading-5',
-            value: state.soul,
-            onChange: event => setState(prev => ({ ...prev, dirtySoul: true, soul: event.target.value }))
-          })
-        )
-      ]
-    })
-  }
-
-  if (bot?.sourceScoped && botRoute?.mode === 'remote' && !skillsViewRoutesConnections) {
-    return jsxs('div', {
-      className: 'grid gap-4',
-      children: [
-        jsx(ModelPicker, {
-          bot,
-          value: { provider: state.provider, model: state.model },
-          onChange: patch => setState(prev => ({ ...prev, dirtyModel: true, ...patch }))
-        }),
-        jsx('div', {
-          className: 'rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs text-(--ui-text-tertiary)',
-          children: 'Remote capabilities require a newer desktop. Model and SOUL changes remain staged until you save.'
-        }),
-        labeled(
-          'SOUL.md (persona + agent-messaging protocol)',
-          jsx(Textarea, {
-            className: 'min-h-28 font-mono text-xs leading-5',
-            value: state.soul,
-            onChange: event => setState(prev => ({ ...prev, dirtySoul: true, soul: event.target.value }))
-          })
-        )
-      ]
-    })
-  }
-
-  return jsxs('div', {
-    className: 'grid gap-4',
-    children: [
-      jsx(ModelPicker, {
-        bot,
-        value: { provider: state.provider, model: state.model },
-        onChange: patch => setState(prev => ({ ...prev, dirtyModel: true, ...patch }))
-      }),
-      labeled(
-        `Skills (${enabledSkills}/${state.skills.length} enabled)`,
-        jsxs('div', {
-          className: 'grid gap-1.5 rounded-md border border-(--ui-stroke-secondary) p-2',
-          children: [
-            jsx(Input, {
-              className: 'h-7 text-xs',
-              placeholder: 'Filter skills…',
-              value: skillFilter,
-              onChange: event => setSkillFilter(event.target.value)
-            }),
-            jsx(ScrollArea, {
-              className: 'hermes-scroll-cap',
-              style: { maxHeight: 180 },
-              children: jsx(CheckList, { items: visibleSkills, onToggle: toggleSkill, columns: 2 })
-            }),
-            jsx(HubSkillsSection, {
-              forProfile: backendScope,
-              onInstalled: name =>
-                setState(prev =>
-                  prev.skills.some(s => s.name === name)
-                    ? prev
-                    : { ...prev, skills: [...prev.skills, { name, enabled: true }] }
-                )
-            })
-          ]
-        })
-      ),
-      labeled(
-        `Toolsets (${enabledToolsets}/${state.toolsets.length} enabled — unchecking all restores the default)`,
-        jsx('div', {
-          className: 'rounded-md border border-(--ui-stroke-secondary) p-2',
-          children: jsx(ScrollArea, {
-            className: 'hermes-scroll-cap',
-            style: { maxHeight: 320 },
-            children: jsx('div', {
-              className: 'grid gap-1.5',
-              children: state.toolsets.map(tset =>
-                jsxs(
-                  'div',
-                  {
-                    className: 'rounded-md border border-(--ui-stroke-secondary) p-2',
-                    children: [
-                      jsxs('label', {
-                        className: 'flex items-center gap-2 text-xs font-medium text-(--ui-text-secondary)',
-                        children: [
-                          jsx(Checkbox, {
-                            checked: !!tset.enabled,
-                            onCheckedChange: value => toggleToolset(tset.name, Boolean(value))
-                          }),
-                          jsx('span', { children: tset.name })
-                        ]
-                      }),
-                      // The REAL per-toolset config (env vars / API keys / model
-                      // picker / post-setup), scoped to THIS bot's profile, when
-                      // the desktop build exposes it. Older builds: just the toggle.
-                      ToolsetConfigPanel
-                        ? jsx('div', {
-                            className: 'mt-1.5 border-t border-(--ui-stroke-secondary) pt-1.5',
-                            children: jsx(ToolsetConfigPanel, { toolset: tset.name, profile: backendScope })
-                          })
-                        : null
-                    ]
-                  },
-                  tset.name
-                )
-              )
-            })
-          })
-        })
-      ),
-      labeled(
-        'MCP servers',
-        jsx('div', {
-          className: 'overflow-hidden rounded-md border border-(--ui-stroke-secondary)',
-          // The REAL MCP tab core Settings renders — per-server enable + OAuth
-          // sign-in + API-key setup + live probes — scoped to this bot's profile.
-          // Feature-detected: older desktop builds without the SDK export fall
-          // back to the plugin's own checkbox list + inline setup buttons.
-          children: McpTab && typeof host.getGateway === 'function'
-            ? jsx('div', {
-                style: { minHeight: 220, maxHeight: 360 },
-                children: jsx(McpTab, { gateway: host.getGateway(), profile: backendScope })
-              })
-            : mcpList.length === 0
-              ? jsx('div', {
-                  className: 'px-1 py-2 text-center text-xs text-(--ui-text-tertiary)',
-                  children: 'No MCP servers configured or in the catalog.'
-                })
-              : jsx(ScrollArea, {
-                  className: 'hermes-scroll-cap',
-                  style: { maxHeight: 180 },
-                  children: jsx('div', {
-                    className: 'grid gap-1 p-2',
-                    children: mcpList.map(m => {
-                      const needsSetup = m.fromCatalog && !m.installed && ((m.requires || []).length > 0 || (m.auth || '').toLowerCase() === 'oauth')
-                      return jsxs(
-                        'label',
-                        {
-                          className: 'flex items-start gap-2 text-xs text-(--ui-text-secondary)',
-                          children: [
-                            jsx(Checkbox, {
-                              checked: !!m.enabled,
-                              disabled: needsSetup,
-                              onCheckedChange: value => toggleMcp(m.name, Boolean(value))
-                            }),
-                            jsxs('span', {
-                              className: 'min-w-0',
-                              children: [
-                                jsx('span', { children: m.name }),
-                                m.fromCatalog && !needsSetup
-                                  ? jsx('span', {
-                                      className: 'ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)',
-                                      children: m.installed ? 'catalog · installed' : 'catalog'
-                                    })
-                                  : null,
-                                needsSetup
-                                  ? jsx(McpSetupButton, {
-                                      profile: backendScope,
-                                      entry: m,
-                                      onDone: () => toggleMcp(m.name, true)
-                                    })
-                                  : null,
-                                m.description
-                                  ? jsx('div', {
-                                      className: 'truncate text-[0.65rem] leading-4 text-(--ui-text-quaternary)',
-                                      children: m.description
-                                    })
-                                  : null
-                              ]
-                            })
-                          ]
-                        },
-                        m.name
-                      )
-                    })
-                  })
-                })
-        })
-      ),
-      labeled(
-        'SOUL.md (persona + agent-messaging protocol)',
-        jsx(Textarea, {
-          className: 'min-h-28 font-mono text-xs leading-5',
-          value: state.soul,
-          onChange: event => setState(prev => ({ ...prev, dirtySoul: true, soul: event.target.value }))
-        })
-      )
-    ]
-  })
-}
-
-// ── skills hub section: the REAL hub page (docs) embedded as a picker ──────
-// https://hermes-agent.nousresearch.com/docs/skills?embed=picker hides the
-// docs chrome and adds "+ Add to this Agent" per card, posting
-// {type: 'hermes-skill-pick', ...} to us (hermes-agent#86243). We validate
-// the origin, install via skills.manage, and bubble onInstalled so the
-// checklist above gains the row. Search-box fallback kept for offline use.
-
-const HUB_ORIGIN = 'https://hermes-agent.nousresearch.com'
-const HUB_PICKER_URL = HUB_ORIGIN + '/docs/skills?embed=picker'
-
-function HubSkillsSection({ forProfile, onInstalled }) {
-  const [query, setQuery] = useState('')
-  const [results, setResults] = useState(null)
-  const [searching, setSearching] = useState(false)
-  const [installing, setInstalling] = useState(null)
-  const [installed, setInstalled] = useState({})
-  const [browseHub, setBrowseHub] = useState(false)
-  const installRef = useRef(null)
-  const frameRef = useRef(null)
-
-  // Picker messages from the embedded hub page. Origin- AND source-checked —
-  // only OUR frame may ask for an install (the hub origin alone would let any
-  // other window on it, e.g. an OAuth popup, trigger installs too); installs
-  // route through the same install() the search fallback uses.
-  useEffect(() => {
-    if (!browseHub) {
-      return undefined
-    }
-
-    const onMessage = event => {
-      if (event.origin !== HUB_ORIGIN) {
-        return
-      }
-
-      if (!frameRef.current || event.source !== frameRef.current.contentWindow) {
-        return
-      }
-
-      const data = event.data
-
-      if (!data || data.type !== 'hermes-skill-pick' || !data.name) {
-        return
-      }
-
-      const target = String(data.identifier || data.name)
-
-      // Skill identifiers are slugs / owner-name paths — keep anything
-      // else out of skills.manage.
-      if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(target)) {
-        return
-      }
-
-      if (installRef.current) {
-        void installRef.current(target, String(data.name))
-      }
-    }
-
-    window.addEventListener('message', onMessage)
-
-    return () => window.removeEventListener('message', onMessage)
-  }, [browseHub])
-
-  const search = async () => {
-    const q = query.trim()
-
-    if (!q || searching) {
-      return
-    }
-
-    setSearching(true)
-    setResults(null)
-
-    try {
-      const res = await host.request('skills.manage', { action: 'search', query: q })
-      setResults(res.results || [])
-    } catch {
-      setResults([])
-    } finally {
-      setSearching(false)
-    }
-  }
-
-  const install = async (name, displayName) => {
-    const label = displayName || name
-
-    if (installing) {
-      return
-    }
-
-    setInstalling(label)
-
-    try {
-      // With forProfile the install lands in that bot's skills dir
-      // (gateway skills.manage profile scoping); null = launch profile,
-      // which is right at create time — the new bot clones/copies from it.
-      await host.request('skills.manage', {
-        action: 'install',
-        query: name,
-        ...(forProfile ? { profile: forProfile } : {})
-      })
-      setInstalled(prev => ({ ...prev, [label]: true }))
-      host.notify({ kind: 'success', message: `Skill "${label}" installed` })
-
-      if (typeof onInstalled === 'function') {
-        onInstalled(label)
-      }
-    } catch (err) {
-      host.notifyError(err, `Installing "${label}" failed`)
-    } finally {
-      setInstalling(null)
-    }
-  }
-
-  installRef.current = install
-
-  return jsxs('div', {
-    className: 'grid gap-1.5 border-t border-(--ui-stroke-secondary) pt-2',
-    children: [
-      jsxs('div', {
-        className: 'flex items-baseline justify-between gap-2',
-        children: [
-          jsx('div', {
-            className: 'text-[0.7rem] font-medium text-(--ui-text-secondary)',
-            children: 'Skills Hub'
-          }),
-          jsx('button', {
-            type: 'button',
-            className: 'text-[0.65rem] text-(--ui-text-quaternary) hover:text-(--ui-text-secondary)',
-            onClick: () => setBrowseHub(v => !v),
-            children: browseHub ? 'hide the hub browser' : 'browse the full hub ▾'
-          })
-        ]
-      }),
-      browseHub
-        ? jsxs('div', {
-            className: 'grid gap-1',
-            children: [
-              // Resizable viewport: native CSS resize handle (bottom-right
-              // corner) lets the user drag it larger/smaller. The iframe
-              // inside is rendered oversized and scaled DOWN (133% × 0.75)
-              // so the hub page starts zoomed out — we can't style the
-              // cross-origin page itself, but scaling the frame is ours.
-              jsx('div', {
-                style: {
-                  width: '100%',
-                  height: 560,
-                  minHeight: 240,
-                  minWidth: 320,
-                  maxWidth: '100%',
-                  resize: 'both',
-                  overflow: 'hidden',
-                  border: '1px solid var(--ui-stroke-secondary)',
-                  borderRadius: 8,
-                  position: 'relative'
-                },
-                children: jsx('iframe', {
-                  src: HUB_PICKER_URL,
-                  title: 'Hermes Skills Hub',
-                  ref: frameRef,
-                  style: {
-                    width: '133.34%',
-                    height: '133.34%',
-                    border: 'none',
-                    background: 'transparent',
-                    transform: 'scale(0.75)',
-                    transformOrigin: 'top left'
-                  },
-                  sandbox: 'allow-scripts allow-same-origin'
-                })
-              }),
-              jsx('div', {
-                className: 'px-1 text-[0.65rem] leading-4 text-(--ui-text-quaternary)',
-                children:
-                  installing
-                    ? `Installing "${installing}"…`
-                    : 'Hit "+ Add to this Agent" on any skill — it installs and appears in the list above. Drag the corner to resize.'
-              })
-            ]
-          })
-        : null,
-      jsxs('div', {
-        className: 'flex gap-1.5',
-        children: [
-          jsx(Input, {
-            className: 'h-7 flex-1 text-xs',
-            placeholder: 'Search the hub (community + well-known sources)…',
-            value: query,
-            onChange: event => setQuery(event.target.value),
-            onKeyDown: event => {
-              // IME guard: Enter confirming a composed word must not search.
-              if (event.nativeEvent?.isComposing || event.keyCode === 229) {
-                return
-              }
-              if (event.key === 'Enter') {
-                event.preventDefault()
-                void search()
-              }
-            }
-          }),
-          jsx(Button, {
-            size: 'sm',
-            variant: 'secondary',
-            disabled: searching || !query.trim(),
-            onClick: () => void search(),
-            children: searching ? 'Searching…' : 'Search'
-          })
-        ]
-      }),
-      searching
-        ? jsx('div', {
-            className: 'px-1 text-[0.65rem] text-(--ui-text-quaternary)',
-            children: 'Searching community + well-known sources — can take ~10s…'
-          })
-        : null,
-      results === null
-        ? null
-        : results.length === 0
-          ? jsx('div', {
-              className: 'px-1 py-1.5 text-[0.7rem] text-(--ui-text-quaternary)',
-              children: 'No hub skills matched.'
-            })
-          : jsx(ScrollArea, {
-              className: 'hermes-scroll-cap',
-              style: { maxHeight: 150 },
-              children: jsx('div', {
-                className: 'grid gap-1',
-                children: results.map(r =>
-                  jsxs(
-                    'div',
-                    {
-                      className: 'flex items-center gap-2 text-xs',
-                      children: [
-                        jsxs('div', {
-                          className: 'min-w-0 flex-1',
-                          children: [
-                            jsx('div', { className: 'truncate font-medium', children: r.name }),
-                            r.description
-                              ? jsx('div', {
-                                  className: 'truncate text-[0.65rem] text-(--ui-text-quaternary)',
-                                  children: r.description
-                                })
-                              : null
-                          ]
-                        }),
-                        installed[r.name]
-                          ? jsx('span', {
-                              className: 'shrink-0 text-[0.65rem] text-(--ui-text-tertiary)',
-                              children: '✓ added'
-                            })
-                          : jsx(Button, {
-                              size: 'sm',
-                              variant: 'ghost',
-                              className: 'shrink-0 px-2 font-semibold',
-                              disabled: installing !== null,
-                              title: `Install "${r.name}" and add it to the list above`,
-                              onClick: () => void install(r.name),
-                              children: installing === r.name ? '…' : '+'
-                            })
-                      ]
-                    },
-                    r.name
-                  )
-                )
-              })
-            })
-    ]
-  })
-}
-
-function emptyAdvancedState() {
-  return {
-    loaded: false,
-    provider: '',
-    model: '',
-    soul: '',
-    skills: [],
-    toolsets: [],
-    mcp: [],
-    dirtyModel: false,
-    dirtySoul: false,
-    dirtySkills: false,
-    dirtyToolsets: false,
-    dirtyMcp: false
-  }
-}
-
-/** Persist only the dirty sections of the advanced editor. */
-async function applyAdvancedConfig(bot, state) {
-  const payload = { name: bot.name }
-  const applied = {}
-
-  if (state.dirtySoul) {
-    payload.soul = ensureMessagingProtocol(state.soul, bot.name, $lastRoster.get())
-  }
-
-  if (state.dirtyModel) {
-    const model = state.model.trim()
-    const provider = state.provider.trim()
-
-    if (model && provider) {
-      payload.model = model
-      payload.provider = provider
-    } else if (!model && !provider) {
-      try {
-        const result = await requestForBot(bot, 'cli.exec', {
-          argv: ['--profile', bot.name, 'config', 'unset', 'model']
-        })
-        applied.model = result?.blocked !== true && result?.code === 0
-      } catch {
-        applied.model = false
-      }
-    } else {
-      applied.model = false
-    }
-  }
-
-  if (state.dirtySkills) {
-    payload.disabled_skills = state.skills.filter(s => !s.enabled).map(s => s.name)
-  }
-
-  if (state.dirtyToolsets) {
-    const all = state.toolsets.length
-    const enabled = state.toolsets.filter(t => t.enabled)
-    // All enabled (or none) = clear the pin; otherwise pin the checked set.
-    payload.enabled_toolsets = enabled.length === all || enabled.length === 0 ? [] : enabled.map(t => t.name)
-  }
-
-  if (state.dirtyMcp) {
-    payload.enabled_mcp_servers = (state.mcp || []).filter(m => m.enabled).map(m => m.name)
-  }
-
-  if (Object.keys(payload).length === 1) {
-    return { ok: Object.values(applied).every(Boolean), applied }
-  }
-
-  const result = await requestForBot(bot, 'profiles.configure', payload)
-  const merged = { ...applied, ...(result?.applied || {}) }
-
-  // #95293 remainder: the gateway now guards data-policy / expensive models
-  // on THIS surface too — `confirm_required` means the model section is
-  // PENDING the user's confirmation, not failed. Route it through the SAME
-  // shared confirm handler the core picker uses (one applier, no forked
-  // confirm logic per surface): the Confirm action resends ONLY the model
-  // section with `confirm_expensive_model: true`.
-  if (result?.confirm_required && payload.model && payload.provider) {
-    delete merged.model
-    surfaceModelSwitchConfirm({
-      confirmLabel: 'Confirm',
-      confirmMessage: result.confirm_message,
-      failureMessage: 'Model switch failed',
-      finish: () => queryClient.invalidateQueries({ queryKey: ROSTER_KEY }),
-      requestConfirmed: () =>
-        requestForBot(bot, 'profiles.configure', {
-          name: bot.name,
-          model: payload.model,
-          provider: payload.provider,
-          confirm_expensive_model: true
-        })
-    })
-  }
-
-  return { ...result, ok: Object.values(merged).every(Boolean), applied: merged }
-}
-
-// ── edit profile dialog ──────────────────────────────────────────────────────
-
-function labeled(label, control) {
-  return jsxs('div', {
-    className: 'grid gap-1.5',
-    children: [
-      jsx('label', {
-        className: 'text-xs font-medium text-(--ui-text-secondary)',
-        children: label
-      }),
-      control
-    ]
-  })
-}
-
-function EditProfileDialog({ bot, open, onClose }) {
-  const metaAll = useValue($botMeta)
-  const meta = bot ? botRosterMeta(bot, metaAll) : null
-  const appearance = bot ? botAppearance(bot.name, meta) : { shape: 'circle', color: AVATAR_COLORS[3] }
-  const [shape, setShape] = useState(appearance.shape)
-  const [color, setColor] = useState(appearance.color)
-  const [image, setImage] = useState(appearance.image)
-  const [title, setTitle] = useState(meta?.title || '')
-  const [description, setDescription] = useState(bot?.description || '')
-  const [busy, setBusy] = useState(false)
-  const [advanced, setAdvanced] = useState(false)
-  const [adv, setAdv] = useState(emptyAdvancedState())
-
-  // Re-seed local state each time a different bot opens the dialog.
-  const [seedKey, setSeedKey] = useState(null)
-  const currentKey = bot ? `${botSelectionKey(bot)}:${open}` : null
-  if (currentKey !== seedKey) {
-    setSeedKey(currentKey)
-    if (bot && open) {
-      setShape(appearance.shape)
-      setColor(appearance.color)
-      setImage(appearance.image)
-      setTitle(meta?.title || '')
-      setDescription(bot.description || '')
-      setBusy(false)
-      setAdvanced(false)
-      setAdv(emptyAdvancedState())
-    }
-  }
-
-  if (!bot) {
-    return null
-  }
-
-  const submit = async () => {
-    if (busy) {
-      return
-    }
-
-    setBusy(true)
-    let advancedFailed = false
-    const persistence = await saveBotMeta(bot, {
-      shape,
-      color,
-      image,
-      imageKind: image ? 'photo' : 'shape',
-      title: title.trim(),
-      custom: true
-    })
-    // Only an explicit remote failure is an error — 'unsupported' is the
-    // documented older-gateway fallback (local wins, silently), and toasting
-    // it would flag every save on every legacy setup forever.
-    const lookFailed = persistence.serverOutcome === 'failed'
-
-    if (lookFailed) {
-      host.notify({ kind: 'error', message: 'Saved look locally; remote persistence failed' })
-    }
-    if (persistence.serverOutcome === 'persisted') {
-      queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-    }
-
-    const desc = description.trim()
-    if (desc !== (bot.description || '').trim()) {
-      try {
-        await requestForBot(bot, 'cli.exec', {
-          argv: ['profile', 'describe', bot.name, '--text', desc]
-        })
-        queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-      } catch (err) {
-        host.notifyError(err, 'Saved look locally; description update failed')
-      }
-    }
-
-    if (adv.loaded && (adv.dirtyModel || adv.dirtySoul || adv.dirtySkills || adv.dirtyToolsets || adv.dirtyMcp)) {
-      try {
-        const res = await applyAdvancedConfig(bot, adv)
-        const failed = Object.entries(res?.applied || {}).filter(([, ok]) => !ok)
-
-        if (failed.length) {
-          advancedFailed = true
-          host.notify({ kind: 'error', message: `Some sections failed: ${failed.map(([k]) => k).join(', ')}` })
-        }
-      } catch (err) {
-        advancedFailed = true
-        host.notifyError(err, 'Advanced configuration failed')
-      }
-    }
-
-    if (!advancedFailed && !lookFailed) {
-      host.notify({ kind: 'success', message: `${displayName(bot, { title })} updated` })
-    }
-    setBusy(false)
-    onClose()
-  }
-
-  return jsx(Dialog, {
-    open,
-    onOpenChange: value => !value && !busy && onClose(),
-    children: jsxs(DialogContent, {
-      className: advanced ? 'max-w-3xl' : 'max-w-sm',
-      // Same resizable-window treatment as the create dialog.
-      style: advanced
-        ? { resize: 'both', overflow: 'auto', minWidth: 420, minHeight: 360, maxWidth: '95vw', maxHeight: '90vh' }
-        : undefined,
-      children: [
-        jsxs(DialogHeader, {
-          children: [
-            jsx(DialogTitle, { children: 'Edit Profile' }),
-            jsx(DialogDescription, { children: `Appearance and role for ${displayName(bot, null)} (${bot.name}).` })
-          ]
-        }),
-        jsxs('div', {
-          className: 'grid gap-4',
-          children: [
-            jsx('div', {
-              className: 'flex justify-center py-1',
-              children: jsx(BotFace, { shape, color, image, size: 64, name: bot.name })
-            }),
-            jsx(AvatarPicker, {
-              shape,
-              color,
-              image,
-              onShape: setShape,
-              onColor: setColor,
-              onImage: setImage,
-              generateSeed: { name: bot.name, title, description }
-            }),
-            labeled(
-              'Title',
-              jsx(Input, {
-                placeholder: displayName(bot, null),
-                value: title,
-                onChange: event => setTitle(event.target.value)
-              })
-            ),
-            labeled(
-              'Description',
-              jsx(Textarea, {
-                className: 'min-h-16',
-                placeholder: 'What should this agent help with?',
-                value: description,
-                onChange: event => setDescription(event.target.value)
-              })
-            ),
-            jsxs('button', {
-              type: 'button',
-              className:
-                'flex items-center gap-1 text-xs font-medium text-(--ui-text-tertiary) hover:text-(--ui-text-secondary)',
-              onClick: () => setAdvanced(v => !v),
-              children: [
-                jsx(Codicon, { name: advanced ? 'chevron-down' : 'chevron-right', className: 'text-[0.8rem]' }),
-                'Advanced — model, skills, toolsets, SOUL.md'
-              ]
-            }),
-            advanced
-              ? jsx('div', {
-                  className: 'rounded-md border border-(--ui-stroke-secondary) p-3',
-                  children: jsx(AdvancedProfileConfig, { bot, state: adv, setState: setAdv })
-                })
-              : null
-          ]
-        }),
-        jsxs(DialogFooter, {
-          children: [
-            jsx(Button, { variant: 'ghost', disabled: busy, onClick: onClose, children: 'Cancel' }),
-            jsx(Button, { disabled: busy, onClick: submit, children: busy ? 'Saving…' : 'Save' })
-          ]
-        })
-      ]
-    })
-  })
-}
-
-// ── create dialog ────────────────────────────────────────────────────────────
-
-function CreateAgentDialog({ open, onClose, roster }) {
-  const [name, setName] = useState('')
-  // Create mode: the profile is created LAZILY. Capability toggles are staged in
-  // component state; the profile is materialized either on Create (submit) or on
-  // the first MCP credential setup (ensureAgentCreated), whichever comes first —
-  // so OAuth / API-key setup works DURING creation, not only after in Edit.
-  const createdRef = useRef(null)
-  // In-flight profiles.create shared across concurrent triggers (Create
-  // button + MCP setup buttons). Distinct from createdRef on purpose:
-  // createdRef must stay a slug string for its sibling consumers.
-  const flightRef = useRef(null)
-  const [title, setTitle] = useState('')
-  const [description, setDescription] = useState('')
-  // Default shapes mode: deterministic blob face drawn from the agent's name
-  // (falls back to the legacy shape vocabulary on older SDKs).
-  const [shape, setShape] = useState(blobatarSvg ? 'blobatar' : 'circle')
-  const [color, setColor] = useState(AVATAR_COLORS[3])
-  const [image, setImage] = useState(null)
-  const [advanced, setAdvanced] = useState(false)
-  const [cloneFrom, setCloneFrom] = useState('default')
-  const [model, setModel] = useState('')
-  const [provider, setProvider] = useState('')
-  const [soul, setSoul] = useState('')
-  const [noSkills, setNoSkills] = useState(false)
-  const [shareAuth, setShareAuth] = useState(true)
-  const [advTab, setAdvTab] = useState('general')
-  // Where the profile is created: '' = the active gateway (unchanged default),
-  // else a registry connection id — the profiles.create lands on THAT
-  // machine's backend via host.requestProfile, no gateway switch. Only
-  // rendered when the desktop has a multi-connection registry.
-  const [targetConnection, setTargetConnection] = useState('')
-  const [connections, setConnections] = useState(null)
-
-  useEffect(() => {
-    if (!open || connections !== null || typeof host.connections !== 'function' || typeof host.requestProfile !== 'function') {
-      return
-    }
-
-    host
-      .connections()
-      // host.connections() returns the registry ROWS on current SDKs, but the
-      // envelope object ({version, primary, connections: [...]}) on desktops
-      // that predate the SDK-side unwrap — accept both shapes.
-      .then(value => setConnections(Array.isArray(value) ? value : Array.isArray(value?.connections) ? value.connections : []))
-      .catch(() => setConnections([]))
-  }, [open, connections])
-
-  const activeConnectionId = String(host.state?.connectionId?.get?.() || '').trim()
-  // Remote target = an explicitly picked registry connection that is not the
-  // one this window is already on.
-  const remoteTarget = Boolean(targetConnection) && targetConnection !== (activeConnectionId || 'local')
-  const targetLabel = remoteTarget
-    ? (connections || []).find(c => c.id === targetConnection)?.label || targetConnection
-    : ''
-
-  /** Gateway RPC on the create target: the picked connection's default
-   *  backend for remote targets, the active gateway otherwise. */
-  const requestForTarget = (method, params = {}) =>
-    remoteTarget
-      ? host.requestProfile(
-          { connectionId: targetConnection, mode: 'remote', profile: 'default', targetProfile: 'default' },
-          method,
-          params
-        )
-      : host.request(method, params)
-
-  // Set once ensureAgentCreated() materializes the profile for the live
-  // Capabilities tab (SkillsView needs a real backend to point at). State —
-  // not just createdRef — because the render must flip when it lands.
-  const [createdForCaps, setCreatedForCaps] = useState(null)
-  const [caps, setCaps] = useState(null)
-  const [capsFailed, setCapsFailed] = useState(false)
-  const [dirtyCaps, setDirtyCaps] = useState({ skills: false, toolsets: false, mcp: false })
-  const [capFilter, setCapFilter] = useState('')
-  const [busy, setBusy] = useState(false)
-  const [error, setError] = useState(null)
-
-  const slug = slugify(name)
-  const valid = slug.length > 0 && NAME_RE.test(slug)
-  // Once the draft profile is materialized (Capabilities tab / MCP setup) it
-  // shows up in the roster — its OWN slug must not read as "taken".
-  // A remote-target create is gated by the TARGET machine's roster: a local
-  // name clash is fine there, and the remote's own duplicate check rejects
-  // real collisions at profiles.create time.
-  const taken = remoteTarget
-    ? roster.some(b => b.remoteSource && b.connectionId === targetConnection && b.name === slug && b.name !== createdRef.current)
-    : roster.some(b => !b.remoteSource && b.name === slug && b.name !== createdRef.current)
-
-  // Draft semantics for the lazily-created profile: opening the Capabilities
-  // tab (or running MCP setup) materializes the profile so the LIVE config
-  // surfaces have a real backend to write to — but until the user hits
-  // Create Agent it is a DRAFT. Cancelling the dialog deletes it, so
-  // preconfigure-then-back-out leaves zero residue. Best-effort and
-  // fire-and-forget: a failed cleanup surfaces a toast, never blocks close.
-  const discardDraft = () => {
-    const draft = createdRef.current
-
-    if (!draft) {
-      return
-    }
-
-    createdRef.current = null
-    flightRef.current = null
-    const discard = remoteTarget
-      ? requestForTarget('cli.exec', { argv: ['profile', 'delete', draft, '--yes'] })
-      : deleteBot({ name: draft })
-    void Promise.resolve(discard)
-      .then(() => host.notify({ kind: 'success', message: `Draft agent "${draft}" discarded` }))
-      .catch(err => host.notifyError(err, `Could not clean up draft profile "${draft}"`))
-  }
-
-  const reset = () => {
-    setName('')
-    setTitle('')
-    setDescription('')
-    setShape(blobatarSvg ? 'blobatar' : 'circle')
-    setColor(AVATAR_COLORS[3])
-    setImage(null)
-    setAdvanced(false)
-    // Same default as the initial useState — resetting to '__none__' made
-    // the second agent you create silently start from a fresh profile
-    // instead of cloning the main one like the first dialog open did.
-    setCloneFrom('default')
-    setModel('')
-    setProvider('')
-    setSoul('')
-    setNoSkills(false)
-    setShareAuth(true)
-    setAdvTab('general')
-    setCreatedForCaps(null)
-    setCaps(null)
-    setCapsFailed(false)
-    setDirtyCaps({ skills: false, toolsets: false, mcp: false })
-    setCapFilter('')
-    setTargetConnection('')
-    setBusy(false)
-    setError(null)
-    createdRef.current = null
-    flightRef.current = null
-  }
-
-  // Capability catalog for the tabs: the profile doesn't exist yet, so show
-  // what it WILL have — the clone source's catalog, else the main profile's.
-  const capSource = cloneFrom === '__none__' ? 'default' : cloneFrom
-  const ensureCaps = () => {
-    if ((caps && caps.source === capSource) || capsFailed) {
-      return
-    }
-
-    Promise.all([
-      requestForTarget('profiles.describe', { name: remoteTarget ? 'default' : capSource }),
-      requestForTarget('mcp.catalog', {}).catch(() => null)
-    ])
-      .then(([res, cat]) => {
-        // Full MCP menu = the profile's configured servers + the bundled
-        // catalog (installable). Configured entries win on name clash.
-        const configured = res.mcp_servers || []
-        const have = new Set(configured.map(m => m.name))
-        const catalog = ((cat && cat.servers) || []).filter(s => !have.has(s.name))
-
-        setCaps({
-          source: capSource,
-          skills: res.skills || [],
-          toolsets: res.toolsets || [],
-          mcp: [
-            ...configured,
-            ...catalog.map(s => ({
-              name: s.name,
-              enabled: false,
-              fromCatalog: true,
-              installed: s.installed,
-              auth: s.auth,
-              requires: s.requires || [],
-              description: s.description || ''
-            }))
-          ]
-        })
-      })
-      .catch(() => setCapsFailed(true))
-  }
-
-  const toggleCap = (kind, name, enabled) => {
-    setDirtyCaps(prev => ({ ...prev, [kind === 'mcp' ? 'mcp' : kind]: true }))
-    setCaps(prev =>
-      prev
-        ? { ...prev, [kind]: prev[kind].map(x => (x.name === name ? { ...x, enabled } : x)) }
-        : prev
-    )
-  }
-
-  // Materialize the profile exactly once. createdRef stores the finished slug
-  // (its consumers — the taken check, draft discard on cancel, the MCP setup
-  // button's profile param — all read a string); flightRef shares the
-  // in-flight creation promise so simultaneous MCP setup / Create clicks fire
-  // ONE profiles.create. A settled flight clears its slot: failures retry,
-  // and a null result (form invalid at flight time) isn't sticky.
-  const ensureAgentCreated = () => {
-    // Renamed since the draft materialized? The old draft is orphaned —
-    // discard it and create fresh under the new slug.
-    if (createdRef.current && createdRef.current !== slug) {
-      discardDraft()
-      setCreatedForCaps(null)
-    }
-
-    if (createdRef.current) {
-      return Promise.resolve(createdRef.current)
-    }
-
-    const flight = singleFlight(flightRef, async () => {
-      if (!valid || taken) {
-        return null
-      }
-
-      const descriptionText = [title, description].filter(Boolean).join(' — ')
-
-      await requestForTarget('profiles.create', {
-        name: slug,
-        description: descriptionText,
-        // Clone sources are profiles of the TARGET backend. The picker's
-        // roster is the local one, so a remote create always starts from the
-        // remote machine's default (or fresh) — never a local profile name
-        // the remote box doesn't have.
-        clone_from: cloneFrom === '__none__' ? null : remoteTarget ? 'default' : cloneFrom,
-        no_skills: noSkills,
-        // Shared (not copied) auth keeps ONE OAuth/token pool with the main
-        // profile, so refreshes can't invalidate each other. Older gateways
-        // ignore the param and copy — still functional, just forked.
-        share_auth: shareAuth,
-        soul: composeSoul({ name: slug, title, description, roster, customSoul: soul }),
-        ...(model.trim() && provider.trim() ? { model: model.trim(), provider: provider.trim() } : {})
-      })
-
-      createdRef.current = slug
-
-      // Apply capability picks from the Advanced tabs (best-effort; the
-      // profile exists either way and Edit Profile can finish the job).
-      try {
-        const capPayload = {}
-
-        if (dirtyCaps.skills && caps) {
-          capPayload.disabled_skills = caps.skills.filter(s => !s.enabled).map(s => s.name)
-        }
-        if (dirtyCaps.toolsets && caps) {
-          const en = caps.toolsets.filter(t => t.enabled)
-          capPayload.enabled_toolsets =
-            en.length === caps.toolsets.length || en.length === 0 ? [] : en.map(t => t.name)
-        }
-        if (dirtyCaps.mcp && caps) {
-          capPayload.enabled_mcp_servers = caps.mcp.filter(m => m.enabled).map(m => m.name)
-        }
-        if (Object.keys(capPayload).length) {
-          await requestForTarget('profiles.configure', { name: slug, ...capPayload })
-        }
-      } catch {
-        /* capability application is best-effort */
-      }
-
-      if (remoteTarget) {
-        // The bot lives on ANOTHER machine — local bot-meta is scoped to the
-        // active gateway, so write appearance/title into the remote
-        // profile's ui_meta (and asset store) directly. Best-effort: the
-        // profile exists either way.
-        const { image: avatarImage, ...look } = {
-          shape,
-          color,
-          image,
-          imageKind: image ? 'photo' : 'shape',
-          title: title.trim(),
-          created: Date.now()
-        }
-
-        try {
-          void requestForTarget('profiles.configure', { name: slug, ui_meta: { 'hermes-bots': look } }).catch(() => undefined)
-
-          if (avatarImage) {
-            void requestForTarget('profiles.set_asset', { name: slug, asset: 'avatar', data: avatarImage }).catch(() => undefined)
-          }
-        } catch {
-          /* older remote gateway */
-        }
-      } else {
-        saveBotMeta(slug, { shape, color, image, imageKind: image ? 'photo' : 'shape', title: title.trim(), created: Date.now() })
-      }
-
-      queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-      return slug
-    })
-
-    return flight
-  }
-
-  const submit = async () => {
-    if (!valid || taken || busy) {
-      return
-    }
-
-    setBusy(true)
-    setError(null)
-
-    try {
-      const slugCreated = await ensureAgentCreated()
-      if (!slugCreated) {
-        setBusy(false)
-        setError('Could not create the agent.')
-        return
-      }
-
-      host.notify({
-        kind: 'success',
-        message: remoteTarget
-          ? `Bot "${displayName({ name: slug, title })}" created on ${targetLabel}`
-          : `Bot "${displayName({ name: slug, title })}" created`
-      })
-      const wasRemote = remoteTarget
-      reset()
-      onClose()
-
-      if (wasRemote) {
-        // The bot lives on another machine: it appears in the roster via the
-        // union enumeration; chat routes through its own source. No local
-        // canonical chat to birth here.
-        queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-        return
-      }
-
-      $selectedBot.set(slug)
-
-      // Birth the bot's forever chat right away: it introduces itself as
-      // the first thing the user sees, and the pin exists from minute one.
-      try {
-        // Creates, pins, opens, and kicks off the intro in one flow. This is
-        // the ONE caller allowed to request the intro turn — genuine New
-        // Agent creation. Click-path resolution (openBotCanonicalChat) mints
-        // silently so a resolution miss never burns a turn (ScottFive).
-        const sid = await createCanonicalChat(slug, { kickoff: true })
-
-        if (!sid && typeof host.newChat === 'function') {
-          host.newChat(slug)
-        }
-      } catch {
-        if (typeof host.newChat === 'function') {
-          host.newChat(slug)
-        }
-      }
-    } catch (err) {
-      setBusy(false)
-      setError(err instanceof Error ? err.message : String(err))
-    }
-  }
-
-  return jsx(Dialog, {
-    open,
-    onOpenChange: value => {
-      if (!value && !busy) {
-        // Cancel path (esc / overlay click): a materialized draft profile is
-        // discarded — preconfigure-then-back-out leaves nothing behind.
-        discardDraft()
-        reset()
-        onClose()
-      }
-    },
-    children: jsxs(DialogContent, {
-      className: advanced ? 'max-w-3xl' : 'max-w-md',
-      // Native resize handle (bottom-right corner): the dialog becomes a
-      // window the user can grow/shrink. overflow:auto is required for CSS
-      // resize to engage; caps keep it on screen.
-      style: advanced
-        ? { resize: 'both', overflow: 'auto', minWidth: 420, minHeight: 360, maxWidth: '95vw', maxHeight: '90vh' }
-        : undefined,
-      children: [
-        jsxs(DialogHeader, {
-          children: [
-            jsx(DialogTitle, { children: 'New Bot' }),
-            jsx(DialogDescription, {
-              children: 'A named teammate with its own memory, skills, and chat. It can message your other agents.'
-            })
-          ]
-        }),
-        jsxs('div', {
-          className: 'grid gap-3.5',
-          children: [
-            jsx('div', {
-              className: 'flex justify-center py-1',
-              children: jsx(BotFace, { shape, color, image, size: 56, name: slug || 'agent' })
-            }),
-            jsx(AvatarPicker, {
-              shape,
-              color,
-              image,
-              onShape: setShape,
-              onColor: setColor,
-              onImage: setImage,
-              generateSeed: { name: slug || 'agent', title, description }
-            }),
-            labeled(
-              'Name',
-              jsx(Input, {
-                autoFocus: true,
-                placeholder: 'inbox-triage',
-                value: name,
-                onChange: event => setName(event.target.value)
-              })
-            ),
-            taken
-              ? jsx('div', {
-                  className: 'text-xs text-(--ui-accent)',
-                  children: remoteTarget
-                    ? `An agent named "${slug}" already exists on ${targetLabel}.`
-                    : `An agent named "${slug}" already exists.`
-                })
-              : null,
-            // Multi-connection desktops choose WHERE the agent lives. Hidden
-            // on single-connection setups — the active gateway is the only
-            // possible home, exactly the old behavior.
-            Array.isArray(connections) && connections.length > 1
-              ? labeled(
-                  'Create on',
-                  jsxs(Select, {
-                    value: targetConnection || activeConnectionId || 'local',
-                    onValueChange: value => {
-                      setTargetConnection(value === (activeConnectionId || 'local') ? '' : value)
-                      // The capability catalog and clone list belong to the
-                      // target backend — refetch for the new home. The live
-                      // Capabilities tab re-pins to it via fixedConnection on
-                      // builds that route it (staged checklists otherwise).
-                      setCaps(null)
-                      setCapsFailed(false)
-                      setAdvTab('general')
-                    },
-                    children: [
-                      jsx(SelectTrigger, {
-                        className: 'h-8 rounded-md',
-                        children: jsx(SelectValue, {})
-                      }),
-                      jsx(SelectContent, {
-                        children: connections.map(connection =>
-                          jsx(
-                            SelectItem,
-                            {
-                              value: connection.id,
-                              children:
-                                connection.id === (activeConnectionId || 'local')
-                                  ? `${connection.label || connection.id} (current)`
-                                  : connection.label || connection.id
-                            },
-                            connection.id
-                          )
-                        )
-                      })
-                    ]
-                  })
-                )
-              : null,
-            remoteTarget
-              ? jsx('div', {
-                  className: 'text-[0.7rem] leading-5 text-(--ui-text-tertiary)',
-                  children: `The agent is created on ${targetLabel} and appears in the roster as a Connections bot. Chat routes to that machine.`
-                })
-              : null,
-            labeled(
-              'Title',
-              jsx(Input, {
-                placeholder: 'Inbox Triage',
-                value: title,
-                onChange: event => setTitle(event.target.value)
-              })
-            ),
-            labeled(
-              'Description',
-              jsx(Textarea, {
-                className: 'min-h-16',
-                placeholder: 'What should this Bot help with?',
-                value: description,
-                onChange: event => setDescription(event.target.value)
-              })
-            ),
-            jsxs('button', {
-              type: 'button',
-              className:
-                'flex items-center gap-1 text-xs font-medium text-(--ui-text-tertiary) hover:text-(--ui-text-secondary)',
-              onClick: () => {
-                setAdvanced(v => {
-                  if (!v) {
-                    ensureCaps()
-                  }
-                  return !v
-                })
-              },
-              children: [
-                jsx(Codicon, { name: advanced ? 'chevron-down' : 'chevron-right', className: 'text-[0.8rem]' }),
-                'Advanced'
-              ]
-            }),
-            advanced
-              ? jsxs('div', {
-                  className: 'grid gap-3 rounded-md border border-(--ui-stroke-secondary) p-3',
-                  children: [
-                    jsx('div', {
-                      className: 'flex gap-1',
-                      // Newer desktops export the whole Capabilities surface —
-                      // one live tab replaces the three staged checklists.
-                      // The live Capabilities surface (SkillsView) binds to
-                      // the ACTIVE gateway's backend unless this build routes
-                      // fixedConnection (skillsViewRoutesConnections) — then a
-                      // remote-target draft gets the live surface pinned to
-                      // ITS machine. Builds without that routing keep the
-                      // staged checklists for remote targets (their catalog
-                      // reads already route to the target).
-                      children: (SkillsView && (!remoteTarget || skillsViewRoutesConnections)
-                        ? [
-                            ['general', 'General'],
-                            ['capabilities', 'Capabilities']
-                          ]
-                        : [
-                            ['general', 'General'],
-                            ['skills', 'Skills'],
-                            ['toolsets', 'Tools'],
-                            ['mcp', 'MCP']
-                          ]
-                      ).map(([id, label]) =>
-                        jsx(
-                          'button',
-                          {
-                            type: 'button',
-                            className: cn(
-                              'rounded-md px-2.5 py-1 text-xs font-medium transition-colors',
-                              advTab === id
-                                ? 'bg-(--chrome-action-hover) text-(--ui-text-primary)'
-                                : 'text-(--ui-text-tertiary) hover:text-(--ui-text-secondary)'
-                            ),
-                            onClick: () => {
-                              setAdvTab(id)
-                              setCapFilter('')
-                              if (id === 'capabilities') {
-                                // The live surface needs a real profile —
-                                // materialize it now (same lazy-create door
-                                // the MCP setup buttons use).
-                                void ensureAgentCreated()
-                                  .then(created => created && setCreatedForCaps(created))
-                                  .catch(err => host.notifyError(err, 'Could not create the profile yet'))
-                              } else if (id !== 'general') {
-                                ensureCaps()
-                              }
-                            },
-                            children: label
-                          },
-                          id
-                        )
-                      )
-                    }),
-                    advTab === 'general'
-                      ? jsxs('div', {
-                          className: 'grid gap-3.5',
-                          children: [
-                            labeled(
-                              remoteTarget ? `Clone from profile (on ${targetLabel})` : 'Clone from profile',
-                              jsxs(Select, {
-                                disabled: remoteTarget,
-                                value: remoteTarget ? 'default' : cloneFrom,
-                                onValueChange: value => {
-                                  setCloneFrom(value)
-                                  setCaps(null)
-                                  setCapsFailed(false)
-                                },
-                                children: [
-                                  jsx(SelectTrigger, {
-                                    className: 'h-8 rounded-md',
-                                    children: jsx(SelectValue, {})
-                                  }),
-                                  jsxs(SelectContent, {
-                                    children: [
-                                      jsx(SelectItem, {
-                                        value: '__none__',
-                                        children: 'Fresh profile (bundled skills)'
-                                      }),
-                                      ...roster.map(b => jsx(SelectItem, { value: b.name, children: b.name }, b.name))
-                                    ]
-                                  })
-                                ]
-                              })
-                            ),
-                            jsx(ModelPicker, {
-                              value: { provider, model },
-                              onChange: patch => {
-                                if ('provider' in patch) {
-                                  setProvider(patch.provider)
-                                }
-                                if ('model' in patch) {
-                                  setModel(patch.model)
-                                }
-                              },
-                              placeholderModel: 'inherited from launch profile'
-                            }),
-                            labeled(
-                              'SOUL.md (optional — replaces the generated persona)',
-                              jsx(Textarea, {
-                                className: 'min-h-24 font-mono text-xs leading-5',
-                                placeholder:
-                                  'Leave blank to auto-generate from name/title/description + agent-messaging roster.',
-                                value: soul,
-                                onChange: event => setSoul(event.target.value)
-                              })
-                            ),
-                            jsxs('label', {
-                              className: 'flex items-center gap-2 text-xs text-(--ui-text-secondary)',
-                              children: [
-                                jsx(Checkbox, {
-                                  checked: shareAuth,
-                                  onCheckedChange: value => setShareAuth(Boolean(value))
-                                }),
-                                'Share keys & accounts with the main profile'
-                              ]
-                            }),
-                            jsx('div', {
-                              className: 'pl-6 pt-0.5 text-[0.7rem] leading-5 text-(--ui-text-tertiary)',
-                              children:
-                                'Subscriptions, OAuth logins, and API keys stay shared (not copied), so token refreshes never invalidate each other. Uncheck for an isolated snapshot copy.'
-                            }),
-                            jsxs('label', {
-                              className: 'flex items-center gap-2 text-xs text-(--ui-text-secondary)',
-                              children: [
-                                jsx(Checkbox, {
-                                  checked: noSkills,
-                                  onCheckedChange: value => setNoSkills(Boolean(value))
-                                }),
-                                'Create empty (skip bundled skills)'
-                              ]
-                            })
-                          ]
-                        })
-                      : advTab === 'capabilities'
-                        ? !valid || taken
-                          ? jsx('div', {
-                              className: 'px-2 py-3 text-center text-xs text-(--ui-text-tertiary)',
-                              children: taken
-                                ? 'That name is taken — pick another before configuring capabilities.'
-                                : 'Name the bot first — a draft profile is created when you open this tab (discarded if you cancel).'
-                            })
-                          : !createdForCaps
-                            ? jsx('div', {
-                                className: 'flex justify-center py-4',
-                                children: jsx(GlyphSpinner, {
-                                  spinner: 'breathe',
-                                  className: 'text-(--ui-text-tertiary)'
-                                })
-                              })
-                            : jsx('div', {
-                                className: 'overflow-hidden rounded-md border border-(--ui-stroke-secondary)',
-                                style: { height: 440, minHeight: 280, resize: 'vertical', overflow: 'auto' },
-                                // The REAL core Capabilities surface (skills +
-                                // one-click hub installs + tools + MCP), pinned
-                                // to the just-created profile — and, for a
-                                // remote-target draft, to the target machine's
-                                // backend via fixedConnection. Writes land
-                                // immediately — no staging needed.
-                                children: jsx(SkillsView, {
-                                  embedded: true,
-                                  fixedProfile: createdForCaps,
-                                  ...(remoteTarget ? { fixedConnection: targetConnection } : {})
-                                })
-                              })
-                      : capsFailed
-                        ? jsx('div', {
-                            className: 'px-2 py-3 text-center text-xs text-(--ui-text-tertiary)',
-                            children:
-                              'Capability catalog needs a newer gateway (restart it after updating Hermes).'
-                          })
-                        : !caps
-                          ? jsx('div', {
-                              className: 'flex justify-center py-4',
-                              children: jsx(GlyphSpinner, {
-                                spinner: 'breathe',
-                                className: 'text-(--ui-text-tertiary)'
-                              })
-                            })
-                          : advTab === 'skills'
-                            ? noSkills
-                              ? jsx('div', {
-                                  className: 'px-2 py-3 text-center text-xs text-(--ui-text-tertiary)',
-                                  children: '“Create empty” is checked — no bundled skills will be installed.'
-                                })
-                              : jsxs('div', {
-                                  className: 'grid gap-1.5',
-                                  children: [
-                                    jsx(Input, {
-                                      className: 'h-7 text-xs',
-                                      placeholder: 'Filter skills…',
-                                      value: capFilter,
-                                      onChange: event => setCapFilter(event.target.value)
-                                    }),
-                                    jsx(ScrollArea, {
-                                      className: 'hermes-scroll-cap',
-                                      style: { maxHeight: 200 },
-                                      children: jsx(CheckList, {
-                                        items: capFilter.trim()
-                                          ? caps.skills.filter(s =>
-                                              s.name.toLowerCase().includes(capFilter.trim().toLowerCase())
-                                            )
-                                          : caps.skills,
-                                        onToggle: (name, enabled) => toggleCap('skills', name, enabled),
-                                        columns: 2
-                                      })
-                                    }),
-                                    jsx('div', {
-                                      className: 'text-[0.65rem] leading-4 text-(--ui-text-quaternary)',
-                                      children: `Catalog from ${caps.source} — unchecked skills are disabled after creation.`
-                                    }),
-                                    jsx(HubSkillsSection, {
-                                      forProfile: null,
-                                      onInstalled: name =>
-                                        setCaps(prev =>
-                                          !prev || prev.skills.some(s => s.name === name)
-                                            ? prev
-                                            : { ...prev, skills: [...prev.skills, { name, enabled: true }] }
-                                        )
-                                    })
-                                  ]
-                                })
-                            : advTab === 'toolsets'
-                              ? jsxs('div', {
-                                  className: 'grid gap-1.5',
-                                  children: [
-                                    jsx(ScrollArea, {
-                                      className: 'hermes-scroll-cap',
-                                      style: { maxHeight: 200 },
-                                      children: jsx(CheckList, {
-                                        items: caps.toolsets,
-                                        onToggle: (name, enabled) => toggleCap('toolsets', name, enabled),
-                                        columns: 2
-                                      })
-                                    }),
-                                    jsx('div', {
-                                      className: 'text-[0.65rem] leading-4 text-(--ui-text-quaternary)',
-                                      children: 'Leaving all (or none) checked keeps the default toolset behavior.'
-                                    })
-                                  ]
-                                })
-                              : caps.mcp.length === 0
-                                ? jsx('div', {
-                                    className: 'px-2 py-3 text-center text-xs text-(--ui-text-tertiary)',
-                                    children: 'No MCP servers configured or in the catalog.'
-                                  })
-                                : jsxs('div', {
-                                    className: 'grid gap-1.5',
-                                    children: [
-                                      jsx(ScrollArea, {
-                                        className: 'hermes-scroll-cap',
-                                        style: { maxHeight: 200 },
-                                        children: jsx('div', {
-                                          className: 'grid gap-1',
-                                          children: caps.mcp.map(m => {
-                                            const needsSetup =
-                                              m.fromCatalog && !m.installed && ((m.requires || []).length > 0 || (m.auth || '').toLowerCase() === 'oauth')
-
-                                            return jsxs(
-                                              'label',
-                                              {
-                                                className: 'flex items-start gap-2 text-xs text-(--ui-text-secondary)',
-                                                children: [
-                                                  jsx(Checkbox, {
-                                                    checked: !!m.enabled,
-                                                    disabled: needsSetup,
-                                                    onCheckedChange: value => toggleCap('mcp', m.name, Boolean(value))
-                                                  }),
-                                                  jsxs('span', {
-                                                    className: 'min-w-0',
-                                                    children: [
-                                                      jsx('span', { children: m.name }),
-                                                      m.fromCatalog && !needsSetup
-                                                        ? jsx('span', {
-                                                            className: 'ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)',
-                                                            children: m.installed
-                                                              ? 'catalog · installed'
-                                                              : 'catalog'
-                                                          })
-                                                        : null,
-                                                      needsSetup
-                                                        ? jsx(McpSetupButton, {
-                                                            profile: createdRef.current,
-                                                            entry: m,
-                                                            ensureProfile: ensureAgentCreated,
-                                                            onDone: () => {
-                                                              // Setup done: mark installed so the row's
-                                                              // checkbox un-disables, and enable it.
-                                                              setCaps(prev =>
-                                                                prev
-                                                                  ? {
-                                                                      ...prev,
-                                                                      mcp: prev.mcp.map(x =>
-                                                                        x.name === m.name
-                                                                          ? { ...x, installed: true, enabled: true }
-                                                                          : x
-                                                                      )
-                                                                    }
-                                                                  : prev
-                                                              )
-                                                              setDirtyCaps(prev => ({ ...prev, mcp: true }))
-                                                            }
-                                                          })
-                                                        : null,
-                                                      m.description
-                                                        ? jsx('div', {
-                                                            className:
-                                                              'truncate text-[0.65rem] leading-4 text-(--ui-text-quaternary)',
-                                                            children: m.description
-                                                          })
-                                                        : null
-                                                    ]
-                                                  })
-                                                ]
-                                              },
-                                              m.name
-                                            )
-                                          })
-                                        })
-                                      }),
-                                      jsx('div', {
-                                        className: 'text-[0.65rem] leading-4 text-(--ui-text-quaternary)',
-                                        children:
-                                          'Configured servers copy from the main profile; catalog entries are the bundled MCP menu. Entries needing API keys route through setup first (credentials follow the shared keys setting).'
-                                      })
-                                    ]
-                                  })
-                  ]
-                })
-              : null,
-            error
-              ? jsx('div', {
-                  className: 'rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs text-(--ui-accent)',
-                  children: error
-                })
-              : null
-          ]
-        }),
-        jsxs(DialogFooter, {
-          children: [
-            jsx(Button, {
-              variant: 'ghost',
-              disabled: busy,
-              onClick: () => {
-                discardDraft()
-                reset()
-                onClose()
-              },
-              children: 'Cancel'
-            }),
-            jsx(Button, {
-              disabled: busy || !valid || taken,
-              onClick: submit,
-              children: busy ? 'Creating…' : 'Create Bot'
-            })
-          ]
-        })
-      ]
-    })
-  })
-}
-
-// ── routines (cron) ──────────────────────────────────────────────────────────
-//
-// Jobs are namespaced "[bot:<name>] <routine>". A job running in the active
-// bot profile uses the plain instruction; a different profile keeps the
-// hermes -p <bot> chat delegation wrapper so the run reaches that bot's
-// history. The tile follows the bot you're chatting with (gateway profile).
-const BOT_TAG_RE = /^\[bot:([a-z0-9][a-z0-9_-]*)\]\s*/i
-const SAFE_ROUTINE_MARKER = '[bot-mode:routine:v2] '
-const LEGACY_DELEGATED_ROUTINE_PREFIX = 'You are running the scheduled routine "'
-
-function routineBot(job) {
-  const match = BOT_TAG_RE.exec(job?.name || '')
-  return match ? match[1].toLowerCase() : null
-}
-
-function routineTitle(job) {
-  return (job?.name || '').replace(BOT_TAG_RE, '') || 'Untitled cronjob'
-}
-
-function isLegacyDelegatedRoutine(job) {
-  const preview = typeof job?.prompt_preview === 'string' ? job.prompt_preview : job?.prompt
-  return Boolean(routineBot(job) && typeof preview === 'string' && preview.startsWith(LEGACY_DELEGATED_ROUTINE_PREFIX))
-}
-
-async function loadRoutines(owner) {
-  const bot = typeof owner === 'string' ? { name: owner } : owner
-  const profile = String(bot?.name || '').trim()
-  // profile scopes cron.manage to that bot's own cron store (core RPC gained an
-  // optional `profile` param). Older gateways ignore the unknown param and
-  // return the launch-profile store — the [bot:] tag filter in selectRoutineJobs
-  // remains the graceful fallback there.
-  const scope = profile ? { profile } : {}
-  const data = await requestForBot(bot, 'cron.manage', { action: 'list', include_disabled: true, ...scope })
-  const jobs = Array.isArray(data?.jobs) ? data.jobs : []
-  const activeLegacyJobs = jobs.filter(
-    job => isLegacyDelegatedRoutine(job) && job.enabled !== false && job.state !== 'paused'
-  )
-
-  // A pause failing must not fail the LIST — the pane would report "could
-  // not load cronjobs" over data that loaded fine, and the 20s poll would
-  // re-attempt the failing pause inside a failing query forever. Each pause
-  // swallows its own error; the overlay only claims jobs the gateway
-  // actually paused, and the next poll retries the rest.
-  const pauses = await Promise.all(
-    activeLegacyJobs.map(job =>
-      requestForBot(bot, 'cron.manage', { action: 'pause', name: job.job_id, ...scope })
-        .then(() => true)
-        .catch(() => false)
-    )
-  )
-
-  if (!activeLegacyJobs.length) {
-    return data
-  }
-
-  const pausedIds = new Set(activeLegacyJobs.filter((job, index) => pauses[index]).map(job => job.job_id))
-  return {
-    ...data,
-    jobs: jobs.map(job => (pausedIds.has(job.job_id) ? { ...job, enabled: false, state: 'paused' } : job))
-  }
-}
-
-function useRoutines(owner) {
-  const bot = typeof owner === 'string' ? { name: owner } : owner
-  const route = botConnectionRoute(bot)
-  const key = route ? botRosterKey(bot) : bot?.name || ''
-
-  return useQuery({
-    queryKey: [...ROUTINES_KEY, key],
-    queryFn: () => loadRoutines(bot),
-    enabled: Boolean(bot?.name),
-    refetchInterval: 20000,
-    staleTime: 8000
-  })
-}
-
-function routineCreateTarget(owner, activeBot) {
-  return owner || activeBot
-}
-
-async function invalidateRoutineOwner(owner) {
-  const bot = typeof owner === 'string' ? { name: owner } : owner
-  const route = botConnectionRoute(bot)
-  const key = route ? botRosterKey(bot) : bot?.name || ''
-
-  await queryClient.invalidateQueries({
-    queryKey: [...ROUTINES_KEY, key],
-    exact: true
-  })
-}
-
-/** Pick which cron jobs to show. A failed refresh keeps the last good list. */
-function selectRoutineJobs(data, error, lastJobs, bot) {
-  const live = Array.isArray(data?.jobs) ? data.jobs : null
-  const all = live ?? (error ? lastJobs : [])
-  const scopedToBot = normalizedProfileName(data?.scoped) === normalizedProfileName(bot)
-  return {
-    live,
-    all,
-    jobs: scopedToBot ? all : all.filter(job => (routineBot(job) || 'default') === bot)
-  }
-}
-
-/**
- * Why the Routines pane can be empty while the bot's cron store has jobs.
- *
- * On older gateways the pane only shows jobs namespaced `[bot:<name>]` for the
- * active bot (plus untagged legacy jobs on the default bot). When jobs exist in
- * the store but none surface for this bot, the user is left staring at the
- * generic empty state with no hint that cronjobs are present but hidden.
- * Return a short explanation string in that case, or null when the store is
- * genuinely empty (or the active bot's jobs are already shown).
- */
-function routineFilterHint(all, jobs) {
-  if (jobs.length !== 0 || !Array.isArray(all) || all.length === 0) {
-    return null
-  }
-  return 'Cronjobs exist in this profile but none are tagged for this bot. ' +
-    'Name a job "[bot:<name>] …" to show it here, or see them in Cron below.'
-}
-
-function normalizedProfileName(profile) {
-  return typeof profile === 'string' ? profile.trim().toLowerCase() : ''
-}
-
-function shellQuote(value) {
-  return `'${String(value).replaceAll("'", "'\"'\"'")}'`
-}
-
-function routineInputError(title, instruction) {
-  if (String(title).includes('\0')) {
-    return 'Cronjob name cannot contain NUL (U+0000).'
-  }
-
-  if (String(instruction).includes('\0')) {
-    return 'Cronjob instruction cannot contain NUL (U+0000).'
-  }
-
-  return null
-}
-
-function routinePrompt(bot, title, instruction, activeProfile) {
-  if (normalizedProfileName(bot) && normalizedProfileName(bot) === normalizedProfileName(activeProfile)) {
-    return instruction
-  }
-
-  return (
-    `${SAFE_ROUTINE_MARKER}You are running the scheduled routine "${title}" for agent '${bot}'. ` +
-    `Execute it AS that agent so the run lands in its own history: run this in the terminal and relay the output:\n\n` +
-    `hermes -p ${shellQuote(bot)} chat -c ${shellQuote(`Routine: ${title}`)} -q ${shellQuote(`[Scheduled routine] ${instruction}`)}\n\n` +
-    `If the command fails, report the error instead.`
-  )
-}
-function scheduleLabel(schedule) {
-  const once = /^once in (.+)$/.exec(schedule || '')
-
-  if (once) {
-    return `Once (${once[1]})`
-  }
-
-  const bare = /^(\d+)([mhd])$/.exec(schedule || '')
-
-  if (bare) {
-    return `Once (${bare[1]}${bare[2]})`
-  }
-
-  const match = /^every (\d+)m$/.exec(schedule || '')
-
-  if (match) {
-    const minutes = Number(match[1])
-
-    if (minutes % 1440 === 0) {
-      const d = minutes / 1440
-      return d === 1 ? 'Daily' : `Every ${d} days`
-    }
-
-    if (minutes % 60 === 0) {
-      const h = minutes / 60
-      return h === 1 ? 'Hourly' : `Every ${h}h`
-    }
-
-    return `Every ${minutes}m`
-  }
-
-  return schedule || ''
-}
-
-/** Absolute + relative rendering of a cron timestamp, or null when the job
- *  has never carried one (a job that has not run yet has no `last_run_at`). */
-function routineTimestamp(value) {
-  const ms = value ? new Date(value).getTime() : Number.NaN
-  return Number.isFinite(ms) ? `${relativeTime(ms)} · ${new Date(ms).toLocaleString()}` : null
-}
-
-/** The facts `cron.manage list` already sends with every job, as label/value
- *  rows. Pure so the detail contract is testable without a renderer, and so
- *  the dialog cannot invent a field the gateway never sent: an absent value
- *  drops its row instead of rendering "undefined". */
-function routineDetailRows(job) {
-  const paused = job?.enabled === false || job?.state === 'paused'
-  const label = scheduleLabel(job?.schedule)
-  const raw = String(job?.schedule || '').trim()
-
-  return [
-    ['Status', paused ? 'Paused' : 'Active'],
-    ['Schedule', label],
-    // `scheduleLabel` humanizes "every 1440m" and cron expressions; keep the
-    // raw string when it says something the label dropped.
-    ['Schedule (raw)', raw && raw !== label ? raw : null],
-    ['Repeat', job?.repeat],
-    ['Next run', paused ? null : routineTimestamp(job?.next_run_at)],
-    ['Last run', routineTimestamp(job?.last_run_at)],
-    ['Last result', job?.last_status],
-    ['Delivers to', job?.deliver],
-    ['Model', job?.model],
-    ['Working directory', job?.workdir]
-  ]
-    .filter(([, value]) => typeof value === 'string' && value.trim())
-    .map(([name, value]) => ({ label: name, value: value.trim() }))
-}
-
-/** Why a job is not doing what the user expects. The row only ever showed
- *  "paused"; the scheduler's own reason and the last fire/delivery failures
- *  had no surface in Bot Mode at all. */
-function routineDetailIssue(job) {
-  const reasons = [job?.last_fire_error, job?.last_delivery_error, job?.paused_reason]
-  const first = reasons.find(value => typeof value === 'string' && value.trim())
-
-  return first ? first.trim() : null
-}
-
-/** Read-only inspector for one cronjob, rendered from the list payload the
- *  pane already holds — no extra RPC, and no second mutation path beside the
- *  row's own switch and delete. */
-function RoutineDetailDialog({ job, onClose, open }) {
-  const rows = job ? routineDetailRows(job) : []
-  const issue = job ? routineDetailIssue(job) : null
-  const instruction = String(job?.prompt_preview || '').trim()
-
-  return jsx(Dialog, {
-    open: Boolean(open && job),
-    onOpenChange: value => {
-      if (!value) {
-        onClose()
-      }
-    },
-    children: jsxs(DialogContent, {
-      className: 'max-w-md',
-      children: [
-        jsxs(DialogHeader, {
-          children: [
-            jsx(DialogTitle, { className: 'truncate', children: routineTitle(job) }),
-            jsx(DialogDescription, { children: 'What this cronjob runs, and when it runs next.' })
-          ]
-        }),
-        jsxs('div', {
-          className: 'grid gap-3.5',
-          children: [
-            issue
-              ? jsx('div', {
-                  className:
-                    'rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs leading-5 text-(--ui-accent)',
-                  children: issue
-                })
-              : null,
-            jsx('div', {
-              className: 'grid gap-1.5',
-              children: rows.map(row =>
-                jsxs('div', {
-                  className: 'flex items-baseline justify-between gap-3 text-xs',
-                  children: [
-                    jsx('span', { className: 'shrink-0 text-(--ui-text-tertiary)', children: row.label }),
-                    jsx('span', { className: 'min-w-0 truncate text-right', children: row.value })
-                  ]
-                }, row.label)
-              )
-            }),
-            instruction
-              ? labeled(
-                  'Instruction',
-                  jsx('div', {
-                    className:
-                      'max-h-48 overflow-y-auto whitespace-pre-wrap break-words rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs leading-5 text-(--ui-text-secondary)',
-                    children: instruction
-                  })
-                )
-              : null
-          ]
-        }),
-        jsx(DialogFooter, {
-          children: jsx(Button, { variant: 'secondary', onClick: onClose, children: 'Close' })
-        })
-      ]
-    })
-  })
-}
-
-function RoutineRow({ job, onOpen, owner }) {
-  const profile = typeof owner === 'string' ? owner : owner?.name
-  const [busy, setBusy] = useState(false)
-  // Optimistic overlay: null = trust server state. Set immediately on
-  // toggle so the switch responds even before the refetch lands.
-  const [pendingActive, setPendingActive] = useState(null)
-  const legacyUnsafe = isLegacyDelegatedRoutine(job)
-  const serverActive = !legacyUnsafe && job.enabled !== false && job.state !== 'paused'
-  const active = pendingActive === null ? serverActive : pendingActive
-
-  if (pendingActive !== null && pendingActive === serverActive) {
-    setPendingActive(null) // server caught up
-  }
-
-  const act = async action => {
-    if (busy) {
-      return
-    }
-
-    setBusy(true)
-
-    if (action === 'pause' || action === 'resume') {
-      setPendingActive(action === 'resume')
-    }
-
-    try {
-      await requestForBot(owner, 'cron.manage', { action, name: job.job_id, ...(profile ? { profile } : {}) })
-      await invalidateRoutineOwner(owner)
-    } catch (err) {
-      setPendingActive(null)
-      host.notifyError(err, 'Cronjob update failed')
-    } finally {
-      setBusy(false)
-    }
-  }
-
-  return jsxs('div', {
-    className: cn(
-      'group grid gap-1.5 rounded-lg border border-(--ui-stroke-secondary) p-2.5 transition-colors',
-      'hover:border-(--ui-stroke-primary, var(--ui-stroke-secondary))'
-    ),
-    children: [
-      jsxs('div', {
-        className: 'flex items-center gap-2',
-        children: [
-          // The row's own button, not a click handler on the card: the switch
-          // and delete control are siblings, so opening the details can never
-          // swallow a toggle (and a nested button would be invalid markup).
-          jsxs('button', {
-            type: 'button',
-            title: 'Cronjob details',
-            className: 'flex min-w-0 flex-1 items-center gap-2 text-left transition-colors hover:text-foreground',
-            onClick: () => onOpen?.(job),
-            children: [
-              jsx('span', {
-                'aria-hidden': true,
-                className: cn('size-1.5 shrink-0 rounded-full', active ? 'bg-emerald-500' : 'bg-(--ui-text-quaternary)')
-              }),
-              jsx('span', {
-                className: cn('min-w-0 flex-1 truncate text-xs font-medium', !active && 'text-(--ui-text-tertiary)'),
-                children: routineTitle(job)
-              })
-            ]
-          }),
-          jsx(Switch, {
-            checked: active,
-            disabled: busy || legacyUnsafe,
-            onCheckedChange: value => act(value ? 'resume' : 'pause')
-          }),
-          jsx(Tip, {
-            label: 'Delete cronjob',
-            children: jsx('button', {
-              type: 'button',
-              disabled: busy,
-              className:
-                'flex size-5 items-center justify-center rounded text-(--ui-text-quaternary) opacity-0 transition-opacity group-hover:opacity-100 hover:bg-(--chrome-action-hover) hover:text-foreground',
-              onClick: () => act('remove'),
-              children: jsx(Codicon, { name: 'trash', className: 'text-[0.75rem]' })
-            })
-          })
-        ]
-      }),
-      jsxs('div', {
-        className: 'flex items-center justify-between gap-2 pl-3.5',
-        children: [
-          jsxs('span', {
-            className:
-              'inline-flex items-center gap-1 rounded-full border border-(--ui-stroke-secondary) px-1.5 py-0.5 text-[0.65rem] text-(--ui-text-tertiary)',
-            children: [jsx(Codicon, { name: 'calendar', className: 'text-[0.7rem]' }), scheduleLabel(job.schedule)]
-          }),
-          jsx('span', {
-            className: 'truncate text-[0.65rem] text-(--ui-text-quaternary)',
-            children: active && job.next_run_at ? `next ${relativeTime(new Date(job.next_run_at).getTime())}` : 'paused'
-          })
-        ]
-      }),
-      legacyUnsafe
-        ? jsx('div', {
-            className:
-              'rounded-md border border-(--ui-stroke-secondary) px-2 py-1.5 text-[0.65rem] leading-4 text-(--ui-accent)',
-            children: 'Paused for security: delete and recreate this legacy cronjob before running it again.'
-          })
-        : null
-    ]
-  })
-}
-
-// Structured schedule picker: frequency first, then only the detail that
-// frequency needs (time of day, weekday, day of month, interval). Emits a
-// Hermes-native schedule string; Advanced exposes it raw.
-const FREQUENCIES = [
-  { id: 'once', label: 'Once, in\u2026' },
-  { id: 'hourly', label: 'Every hour' },
-  { id: 'daily', label: 'Every day' },
-  { id: 'weekdays', label: 'Weekdays' },
-  { id: 'weekly', label: 'Every week' },
-  { id: 'monthly', label: 'Every month' },
-  { id: 'interval', label: 'Interval' },
-  { id: 'advanced', label: 'Advanced\u2026' }
-]
-
-const WEEKDAYS = [
-  { id: '1', label: 'Monday' },
-  { id: '2', label: 'Tuesday' },
-  { id: '3', label: 'Wednesday' },
-  { id: '4', label: 'Thursday' },
-  { id: '5', label: 'Friday' },
-  { id: '6', label: 'Saturday' },
-  { id: '0', label: 'Sunday' }
-]
-
-const TIMES = (() => {
-  const out = []
-  for (let h = 0; h < 24; h++) {
-    for (const m of [0, 30]) {
-      const ampm = h < 12 ? 'AM' : 'PM'
-      const h12 = h % 12 === 0 ? 12 : h % 12
-      out.push({ id: `${h}:${m}`, label: `${h12}:${String(m).padStart(2, '0')} ${ampm}`, h, m })
-    }
-  }
-  return out
-})()
-
-/** Compose the Hermes schedule string from picker state. */
-function composeSchedule(state) {
-  const [h, m] = (state.time || '9:0').split(':').map(Number)
-
-  switch (state.freq) {
-    case 'once': {
-      const n = Math.max(1, parseInt(state.onceN, 10) || 1)
-      return `${n}${state.onceUnit || 'h'}`
-    }
-    case 'hourly':
-      return 'every 1h'
-    case 'daily':
-      return `${m} ${h} * * *`
-    case 'weekdays':
-      return `${m} ${h} * * 1-5`
-    case 'weekly':
-      return `${m} ${h} * * ${state.weekday || '1'}`
-    case 'monthly':
-      return `${m} ${h} ${state.monthday || '1'} * *`
-    case 'interval': {
-      const n = Math.max(1, parseInt(state.intervalN, 10) || 1)
-      return `every ${n}${state.intervalUnit || 'h'}`
-    }
-    default:
-      return state.raw || ''
-  }
-}
-
-function scheduleSummary(state) {
-  const t = TIMES.find(x => x.id === state.time)
-  const tl = t ? t.label : '9:00 AM'
-
-  const unitWord = u => (u === 'm' ? 'minute(s)' : u === 'd' ? 'day(s)' : 'hour(s)')
-  const cap =
-    state.freq !== 'once' && String(state.repeatN || '').trim()
-      ? `, ${Math.max(1, parseInt(state.repeatN, 10) || 1)} time(s) total`
-      : ''
-
-  switch (state.freq) {
-    case 'once':
-      return `Runs once, ${Math.max(1, parseInt(state.onceN, 10) || 1)} ${unitWord(state.onceUnit)} from now`
-    case 'hourly':
-      return 'Runs at the top of every hour' + cap
-    case 'daily':
-      return `Runs every day at ${tl}` + cap
-    case 'weekdays':
-      return `Runs Monday\u2013Friday at ${tl}` + cap
-    case 'weekly':
-      return `Runs every ${(WEEKDAYS.find(w => w.id === state.weekday) || WEEKDAYS[0]).label} at ${tl}` + cap
-    case 'monthly':
-      return `Runs on day ${state.monthday || '1'} of each month at ${tl}` + cap
-    case 'interval':
-      return `Runs every ${Math.max(1, parseInt(state.intervalN, 10) || 1)} ${unitWord(state.intervalUnit)}` + cap
-    default:
-      return 'Raw schedule \u2014 every Nm/Nh/Nd or 5-field cron'
-  }
-}
-
-function pickerSelect(value, onChange, options) {
-  return jsxs(Select, {
-    value,
-    onValueChange: onChange,
-    children: [
-      jsx(SelectTrigger, { className: 'h-8 rounded-md', children: jsx(SelectValue, {}) }),
-      jsx(SelectContent, {
-        children: options.map(o => jsx(SelectItem, { value: o.id, children: o.label }, o.id))
-      })
-    ]
-  })
-}
-
-function SchedulePicker({ state, setState }) {
-  const upd = patch => setState(prev => ({ ...prev, ...patch }))
-  const needsTime = ['daily', 'weekdays', 'weekly', 'monthly'].includes(state.freq)
-
-  return jsxs('div', {
-    className: 'grid gap-2',
-    children: [
-      jsxs('div', {
-        style: { display: 'grid', gridTemplateColumns: needsTime ? '1fr 1fr' : '1fr', gap: '8px' },
-        children: [
-          pickerSelect(state.freq, v => upd({ freq: v }), FREQUENCIES),
-          needsTime ? pickerSelect(state.time, v => upd({ time: v }), TIMES) : null
-        ]
-      }),
-      state.freq === 'once'
-        ? jsxs('div', {
-            style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '8px' },
-            children: [
-              jsx(Input, {
-                className: 'h-8',
-                placeholder: '30',
-                value: state.onceN,
-                onChange: event => upd({ onceN: event.target.value.replace(/[^0-9]/g, '').slice(0, 4) })
-              }),
-              pickerSelect(state.onceUnit, v => upd({ onceUnit: v }), [
-                { id: 'm', label: 'minutes from now' },
-                { id: 'h', label: 'hours from now' },
-                { id: 'd', label: 'days from now' }
-              ])
-            ]
-          })
-        : null,
-      state.freq === 'weekly'
-        ? pickerSelect(state.weekday, v => upd({ weekday: v }), WEEKDAYS)
-        : null,
-      state.freq === 'monthly'
-        ? labeled(
-            'Day of month',
-            jsx(Input, {
-              className: 'h-8',
-              placeholder: '1',
-              value: state.monthday,
-              onChange: event => upd({ monthday: event.target.value.replace(/[^0-9]/g, '').slice(0, 2) })
-            })
-          )
-        : null,
-      state.freq === 'interval'
-        ? jsxs('div', {
-            style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '8px' },
-            children: [
-              jsx(Input, {
-                className: 'h-8',
-                placeholder: '2',
-                value: state.intervalN,
-                onChange: event => upd({ intervalN: event.target.value.replace(/[^0-9]/g, '').slice(0, 4) })
-              }),
-              pickerSelect(state.intervalUnit, v => upd({ intervalUnit: v }), [
-                { id: 'm', label: 'minutes' },
-                { id: 'h', label: 'hours' },
-                { id: 'd', label: 'days' }
-              ])
-            ]
-          })
-        : null,
-      state.freq === 'advanced'
-        ? jsx(Input, {
-            className: 'h-8 font-mono text-xs',
-            placeholder: 'every 1d \u00b7 every 2h \u00b7 0 9 * * * (cron)',
-            value: state.raw,
-            onChange: event => upd({ raw: event.target.value })
-          })
-        : null,
-      state.freq !== 'once' && state.freq !== 'advanced'
-        ? jsxs('div', {
-            className: 'flex items-center gap-2',
-            children: [
-              jsx('span', { className: 'text-xs text-(--ui-text-tertiary)', children: 'Stop after' }),
-              jsx(Input, {
-                className: 'h-7 w-16 text-xs',
-                placeholder: '\u221e',
-                value: state.repeatN,
-                onChange: event => upd({ repeatN: event.target.value.replace(/[^0-9]/g, '').slice(0, 4) })
-              }),
-              jsx('span', { className: 'text-xs text-(--ui-text-tertiary)', children: 'runs (blank = forever)' })
-            ]
-          })
-        : null,
-      jsx('div', {
-        className: 'text-[0.65rem] text-(--ui-text-quaternary)',
-        children: `${scheduleSummary(state)} \u00b7 ${composeSchedule(state) || '\u2014'}`
-      })
-    ]
-  })
-}
-
-function defaultScheduleState() {
-  return { freq: 'daily', time: '9:0', weekday: '1', monthday: '1', intervalN: '2', intervalUnit: 'h', onceN: '30', onceUnit: 'm', repeatN: '', raw: '' }
-}
-
-function CreateRoutineDialog({ bot, open, onClose }) {
-  const [name, setName] = useState('')
-  const [instruction, setInstruction] = useState('')
-  const [sched, setSched] = useState(defaultScheduleState())
-  const [continuity, setContinuity] = useState(false)
-  // Where the run's output lands: 'history' = the run session only (Run
-  // history / cron page, today's behavior); 'bot-chat' = inject into this
-  // bot's canonical Bot Chat as a real message — the bot reads it, acts on
-  // it, and responds there (costs the bot one agent turn per run).
-  const [target, setTarget] = useState('history')
-  const [busy, setBusy] = useState(false)
-  const [error, setError] = useState(null)
-  const activeProfile = useValue(host.state.profile)
-  const profile = typeof bot === 'string' ? bot : bot?.name
-  const schedule = composeSchedule(sched)
-
-  const reset = () => {
-    setName('')
-    setInstruction('')
-    setSched(defaultScheduleState())
-    setContinuity(false)
-    setTarget('history')
-    setBusy(false)
-    setError(null)
-  }
-
-  const submit = async () => {
-    const title = name.trim()
-    const task = instruction.trim()
-    const inputError = routineInputError(title, task)
-
-    if (inputError) {
-      setError(inputError)
-      return
-    }
-
-    if (!title || !task || !schedule.trim() || busy) {
-      return
-    }
-
-    setBusy(true)
-    setError(null)
-
-    try {
-      const repeatN =
-        sched.freq !== 'once' && sched.freq !== 'advanced' && String(sched.repeatN || '').trim()
-          ? Math.max(1, parseInt(sched.repeatN, 10) || 1)
-          : null
-      await requestForBot(bot, 'cron.manage', {
-        action: 'add',
-        name: `[bot:${profile}] ${title}`,
-        schedule: schedule.trim(),
-        prompt: routinePrompt(profile, title, task, activeProfile),
-        ...(profile ? { profile } : {}),
-        ...(repeatN ? { repeat: repeatN } : {}),
-        ...(continuity ? { continuity: true } : {}),
-        // 'bot-chat' (bare, no name): the job is created IN the bot's own
-        // cron store (profile scoping above), so the scheduler resolves the
-        // token to that profile — no cross-gateway name ambiguity possible.
-        ...(target === 'bot-chat' ? { deliver: 'bot-chat' } : {})
-      })
-      await invalidateRoutineOwner(bot)
-      host.notify({ kind: 'success', message: `Cronjob "${title}" scheduled` })
-      reset()
-      onClose()
-    } catch (err) {
-      setBusy(false)
-      setError(err instanceof Error ? err.message : String(err))
-    }
-  }
-
-  return jsx(Dialog, {
-    open,
-    onOpenChange: value => {
-      if (!value && !busy) {
-        reset()
-        onClose()
-      }
-    },
-    children: jsxs(DialogContent, {
-      className: 'max-w-md',
-      children: [
-        jsxs(DialogHeader, {
-          children: [
-            jsx(DialogTitle, { children: 'New Cronjob' }),
-            jsx(DialogDescription, {
-              children: `A recurring task ${displayName(typeof bot === 'string' ? { name: bot } : bot, botRosterMeta(bot, $botMeta.get()))} runs on a schedule. Runs land in its own chat history.`
-            })
-          ]
-        }),
-        jsxs('div', {
-          className: 'grid gap-3.5',
-          children: [
-            labeled(
-              'Name',
-              jsx(Input, {
-                autoFocus: true,
-                placeholder: 'Name this cronjob',
-                value: name,
-                onChange: event => setName(event.target.value)
-              })
-            ),
-            labeled(
-              'Instruction',
-              jsx(Textarea, {
-                className: 'min-h-20',
-                placeholder: 'What should this cronjob do each time it runs?',
-                value: instruction,
-                onChange: event => setInstruction(event.target.value)
-              })
-            ),
-            labeled('When to run', jsx(SchedulePicker, { state: sched, setState: setSched })),
-            labeled(
-              'Send results to',
-              pickerSelect(target, setTarget, [
-                { id: 'history', label: 'Run history only' },
-                { id: 'bot-chat', label: `${displayName(typeof bot === 'string' ? { name: bot } : bot, botRosterMeta(bot, $botMeta.get()))}\u2019s chat (bot responds)` }
-              ])
-            ),
-            jsxs('label', {
-              className: 'flex items-center gap-2 text-xs text-(--ui-text-tertiary) cursor-pointer select-none',
-              children: [
-                jsx('input', {
-                  type: 'checkbox',
-                  className: 'accent-(--ui-accent)',
-                  checked: continuity,
-                  onChange: event => setContinuity(event.target.checked)
-                }),
-                'Continuity: each run sees the previous run\u2019s output (dedupe, continue where it left off)'
-              ]
-            }),
-            error
-              ? jsx('div', {
-                  className: 'rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs text-(--ui-accent)',
-                  children: error
-                })
-              : null
-          ]
-        }),
-        jsxs(DialogFooter, {
-          children: [
-            jsx(Button, {
-              variant: 'ghost',
-              disabled: busy,
-              onClick: () => {
-                reset()
-                onClose()
-              },
-              children: 'Cancel'
-            }),
-            jsx(Button, {
-              disabled: busy || !name.trim() || !instruction.trim() || !schedule.trim(),
-              onClick: submit,
-              children: busy ? 'Scheduling…' : 'Create Cronjob'
-            })
-          ]
-        })
-      ]
-    })
-  })
-}
-
-/** Keeps $selectedBot in sync with the focused chat's owner profile.
- *  nanostores' `.listen()` never replays the current value the way
- *  `.subscribe()` does, so a disable → profile switch → re-enable sequence
- *  would otherwise leave $selectedBot pointed at whichever bot was active
- *  before the plugin was disabled — reseeding here on every register() call
- *  closes that gap. Connection qualification keeps same-named owners isolated.
- *  Returns the unbind function for ctx.onDispose. */
-function bindProfileSync(ownerStore) {
-  const sync = owner => {
-    const profile = typeof owner === 'string' ? owner : owner?.profile
-
-    if (!profile || typeof profile !== 'string') {
-      return
-    }
-
-    const connectionId = String(
-      typeof owner === 'object' ? owner?.connectionId || '' : ''
-    ).trim()
-    $selectedBot.set(connectionId ? `${connectionId}::${profile}` : profile)
-  }
-
-  sync(ownerStore.get?.())
-
-  return ownerStore.listen(sync)
-}
-
-function resolveRoutineOwner(roster, focusedOwner, selected) {
-  // A null focused owner is NOT a failure: the SDK fails closed to null
-  // whenever the focused session has no unique bot owner (a normal chat,
-  // ambiguous owner hints) — the common case while the user browses the
-  // Bots pane. Fall through to the roster-clicked bot (the previously
-  // working scope) instead of dead-ending the pane on the unavailable
-  // placeholder for every agent (#94516).
-  const selectedBot = roster.find(bot => botSelectionKey(bot) === selected)
-  const focusedBot = focusedOwner
-    ? roster.find(bot => isActiveRosterBot(bot, focusedOwner))
-    : null
-
-  if (focusedOwner?.authoritative) {
-    // An authoritative focused owner wins, but only through its exact roster
-    // row. If that row is absent, fail closed instead of routing cron
-    // reads/mutations through a stale selection or an unscoped profile name.
-    return focusedBot || null
-  }
-
-  return focusedBot || selectedBot || (focusedOwner ? { name: focusedOwner.name } : null)
-}
-
-function RoutinesPane() {
-  const selected = useValue($selectedBot)
-  const focusedOwner = focusedRosterOwner(useValue($focusedBotOwner))
-  // Subscribe instead of a bare read: BotsHomeView owns the roster fetch and
-  // can hydrate (or replace) rows after this pane mounted, so a .get()
-  // snapshot captured while the roster was still empty pinned the pane on
-  // "unavailable" until some unrelated atom happened to re-render it (#94483).
-  // A complete focused owner is still authoritative. If its exact roster row
-  // is absent, fail closed rather than routing cron reads/mutations through a
-  // stale selection or an unscoped profile name.
-  const owner = resolveRoutineOwner(useValue($lastRoster), focusedOwner, selected)
-  const bot = String(owner?.name || focusedOwner?.name || 'default').trim() || 'default'
-  const allMeta = useValue($botMeta)
-  const meta = owner ? botRosterMeta(owner, allMeta) : null
-  const { shape, color, image } = botAppearance(bot, meta)
-  const { data, error, isLoading, refetch } = useRoutines(owner)
-  const [createOpen, setCreateOpen] = useState(false)
-  const [createOwner, setCreateOwner] = useState(null)
-  // Hold the id, not the record: the 20s poll replaces every job object, and
-  // an open inspector must follow the live row (next run, pause, last error)
-  // instead of freezing the snapshot that was on screen when it opened.
-  const [detailJobId, setDetailJobId] = useState(null)
-  const createTarget = owner ? routineCreateTarget(createOwner, bot) : null
-
-  const openCreate = () => {
-    if (!owner) {
-      return
-    }
-
-    setCreateOwner(owner)
-    setCreateOpen(true)
-  }
-
-  if (!owner) {
-    return jsx('div', {
-      className: 'flex h-full items-center justify-center px-4 text-center text-xs text-(--ui-text-tertiary)',
-      children: 'Cronjobs are unavailable until this agent appears in the roster.'
-    })
-  }
-
-  const view = selectRoutineJobs(data, error, $lastJobs.get(), bot)
-  if (view.live) {
-    $lastJobs.set(view.live)
-  }
-  const jobs = view.jobs
-  const detailJob = detailJobId ? jobs.find(job => job.job_id === detailJobId) || null : null
-  const staleNotice = error && !view.live && view.all.length
-    ? 'Could not refresh cronjobs. Showing the last list we had.'
-    : null
-  const filterHint = routineFilterHint(view.all, jobs)
-
-  return jsxs('div', {
-    className: 'flex h-full flex-col',
-    children: [
-      jsxs('div', {
-        className: 'flex items-center gap-2 px-3 pt-3 pb-2',
-        children: [
-          jsx(BotFace, { shape, color, image, size: 22, name: bot }),
-          jsxs('div', {
-            className: 'min-w-0 flex-1',
-            children: [
-              jsxs('div', {
-                className: 'flex min-w-0 items-baseline gap-1.5 truncate',
-                children: [
-                  jsx('div', {
-                    className: 'truncate text-xs font-semibold',
-                    children: displayName({ name: bot }, meta)
-                  }),
-                  showsHandle(bot, meta)
-                    ? jsx('span', {
-                        className: 'shrink-0 font-mono text-[0.65rem] text-(--ui-text-quaternary)',
-                        children: `@${botHandle(bot)}`
-                      })
-                    : null
-                ]
-              }),
-              jsx('div', {
-                className: 'text-[0.65rem] uppercase tracking-wider text-(--ui-text-quaternary)',
-                children: 'Cronjobs'
-              })
-            ]
-          }),
-          jsx(Tip, {
-            label: 'New Cronjob',
-            children: jsx('button', {
-              type: 'button',
-              className:
-                'flex size-6 shrink-0 items-center justify-center rounded-md text-(--ui-text-tertiary) transition-colors hover:bg-(--chrome-action-hover) hover:text-foreground',
-              onClick: openCreate,
-              children: jsx(Codicon, { name: 'add' })
-            })
-          })
-        ]
-      }),
-      jsx('div', { className: 'mx-3 border-t border-(--ui-stroke-secondary)' }),
-      staleNotice
-        ? jsx('div', {
-            className: 'mx-3 mt-2 rounded-md bg-(--chrome-action-hover) px-2 py-1.5 text-[0.6875rem] text-(--ui-text-tertiary)',
-            children: staleNotice
-          })
-        : null,
-      isLoading && !view.all.length
-        ? jsx('div', {
-            className: 'flex flex-1 items-center justify-center',
-            children: jsx(GlyphSpinner, { spinner: 'breathe', className: 'text-(--ui-text-tertiary)' })
-          })
-        : error && !view.all.length
-          ? jsxs('div', {
-              className: 'flex flex-1 flex-col items-center justify-center gap-3 px-4 text-center',
-              children: [
-                jsx(Codicon, { name: 'warning', className: 'text-[1.6rem] text-(--ui-text-quaternary)' }),
-                jsx('div', {
-                  className: 'text-xs leading-5 text-(--ui-text-tertiary)',
-                  children: 'Could not load cronjobs. The list may still be there.'
-                }),
-                jsx(Button, {
-                  variant: 'secondary',
-                  size: 'sm',
-                  onClick: () => void refetch(),
-                  children: 'Retry'
-                })
-              ]
-            })
-        : jobs.length === 0
-          ? jsxs('div', {
-              className: 'flex flex-1 flex-col items-center justify-center gap-3 px-4 text-center',
-              children: [
-                // No generic placeholder here: an icon + "cronjobs are…" blurb and the
-                // create button both just said "empty" (Teknium, Aug 2026). The hint
-                // text stays only when jobs exist but are hidden by the bot filter —
-                // that carries real information, not an empty-state marker.
-                filterHint
-                  ? jsx('div', {
-                      className: 'text-xs leading-5 text-(--ui-text-tertiary)',
-                      children: filterHint
-                    })
-                  : null,
-                jsx(Button, {
-                  variant: 'secondary',
-                  size: 'sm',
-                  onClick: openCreate,
-                  children: filterHint ? 'Create a cronjob for this bot' : 'Create Cronjob'
-                })
-              ]
-            })
-          : jsx(ScrollArea, {
-              className: 'min-h-0 flex-1',
-              children: jsx('div', {
-                className: 'grid gap-1.5 px-2.5 py-2',
-                children: jobs.map(job =>
-                  jsx(RoutineRow, { job, onOpen: opened => setDetailJobId(opened.job_id), owner }, job.job_id)
-                )
-              })
-            }),
-      jsx(RoutineDetailDialog, {
-        job: detailJob,
-        open: Boolean(detailJob),
-        onClose: () => setDetailJobId(null)
-      }),
-      jsx(CreateRoutineDialog, {
-        bot: createTarget,
-        open: createOpen,
-        onClose: () => {
-          setCreateOpen(false)
-          setCreateOwner(null)
-        }
-        // key is the jsx() THIRD argument — as a prop it is silently ignored
-        // and the dialog kept stale per-bot form state when the target changed.
-      }, createTarget)
-    ]
-  })
-}
-
-// ── roster pane ──────────────────────────────────────────────────────────────
-
-/** "Active now" presence strip above the roster: chips for every bot that is
- *  working right now (the gateway-busy selected profile + bots whose last
- *  message landed inside the liveness window). Reuses the row avatar; each
- *  chip opens that bot's canonical Bot Chat. Omitted entirely when nothing
- *  is active, and never reorders the roster below it. */
-function ActiveNowStrip({ roster, activeProfile, gatewayState, metaByName, onOpen }) {
-  const active = activeBots(roster, activeProfile, gatewayState)
-
-  if (!active.length) {
-    return null
-  }
-
-  return jsxs('div', {
-    role: 'status',
-    'aria-live': 'polite',
-    'aria-label': 'Active now',
-    className: 'flex flex-wrap items-center gap-1.5 px-2.5 pb-1.5',
-    children: [
-      jsx('span', {
-        className: 'text-[0.6875rem] font-semibold uppercase tracking-wider text-(--ui-text-quaternary)',
-        children: 'Active now'
-      }),
-      ...active.map(bot => {
-        const meta = botRosterMeta(bot, metaByName)
-        const { shape, color, image } = botAppearance(bot.name, meta)
-        const photo = Boolean(image && !isBackfilledFacePng(image))
-        const label = displayName(bot, meta)
-
-        return jsx(
-          Tip,
-          {
-            label: `Open ${label}'s chat`,
-            children: jsx('button', {
-              type: 'button',
-              'aria-label': `Open ${label}'s chat`,
-              className: cn(
-                'flex items-center gap-1.5 rounded-md bg-(--chrome-action-hover) px-1.5 py-1 text-left transition-colors',
-                'hover:bg-(--chrome-action-hover) hover:text-foreground'
-              ),
-              onClick: () => onOpen(bot),
-              children: [
-                jsx(BotFace, {
-                  shape,
-                  color,
-                  image: photo ? image : null,
-                  size: 24,
-                  name: bot.name,
-                  mood: 'work'
-                }),
-                jsx('span', {
-                  className: 'max-w-28 truncate text-xs font-medium',
-                  children: label
-                })
-              ]
-            })
-          },
-          botRosterKey(bot)
-        )
-      })
-    ]
-  })
-}
-
-/** Assign a bot to a group-chat membership without replacing its others.
- *  Existing groups are independent toggles; the input creates and joins a new
- *  one. Canonical groups + the legacy scalar projection ride ui_meta. */
-function GroupDialog({ bot, onClose }) {
-  const meta = useValue($botMeta)
-  const [name, setName] = useState('')
-  const current = botGroups(botRosterMeta(bot, meta))
-  const groups = knownGroups(meta)
-
-  const setMembership = (group, enabled) => {
-    void saveBotMeta(bot, groupMembershipPatch(botRosterMeta(bot, meta), group, enabled))
-    host.notify({
-      kind: 'info',
-      message: enabled
-        ? `${displayName(bot, botRosterMeta(bot, meta))} added to “${group}”`
-        : `${displayName(bot, botRosterMeta(bot, meta))} removed from “${group}”`
-    })
-  }
-
-  return jsx(Dialog, {
-    open: Boolean(bot),
-    onOpenChange: value => {
-      if (!value) {
-        onClose()
-      }
-    },
-    children: jsxs(DialogContent, {
-      className: 'max-w-sm',
-      children: [
-        jsxs(DialogHeader, {
-          children: [
-            jsx(DialogTitle, { children: 'Manage groups' }),
-            jsx(DialogDescription, {
-              children: 'A bot can join multiple group chats. Memberships sync to every machine.'
-            })
-          ]
-        }),
-        groups.length
-          ? jsx('div', {
-              className: 'grid gap-1.5',
-              children: groups.map(group => {
-                const enabled = current.includes(group)
-
-                return jsxs(
-                  'label',
-                  {
-                    className:
-                      'flex cursor-pointer items-center gap-2 rounded-md px-2 py-1.5 text-sm hover:bg-(--chrome-action-hover)',
-                    children: [
-                      jsx(Checkbox, {
-                        checked: enabled,
-                        onCheckedChange: checked => setMembership(group, checked === true)
-                      }),
-                      jsx('span', { children: group })
-                    ]
-                  },
-                  group
-                )
-              })
-            })
-          : null,
-        jsxs('form', {
-          className: 'flex items-center gap-1.5',
-          onSubmit: event => {
-            event.preventDefault()
-            const trimmed = name.trim()
-
-            if (trimmed) {
-              setMembership(trimmed, true)
-              setName('')
-            }
-          },
-          children: [
-            jsx(Input, {
-              autoFocus: true,
-              placeholder: groups.length ? 'New group…' : 'Group name (e.g. Research)',
-              value: name,
-              onChange: event => setName(event.target.value)
-            }),
-            jsx(Button, { type: 'submit', size: 'sm', disabled: !name.trim(), children: 'Create & join' })
-          ]
-        }),
-        current.length
-          ? jsx(Button, {
-              variant: 'ghost',
-              size: 'sm',
-              className: 'justify-self-start',
-              onClick: () => void saveBotMeta(bot, { groups: [], group: null }),
-              children: 'Remove from all groups'
-            })
-          : null
-      ]
-    })
-  })
-}
-
-/** Compact picture controls shared by group-chat creation and settings:
- *  a live preview (image, else the organization glyph), Upload / Generate /
- *  Remove. Reuses the bot-avatar pipeline (device picker, 256px normalize,
- *  image.generate probe) so room pictures cost the same as bot avatars. */
-function GroupImageControls({ image, onImage, seedName, seedMembers }) {
-  const imagen = useValue($imagenAvailable)
-  const [busy, setBusy] = useState(false)
-
-  if (imagen === null) {
-    void probeImagen()
-  }
-
-  const upload = async () => {
-    const raw = await pickImageFromDevice()
-
-    if (raw) {
-      onImage(await normalizeAvatarImage(raw))
-    }
-  }
-
-  const generate = async () => {
-    if (busy) {
-      return
-    }
-
-    setBusy(true)
-
-    try {
-      const who = [seedName, seedMembers?.length ? `a team of ${seedMembers.join(', ')}` : '']
-        .filter(Boolean)
-        .join(' — ')
-      const res = await host.request('image.generate', {
-        prompt:
-          `Group chat icon for an AI agent team called "${who || 'a bot team'}". ` +
-          'Friendly minimal emblem, bold flat vector style, solid color background, centered, no text.',
-        aspect_ratio: 'square'
-      })
-
-      if (!res?.success) {
-        throw new Error(res?.error || 'generation failed')
-      }
-
-      const img = res.image_data || res.image
-
-      if (img) {
-        onImage(await normalizeAvatarImage(img))
-      }
-    } catch (err) {
-      host.notifyError(err, 'Group picture generation failed')
-    } finally {
-      setBusy(false)
-    }
-  }
-
-  return jsxs('div', {
-    className: 'flex items-center gap-2',
-    children: [
-      jsx('div', {
-        className:
-          'flex size-10 shrink-0 items-center justify-center overflow-hidden rounded-full bg-(--chrome-action-hover)',
-        children: image
-          ? jsx('img', { src: image, alt: '', className: 'size-full object-cover' })
-          : jsx(Codicon, { name: 'organization', className: 'text-(--ui-text-tertiary)' })
-      }),
-      jsx(Button, { type: 'button', variant: 'secondary', size: 'sm', onClick: upload, children: 'Upload' }),
-      imagen
-        ? jsx(Button, {
-            type: 'button',
-            variant: 'secondary',
-            size: 'sm',
-            disabled: busy,
-            onClick: generate,
-            children: busy ? 'Generating…' : 'Generate'
-          })
-        : null,
-      image
-        ? jsx(Button, { type: 'button', variant: 'ghost', size: 'sm', onClick: () => onImage(null), children: 'Remove' })
-        : null
-    ]
-  })
-}
-
-/** Edit an existing group chat's name and picture. Renames re-key the room
- *  and every local member's membership (renameGroupChat); the picture rides
- *  the room record. Both apply on Save so a cancelled dialog changes nothing. */
-function GroupChatSettingsDialog({ group, members, open, onClose, onRenamed }) {
-  const rooms = useValue($groupChats)
-  const current = (rooms[group] || {}).image || null
-  const [name, setName] = useState(group)
-  const [image, setImage] = useState(current)
-
-  useEffect(() => {
-    if (open) {
-      setName(group)
-      setImage(current)
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [open, group])
-
-  const save = async () => {
-    const finalName = await renameGroupChat(group, name, members)
-
-    if (finalName === null) {
-      return // collision — dialog stays open for a different name
-    }
-
-    if (image !== current) {
-      setGroupChatImage(finalName, image)
-    }
-
-    onClose()
-
-    if (finalName !== group) {
-      onRenamed?.(finalName)
-    }
-  }
-
-  return jsx(Dialog, {
-    open,
-    onOpenChange: value => {
-      if (!value) {
-        onClose()
-      }
-    },
-    children: jsxs(DialogContent, {
-      className: 'max-w-sm',
-      children: [
-        jsxs(DialogHeader, {
-          children: [
-            jsx(DialogTitle, { children: 'Group settings' }),
-            jsx(DialogDescription, {
-              children: 'Rename the group or set a room picture. Members and history are kept.'
-            })
-          ]
-        }),
-        jsx(GroupImageControls, {
-          image,
-          onImage: setImage,
-          seedName: name.trim() || group,
-          seedMembers: (members || []).map(b => b.name)
-        }),
-        jsx('form', {
-          onSubmit: event => {
-            event.preventDefault()
-            void save()
-          },
-          children: jsx(Input, {
-            'aria-label': 'Group name',
-            autoFocus: true,
-            maxLength: 64,
-            value: name,
-            onChange: event => setName(event.target.value)
-          })
-        }),
-        jsxs(DialogFooter, {
-          children: [
-            jsx(Button, { variant: 'secondary', onClick: onClose, children: 'Cancel' }),
-            jsx(Button, { disabled: !name.trim(), onClick: () => void save(), children: 'Save' })
-          ]
-        })
-      ]
-    })
-  })
-}
-
-/** Discord-style group chat creation: pick 2+ bots via checkboxes (with
- *  search), name the group, create. Assignment appends to each local bot's
- *  group membership list, so the room appears in the roster and syncs
- *  cross-machine via ui_meta without replacing its other groups. */
-function CreateGroupChatDialog({ open, roster, onClose, onCreated }) {
-  const allMeta = useValue($botMeta)
-  const [query, setQuery] = useState('')
-  const [checked, setChecked] = useState({})
-  const [name, setName] = useState('')
-  const [image, setImage] = useState(null)
-
-  // Reset per open so a cancelled draft doesn't leak into the next one.
-  useEffect(() => {
-    if (open) {
-      setQuery('')
-      setChecked({})
-      setName('')
-      setImage(null)
-    }
-  }, [open])
-
-  // An outage placeholder preserves one selected owner's identity in the
-  // sidebar, but it is not a routable room member. Never offer it here.
-  const selectableRoster = roster.filter(bot => !bot?.ghost)
-  const selected = selectableRoster.filter(bot => checked[botRosterKey(bot)])
-  const visible = filterBots(selectableRoster, allMeta, query)
-  const atCap = selected.length >= GROUP_CHAT_MAX_MEMBERS
-  const placeholder = selected.length
-    ? selected.map(bot => displayName(bot, botRosterMeta(bot, allMeta))).join(', ')
-    : 'Group name'
-  const canCreate = selected.length >= 2 && Boolean(name.trim() || selected.length)
-
-  const create = () => {
-    const base = (name.trim() || placeholder).slice(0, 64)
-
-    if (selected.length < 2 || !base) {
-      return
-    }
-
-    // Creating a group is always a FRESH room. Without this, re-creating a
-    // group under an existing name (easy — the default name is just the
-    // member names) silently reopens the old room with its full log, which
-    // reads as "not a fresh group" (db's Aug 2026 report). Uniquify against
-    // both live rooms and any bot's current grouping, then mint a fresh
-    // roomId: member sessions are titled by that roomId, so a
-    // disbanded-and-recreated group with the SAME display name still gets
-    // new sessions instead of resuming the old room's by title.
-    const taken = new Set(liveGroupChatNames())
-
-    for (const meta of Object.values($botMeta.get() || {})) {
-      for (const existing of botGroups(meta)) {
-        taken.add(existing)
-      }
-    }
-
-    const groupName = uniqueGroupChatName(base, taken)
-    const roomId = mintGroupRoomId()
-
-    for (const bot of selected) {
-      void saveBotMeta(bot, groupMembershipPatch(botRosterMeta(bot, allMeta), groupName, true))
-    }
-
-    // Persist every machine identity, including today's active source. That
-    // member becomes remote after a source switch and cannot rely on the new
-    // gateway's name-keyed bot metadata to remain seated in this room.
-    const roomMembers = durableGroupChatMembers(selected)
-
-    updateGroupChat(groupName, room => {
-      room.members = roomMembers
-      room.roomId = roomId
-
-      if (image) {
-        room.image = image
-      }
-
-      return room
-    })
-
-    host.notify({ kind: 'info', message: `“${groupName}” created with ${selected.length} bots` })
-    onClose()
-    onCreated?.(groupName)
-  }
-
-  return jsx(Dialog, {
-    open,
-    onOpenChange: value => {
-      if (!value) {
-        onClose()
-      }
-    },
-    children: jsxs(DialogContent, {
-      className: 'max-w-md',
-      children: [
-        jsxs(DialogHeader, {
-          children: [
-            jsx(DialogTitle, { children: 'New Group Chat' }),
-            jsx(DialogDescription, {
-              children: `Pick 2–${GROUP_CHAT_MAX_MEMBERS} bots. Local memberships sync through each Bot profile; cross-machine members stay scoped to this room.`
-            })
-          ]
-        }),
-        jsx(SearchField, {
-          'aria-label': 'Search bots to add',
-          autoFocus: true,
-          containerClassName: 'w-full',
-          inputClassName: 'w-full',
-          placeholder: 'Search bots to add…',
-          value: query,
-          onChange: setQuery
-        }),
-        selected.length
-          ? jsx('div', {
-              className: 'flex flex-wrap gap-1',
-              children: selected.map(bot =>
-                jsxs('button', {
-                  type: 'button',
-                  className:
-                    'flex items-center gap-1 rounded-full bg-(--chrome-action-hover) py-0.5 pl-2 pr-1.5 text-[0.6875rem] text-(--ui-text-secondary) transition-colors hover:text-foreground',
-                  title: 'Remove from selection',
-                  onClick: () => setChecked(prev => ({ ...prev, [botRosterKey(bot)]: false })),
-                  children: [displayName(bot, botRosterMeta(bot, allMeta)), jsx(Codicon, { name: 'close', className: 'text-[0.6rem]' })]
-                }, botRosterKey(bot))
-              )
-            })
-          : null,
-        jsx(ScrollArea, {
-          className: 'max-h-64 min-h-0',
-          children: jsx('div', {
-            className: 'grid gap-0.5 pr-2',
-            children: visible.length
-              ? visible.map(bot => {
-                  const meta = botRosterMeta(bot, allMeta)
-                  const { shape, color, image } = botAppearance(bot.name, meta)
-                  const isChecked = Boolean(checked[botRosterKey(bot)])
-                  const disabled = !isChecked && atCap
-                  const currentGroups = botGroups(meta)
-
-                  return jsxs('label', {
-                    className: cn(
-                      'flex cursor-pointer items-center gap-2 rounded-md px-1.5 py-1 transition-colors hover:bg-(--chrome-action-hover)',
-                      disabled && 'cursor-not-allowed opacity-50'
-                    ),
-                    children: [
-                      jsx(BotFace, {
-                        shape,
-                        color,
-                        image: image && !isBackfilledFacePng(image) ? image : null,
-                        size: 24,
-                        name: bot.name
-                      }),
-                      jsxs('div', {
-                        className: 'min-w-0 flex-1',
-                        children: [
-                          jsx('div', { className: 'truncate text-xs text-foreground', children: displayName(bot, meta) }),
-                          jsx('div', {
-                            className: 'truncate text-[0.625rem] text-(--ui-text-quaternary)',
-                            children: [
-                              currentGroups.length
-                                ? `@${botHandle(bot.name, bot)} · in ${currentGroups.map(group => `“${group}”`).join(', ')}`
-                                : `@${botHandle(bot.name, bot)}`,
-                              bot.remoteSource && bot.connectionLabel ? ` · ${bot.connectionLabel}` : ''
-                            ].join('')
-                          })
-                        ]
-                      }),
-                      jsx(Checkbox, {
-                        checked: isChecked,
-                        disabled,
-                        onCheckedChange: value => setChecked(prev => ({ ...prev, [botRosterKey(bot)]: Boolean(value) }))
-                      })
-                    ]
-                  }, botRosterKey(bot))
-                })
-              : jsx('div', {
-                  className: 'px-1.5 py-3 text-center text-xs text-(--ui-text-tertiary)',
-                  children: query.trim() ? `No bots match “${query.trim()}”` : 'No bots yet — create one first.'
-                })
-          })
-        }),
-        jsxs('div', {
-          className: 'grid gap-2',
-          children: [
-            jsx(GroupImageControls, {
-              image,
-              onImage: setImage,
-              seedName: name.trim() || (selected.length ? placeholder : ''),
-              seedMembers: selected.map(bot => displayName(bot, botRosterMeta(bot, allMeta)))
-            }),
-            jsx('form', {
-              onSubmit: event => {
-                event.preventDefault()
-                create()
-              },
-              children: jsx(Input, {
-                'aria-label': 'Group name',
-                maxLength: 64,
-                placeholder,
-                value: name,
-                onChange: event => setName(event.target.value)
-              })
-            })
-          ]
-        }),
-        jsxs(DialogFooter, {
-          children: [
-            jsx(Button, { variant: 'secondary', onClick: onClose, children: 'Cancel' }),
-            jsx(Button, {
-              disabled: !canCreate,
-              title: selected.length < 2 ? 'Pick at least 2 bots' : undefined,
-              onClick: create,
-              children: `Create Group${selected.length ? ` (${selected.length})` : ''}`
-            })
-          ]
-        })
-      ]
-    })
-  })
-}
-
-// ── threads: the Slack/Discord shape ─────────────────────────────────────────
-// Every room entry belongs to a THREAD. Messaging the room composer starts a
-// new thread with the whole group; replying inside a thread continues that
-// work. Member turns are scoped to the thread that triggered them — deltas,
-// watermarks, and responder resolution all key on the thread id.
-
-function groupThreadOf(entry) {
-  return entry?.thread || 'legacy'
-}
-
-function mintGroupThreadId() {
-  return `t${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`
-}
-
-// Pre-thread logs (hydrated from storage) get synthetic thread ids: a user
-// entry after a real lull starts one, so multi-turn tasks stay whole instead
-// of splitting on every follow-up.
-const GROUP_THREAD_GAP_MS = 15 * 60000
-
-function assignLegacyThreads(log) {
-  let current = null
-  let n = 0
-
-  return (log || []).map((entry, i) => {
-    if (entry?.thread) {
-      current = null
-
-      return entry
-    }
-
-    const prev = log[i - 1]
-    const lull = !prev || (entry.at || 0) - (prev.at || 0) > GROUP_THREAD_GAP_MS
-
-    if (!current || (entry.from?.kind === 'user' && lull)) {
-      current = `legacy-${n++}`
-    }
-
-    return { ...entry, thread: current }
-  })
-}
-
-/** Merged room view for one group: shared timeline with per-member
- *  attribution, a composer that drives the round-robin, and a working
- *  indicator while member turns run. Renders identically in the MAIN chat
- *  window (host.openWorkspace tile) and in the bots panel (older-desktop
- *  fallback); `onBack` is where the Back button routes — the main tile's
- *  closer, or clearing the in-panel workspace atom. */
-/** The active @-token at the caret: text from the nearest '@' (that begins a
- *  word) up to the caret, or null when the caret isn't inside a mention. */
-function mentionTokenAt(text, caret) {
-  const upto = String(text || '').slice(0, caret)
-  const match = /(^|\s)@([a-z0-9._-]*)$/i.exec(upto)
-
-  if (!match) {
-    return null
-  }
-
-  return { query: match[2].toLowerCase(), start: caret - match[2].length - 1 }
-}
-
-/** Mention-aware composer input for group rooms. The core composer's
- *  @-completion area doesn't mount inside workspace tiles (#89049), so this
- *  wraps the plain SDK Input with a member-scoped popover: @everyone/@all
- *  quick picks plus each seated member's handle. Insertion produces exactly
- *  the strings parseGroupChatMentions resolves. Keyboard: Up/Down navigate,
- *  Enter/Tab insert (Enter falls through to submit when the popover is
- *  closed), Escape dismisses. */
-function GroupMentionInput({ members, onChange, onSubmitDraft, value, ...inputProps }) {
-  const allMeta = useValue($botMeta)
-  const inputRef = useRef(null)
-  const [token, setToken] = useState(null)
-  const [selected, setSelected] = useState(0)
-
-  const options = []
-
-  if (token) {
-    for (const pick of ['everyone', 'all']) {
-      if (pick.startsWith(token.query)) {
-        options.push({ handle: pick, meta: 'Every bot in the room' })
-      }
-    }
-
-    for (const member of members) {
-      const handle = String(member.handle || botHandle(member.name, member) || '').trim()
-      const display = displayName(member, botRosterMeta(member, allMeta))
-      // Renamed members complete on their friendly tag; parser resolves both.
-      const tag = String(botMentionTag(member) || handle).trim()
-
-      if (!tag) {
-        continue
-      }
-
-      if (
-        token.query &&
-        !tag.toLowerCase().startsWith(token.query) &&
-        !(handle && handle.toLowerCase().startsWith(token.query)) &&
-        !display.toLowerCase().startsWith(token.query)
-      ) {
-        continue
-      }
-
-      options.push({
-        handle: tag,
-        meta: display
-      })
-    }
-  }
-
-  const open = Boolean(token) && options.length > 0
-  const active = open ? Math.min(selected, options.length - 1) : 0
-
-  const refreshToken = target => {
-    setToken(mentionTokenAt(target.value, target.selectionStart ?? target.value.length))
-    setSelected(0)
-  }
-
-  const insert = handle => {
-    if (!token) {
-      return
-    }
-
-    const caret = inputRef.current?.selectionStart ?? value.length
-    const next = `${value.slice(0, token.start)}@${handle} ${value.slice(caret)}`
-    onChange(next)
-    setToken(null)
-
-    // Restore focus with the caret after the inserted mention.
-    const pos = token.start + handle.length + 2
-    requestAnimationFrame(() => {
-      const el = inputRef.current
-
-      if (el) {
-        el.focus()
-        try {
-          el.setSelectionRange(pos, pos)
-        } catch {
-          /* input type without selection support */
-        }
-      }
-    })
-  }
-
-  return jsxs('div', {
-    className: 'relative min-w-0 flex-1',
-    children: [
-      open
-        ? jsx('div', {
-            className:
-              'absolute bottom-full left-0 z-50 mb-1 max-h-48 w-64 overflow-y-auto rounded-md border border-(--ui-stroke-secondary) bg-(--ui-bg-primary,#111) py-1 shadow-lg',
-            children: options.map((option, index) =>
-              jsxs('button', {
-                type: 'button',
-                className: cn(
-                  'flex w-full items-baseline gap-2 px-2 py-1 text-left text-xs',
-                  index === active ? 'bg-(--ui-control-hover-background) text-foreground' : 'text-(--ui-text-secondary)'
-                ),
-                // preventDefault on mousedown so the input keeps focus.
-                onMouseDown: event => {
-                  event.preventDefault()
-                  insert(option.handle)
-                },
-                onMouseEnter: () => setSelected(index),
-                children: [
-                  jsx('span', { className: 'font-medium', children: `@${option.handle}` }),
-                  jsx('span', { className: 'truncate text-[0.65rem] text-(--ui-text-quaternary)', children: option.meta })
-                ]
-              }, option.handle)
-            )
-          })
-        : null,
-      jsx(Textarea, {
-        ...inputProps,
-        ref: inputRef,
-        value,
-        rows: 1,
-        // Multi-line room prompts (#89884): the composer was a single-line
-        // Input whose form submitted on every Enter — newlines were
-        // impossible. Enter (no Shift) still submits via onSubmitDraft;
-        // Shift+Enter falls through to the textarea's native newline.
-        className: cn('max-h-40 min-h-9 resize-none', inputProps.className),
-        onChange: event => {
-          onChange(event.target.value)
-          refreshToken(event.target)
-        },
-        onClick: event => refreshToken(event.target),
-        onKeyDown: event => {
-          // IME composition guard (same as the core composer): Enter here
-          // confirms the composed Chinese/Japanese/Korean text — it must not
-          // insert a mention nor submit the draft. nativeEvent.isComposing
-          // covers Chromium; keyCode 229 covers macOS Chinese IMEs that fire
-          // Enter after compositionend with isComposing already false.
-          if (event.nativeEvent?.isComposing || event.keyCode === 229) {
-            return
-          }
-          if (open) {
-            if (event.key === 'ArrowDown') {
-              event.preventDefault()
-              setSelected((active + 1) % options.length)
-
-              return
-            }
-
-            if (event.key === 'ArrowUp') {
-              event.preventDefault()
-              setSelected((active - 1 + options.length) % options.length)
-
-              return
-            }
-
-            if (event.key === 'Enter' || event.key === 'Tab') {
-              event.preventDefault()
-              insert(options[active].handle)
-
-              return
-            }
-
-            if (event.key === 'Escape') {
-              event.preventDefault()
-              setToken(null)
-
-              return
-            }
-          }
-
-          if (event.key === 'Enter' && !event.shiftKey) {
-            event.preventDefault()
-            onSubmitDraft?.()
-          }
-        },
-        onBlur: () => setToken(null)
-      })
-    ]
-  })
-}
-
-/** One member's pending prompt, rendered in the room (#90694).
- *  - clarify: choices as tap buttons (multi-select stages; single-select
- *    stages one), free text always available, batch sub-questions each get
- *    their own input.
- *  - approval: the command in a code row plus the server's choice set
- *    (once/session/always/deny) as buttons — no free text; approvals are a
- *    closed choice. Answer sends via the member's own source. */
-function GroupClarifyCard({ entry, members }) {
-  const { group } = entry
-  const isApproval = entry.kind === 'approval'
-  const member = members.find(m => groupMemberKey(m) === entry.memberKey) || members.find(m => m.name === entry.member)
-  const [drafts, setDrafts] = useState({})
-  const [picked, setPicked] = useState({})
-  const [sending, setSending] = useState(false)
-  const questions = entry.questions && entry.questions.length
-    ? entry.questions.map((q, i) => ({
-        qid: q?.qid ?? q?.id ?? `q${i}`,
-        question: typeof q?.question === 'string' ? q.question : '',
-        choices: Array.isArray(q?.choices) ? q.choices.filter(c => typeof c === 'string' && c) : [],
-        multiSelect: Boolean(q?.multi_select ?? q?.multiSelect)
-      }))
-    : [{ qid: '__single__', question: entry.question, choices: entry.choices, multiSelect: entry.multiSelect }]
-
-  const answerFor = q => {
-    const chosen = picked[q.qid] || []
-
-    if (chosen.length) {
-      return q.multiSelect ? JSON.stringify(chosen) : chosen[0]
-    }
-
-    return isApproval ? '' : (drafts[q.qid] || '').trim()
-  }
-
-  const allAnswered = questions.every(q => answerFor(q))
-
-  const submit = async () => {
-    if (!member || sending || !allAnswered) {
-      return
-    }
-
-    setSending(true)
-
-    try {
-      if (isApproval || !(entry.questions && entry.questions.length)) {
-        await answerGroupClarify(entry, member, answerFor(questions[0]))
-      } else {
-        const answers = {}
-
-        for (const q of questions) {
-          answers[q.qid] = answerFor(q)
-        }
-
-        await answerGroupClarify(entry, member, answers)
-      }
-
-      // Echo the exchange into the room log so the thread reads complete.
-      const summary = isApproval
-        ? `${answerFor(questions[0])} — ${entry.command || entry.question || 'command approval'}`
-        : questions
-            .map(q => (questions.length > 1 ? `${q.question}: ${answerFor(q)}` : answerFor(q)))
-            .join('\n')
-      appendGroupChatEntry(group, { kind: 'user', name: 'You' }, summary, entry.thread || 'legacy')
-    } catch (err) {
-      host.notify({ kind: 'error', message: `Could not send the answer to @${botHandle(entry.member, member)}: ${err?.message || err}` })
-    } finally {
-      setSending(false)
-    }
-  }
-
-  return jsxs('div', {
-    className:
-      'grid gap-1.5 rounded-md border border-(--ui-accent,#4f9cf9)/50 bg-(--ui-accent,#4f9cf9)/5 px-2.5 py-2',
-    children: [
-      jsxs('div', {
-        className: 'flex items-center gap-1.5 text-xs font-medium',
-        children: [
-          jsx(Codicon, {
-            name: isApproval ? 'shield' : 'question',
-            className: 'shrink-0 text-(--ui-accent,#4f9cf9)'
-          }),
-          isApproval
-            ? `@${botHandle(entry.member, member)} wants to run a command:`
-            : `@${botHandle(entry.member, member)} asks:`
-        ]
-      }),
-      isApproval && entry.command
-        ? jsx('code', {
-            className:
-              'block overflow-x-auto rounded bg-(--ui-bg-secondary,rgba(0,0,0,0.25)) px-2 py-1 font-mono text-[0.7rem] whitespace-pre-wrap break-all',
-            children: entry.command
-          })
-        : null,
-      ...questions.map(q =>
-        jsxs('div', {
-          className: 'grid gap-1',
-          children: [
-            q.question
-              ? jsx('div', { className: 'text-xs whitespace-pre-wrap', children: q.question })
-              : null,
-            q.choices.length
-              ? jsx('div', {
-                  className: 'flex flex-wrap gap-1',
-                  children: q.choices.map(choice => {
-                    const chosen = (picked[q.qid] || []).includes(choice)
-
-                    return jsx(Button, {
-                      size: 'sm',
-                      variant: chosen ? 'default' : 'secondary',
-                      className: cn(
-                        'h-6 px-2 text-[0.7rem]',
-                        isApproval && choice === 'deny' && !chosen && 'text-destructive'
-                      ),
-                      onClick: () => {
-                        setDrafts(prev => ({ ...prev, [q.qid]: '' }))
-                        setPicked(prev => {
-                          const current = prev[q.qid] || []
-                          const next = q.multiSelect
-                            ? chosen
-                              ? current.filter(c => c !== choice)
-                              : [...current, choice]
-                            : chosen
-                              ? []
-                              : [choice]
-
-                          return { ...prev, [q.qid]: next }
-                        })
-                      },
-                      children: choice
-                    }, `choice:${q.qid}:${choice}`)
-                  })
-                })
-              : null,
-            // Approvals are a closed choice set — no free-text input.
-            isApproval
-              ? null
-              : jsx(Input, {
-                  'aria-label': `Answer @${entry.member}`,
-                  placeholder: q.choices.length ? 'Or type your own answer…' : 'Type your answer…',
-                  value: drafts[q.qid] || '',
-                  onChange: event => {
-                    const value = event.target.value
-                    setPicked(prev => ({ ...prev, [q.qid]: [] }))
-                    setDrafts(prev => ({ ...prev, [q.qid]: value }))
-                  },
-                  onKeyDown: event => {
-                    // IME guard: Enter confirming a composed word must not submit.
-                    if (event.nativeEvent?.isComposing || event.keyCode === 229) {
-                      return
-                    }
-                    if (event.key === 'Enter' && questions.length === 1) {
-                      event.preventDefault()
-                      void submit()
-                    }
-                  },
-                  className: 'h-7 text-xs'
-                }, `input:${q.qid}`)
-          ]
-        }, `q:${q.qid}`)
-      ),
-      jsx('div', {
-        className: 'flex justify-end',
-        children: jsx(Button, {
-          size: 'sm',
-          disabled: sending || !allAnswered || !member,
-          onClick: () => void submit(),
-          children: sending ? 'Sending…' : isApproval ? 'Respond' : 'Answer'
-        })
-      })
-    ]
-  })
-}
-
-// Group composer drafts are window-local UI state. They must survive pane
-// parking/re-registration and owner switches, but must never enter shared room
-// metadata (where another Desktop would see half-typed text or attachment
-// bytes). Current rooms key by immutable roomId; legacy rooms fall back to the
-// display name until they are upgraded.
-const groupComposerDrafts = new Map()
-
-function emptyGroupComposerDraft() {
-  return { activeReplyThread: null, main: '', pendingAttachments: {}, replies: {}, revision: 0 }
-}
-
-function groupComposerDraftKey(group, room) {
-  return groupChatRoomKey(group, room)
-}
-
-function groupComposerDraftSnapshot(key) {
-  return groupComposerDrafts.get(key) || emptyGroupComposerDraft()
-}
-
-function updateGroupComposerDraft(key, mutate) {
-  const current = groupComposerDraftSnapshot(key)
-  const next = mutate({
-    ...current,
-    pendingAttachments: Object.fromEntries(
-      Object.entries(current.pendingAttachments || {}).map(([thread, attachments]) => [
-        thread,
-        [...(attachments || [])]
-      ])
-    ),
-    replies: { ...(current.replies || {}) }
-  })
-
-  next.revision = current.revision + 1
-  groupComposerDrafts.delete(key)
-  groupComposerDrafts.set(key, next)
-
-  return next
-}
-
-function restoreGroupComposerDraft(key, expectedRevision, snapshot) {
-  const current = groupComposerDraftSnapshot(key)
-
-  if (current.revision !== expectedRevision) {
-    return null
-  }
-
-  const restored = {
-    ...snapshot,
-    pendingAttachments: Object.fromEntries(
-      Object.entries(snapshot.pendingAttachments || {}).map(([thread, attachments]) => [
-        thread,
-        [...(attachments || [])]
-      ])
-    ),
-    replies: { ...(snapshot.replies || {}) },
-    revision: current.revision + 1
-  }
-
-  groupComposerDrafts.set(key, restored)
-
-  return restored
-}
-
-function clearGroupComposerDraft(key) {
-  groupComposerDrafts.delete(key)
-}
-
-function migrateGroupComposerDraft(oldKey, newKey) {
-  if (oldKey === newKey || !groupComposerDrafts.has(oldKey)) {
-    return
-  }
-
-  if (!groupComposerDrafts.has(newKey)) {
-    groupComposerDrafts.set(newKey, groupComposerDrafts.get(oldKey))
-  }
-
-  groupComposerDrafts.delete(oldKey)
-}
-
-function GroupChatWorkspace({ group, members, onBack, visible = true }) {
-  const rooms = useValue($groupChats)
-  const allMeta = useValue($botMeta)
-  const room = rooms[group] || { log: [], running: false }
-  const composerKey = groupComposerDraftKey(group, room)
-  const composerKeyRef = useRef(composerKey)
-  const [composerDraft, setComposerDraft] = useState(() => groupComposerDraftSnapshot(composerKey))
-
-  if (composerKeyRef.current !== composerKey) {
-    migrateGroupComposerDraft(composerKeyRef.current, composerKey)
-    composerKeyRef.current = composerKey
-  }
-
-  const updateComposerDraft = mutate => {
-    const next = updateGroupComposerDraft(composerKeyRef.current, mutate)
-    setComposerDraft(next)
-
-    return next
-  }
-
-  const draft = composerDraft.main || ''
-  const replyDrafts = composerDraft.replies || {}
-  const replyThread = composerDraft.activeReplyThread || null
-  const pendingImages = composerDraft.pendingAttachments || {}
-  const setDraft = value =>
-    updateComposerDraft(current => ({
-      ...current,
-      main: typeof value === 'function' ? value(current.main || '') : value
-    }))
-  const setReplyDrafts = value =>
-    updateComposerDraft(current => ({
-      ...current,
-      replies: typeof value === 'function' ? value(current.replies || {}) : value
-    }))
-  const setReplyThread = value =>
-    updateComposerDraft(current => ({
-      ...current,
-      activeReplyThread:
-        typeof value === 'function' ? value(current.activeReplyThread || null) : value
-    }))
-  const setPendingImages = value =>
-    updateComposerDraft(current => ({
-      ...current,
-      pendingAttachments:
-        typeof value === 'function' ? value(current.pendingAttachments || {}) : value
-    }))
-  const [confirmDisband, setConfirmDisband] = useState(false)
-  const [settingsOpen, setSettingsOpen] = useState(false)
-  // Click-to-disambiguate: which log entry is showing its speaker's full
-  // @handle (the roster's name-device form when names collide across
-  // connections). Naturally every speaker just shows its display name.
-  const [revealedSpeaker, setRevealedSpeaker] = useState(null)
-  // Threads, the Slack/Discord shape: entries carry a thread id. The most
-  // recently active thread renders open; older ones collapse to summary rows.
-  // `openThreads` is the user's explicit expand/collapse overrides, and
-  // `replyThread` is the thread whose reply box currently owns the composer
-  // (null = the main composer, which STARTS a new thread).
-  const [openThreads, setOpenThreads] = useState({})
-  // Pending image attachments per composer: `null` thread key = the main
-  // composer, otherwise the reply box of that thread. Data URLs, already
-  // downscaled — they ride the send into every responding member's session.
-
-  // Scroll anchoring (#89835): rooms used to open at scroll position 0 and
-  // stay there while replies streamed in. Scroll the bottom sentinel into
-  // view on mount and whenever the log grows — but only when the user is
-  // already near the bottom, so reading history is never yanked away.
-  const bottomSentinelRef = useRef(null)
-  const stickToBottomRef = useRef(true)
-
-  useEffect(() => {
-    const sentinel = bottomSentinelRef.current
-
-    if (!sentinel) {
-      return
-    }
-
-    const viewport = sentinel.closest('[data-slot="scroll-area-viewport"]')
-
-    if (viewport) {
-      const onScroll = () => {
-        stickToBottomRef.current = viewport.scrollHeight - viewport.scrollTop - viewport.clientHeight < 80
-      }
-
-      viewport.addEventListener('scroll', onScroll, { passive: true })
-
-      return () => viewport.removeEventListener('scroll', onScroll)
-    }
-  }, [])
-
-  useEffect(() => {
-    if (stickToBottomRef.current) {
-      bottomSentinelRef.current?.scrollIntoView({ block: 'end' })
-    }
-  }, [room.log.length, room.running])
-
-  // Retained-pane reopen (#89835 follow-up): a hot-mounted room pane stays
-  // mounted while another workspace tab is active, so returning to it never
-  // remounts and the mount-time anchor doesn't rerun. Re-anchor on the
-  // hidden → visible edge — an explicit reopen, so it overrides a stale
-  // read-position and mirrors what a fresh open does.
-  const wasVisibleRef = useRef(visible)
-
-  useEffect(() => {
-    if (visible && !wasVisibleRef.current) {
-      stickToBottomRef.current = true
-      bottomSentinelRef.current?.scrollIntoView({ block: 'end' })
-    }
-
-    wasVisibleRef.current = visible
-  }, [visible])
-
-  const imagesFor = thread => pendingImages[thread ?? 'main'] || []
-
-  const addImages = (thread, picked) => {
-    if (!picked.length) {
-      return
-    }
-
-    const key = thread ?? 'main'
-    setPendingImages(prev => ({ ...prev, [key]: [...(prev[key] || []), ...picked] }))
-  }
-
-  const removeImage = (thread, index) => {
-    const key = thread ?? 'main'
-    setPendingImages(prev => ({ ...prev, [key]: (prev[key] || []).filter((_, i) => i !== index) }))
-  }
-
-  // Ctrl/⌘-V a screenshot (or any file) into any composer in this room.
-  const pasteImages = (thread, event) => {
-    const files = [...(event.clipboardData?.files || [])]
-
-    if (!files.length) {
-      return
-    }
-
-    event.preventDefault()
-    void filesToGroupAttachments(files).then(picked => addImages(thread, picked))
-  }
-
-  // Drag & drop anywhere on the room drops into the ACTIVE composer — the
-  // open reply box when one owns the composer, else the main (new-thread)
-  // composer. Matches the 1:1 chat's drop affordance.
-  const [dragOver, setDragOver] = useState(false)
-
-  const dropFiles = event => {
-    const files = [...(event.dataTransfer?.files || [])]
-
-    setDragOver(false)
-
-    if (!files.length) {
-      return
-    }
-
-    event.preventDefault()
-    void filesToGroupAttachments(files).then(picked => addImages(replyThread, picked))
-  }
-
-  // Collapsible Activity view: collapsed by default — opening it is always an
-  // explicit user action, it never steals focus, and it never auto-scrolls.
-  const [activityOpen, setActivityOpen] = useState(false)
-  // Subscribe: activity rows re-render as turn events land.
-  useValue($groupActivity)
-  // Pending member questions for THIS room (#90694), oldest first.
-  const clarifyAll = useValue($groupClarify)
-  const roomClarifies = Object.values(clarifyAll || {})
-    .filter(entry => entry?.group === group)
-    .sort((a, b) => (a.at || 0) - (b.at || 0))
-  const availableMembers = members.filter(member => botSourceStatus(member).available).length
-  const availabilityLabel = `${availableMembers} of ${members.length} available`
-  const memberNames = members.map(b => displayName(b, botRosterMeta(b, allMeta))).join(', ') || 'No bots in this group chat'
-
-  const header = jsxs('div', {
-    className: 'flex items-center gap-2 px-2.5 pt-2.5 pb-2',
-    children: [
-      jsx(Button, {
-        variant: 'ghost',
-        size: 'sm',
-        onClick: () => (onBack ? onBack() : $groupChatWorkspace.set(null)),
-        children: 'Back'
-      }),
-      // Room picture (set via Group settings) leads the title when present.
-      room.image
-        ? jsx('img', {
-            src: room.image,
-            alt: '',
-            className: 'size-6 shrink-0 rounded-md object-cover ring-1 ring-(--ui-stroke-secondary)'
-          })
-        : jsx('span', {
-            className:
-              'flex size-6 shrink-0 items-center justify-center rounded-md bg-(--chrome-action-hover) text-(--ui-text-tertiary)',
-            children: jsx(Codicon, { name: 'organization' })
-          }),
-      jsx('div', {
-        className: 'min-w-0 flex-1 truncate text-sm font-semibold',
-        children: group
-      }),
-      jsx(Tip, {
-        label: memberNames,
-        children: jsx('span', {
-          className: cn(
-            'shrink-0 text-[0.65rem] text-(--ui-text-quaternary)',
-            members.length > 0 && availableMembers < members.length && 'text-amber-600 dark:text-amber-300'
-          ),
-          'aria-label': availabilityLabel,
-          children: members.length > 0 && availableMembers < members.length ? availabilityLabel : `${members.length} bots`
-        })
-      }),
-      jsx(Tip, {
-        label: `Group settings — rename ${group} or set a room picture`,
-        children: jsx(Button, {
-          variant: 'ghost',
-          size: 'sm',
-          className: 'shrink-0 text-(--ui-text-tertiary) hover:text-foreground',
-          'aria-label': `Group settings for ${group}`,
-          onClick: () => setSettingsOpen(true),
-          children: jsx(Codicon, { name: 'gear' })
-        })
-      }),
-      jsx(Tip, {
-        label: `Disband the ${group} group chat`,
-        children: jsx(Button, {
-          variant: 'ghost',
-          size: 'sm',
-          className: 'shrink-0 text-(--ui-text-tertiary) hover:text-destructive',
-          'aria-label': `Disband ${group}`,
-          onClick: () => setConfirmDisband(true),
-          children: jsx(Codicon, { name: 'trash' })
-        })
-      })
-    ]
-  })
-
-  const memberDescriptors = () =>
-    members.map(b => ({
-      ...b,
-      title: (b.remoteSource ? '' : allMeta[b.name]?.title) || b.title || ''
-    }))
-
-  // Activity disclosure: quiet, collapsed by default. The collapsed row shows
-  // the latest event; expanding lists the current run's events newest-first.
-  // Events are epoch-tagged, so a superseded run's history drops out of view.
-  const activityEvents = currentGroupActivity(group)
-  const latestActivity = activityEvents.length ? activityEvents[activityEvents.length - 1] : null
-  // #94570 shell rewired onto the real primitive (#91868/#94569): the button
-  // must stop the ROUND, not just spray per-member interrupts — without the
-  // epoch bump + holds the loop marched on to the next member. Thread scope:
-  // the run being stopped is the one the latest activity belongs to.
-  const stopRoomRun = async () => {
-    await stopGroupThread(group, latestActivity?.thread || null, memberDescriptors())
-    host.notify({ kind: 'success', message: `Stopped ${group} — remaining turns are held until you resume` })
-  }
-
-  const activityPanel = jsxs('div', {
-    className: 'border-b border-(--ui-stroke-secondary)',
-    children: [
-      jsxs('div', {
-        className: 'flex items-center gap-1',
-        children: [
-          jsxs('button', {
-            type: 'button',
-            'aria-expanded': activityOpen,
-            'aria-controls': `group-activity:${group}`,
-            title: activityOpen ? 'Hide room activity' : 'Show room activity',
-            className:
-              'flex min-w-0 flex-1 items-center gap-1.5 px-2.5 py-1 text-left text-[0.7rem] text-(--ui-text-quaternary) transition-colors hover:text-foreground',
-            onClick: () => setActivityOpen(prev => !prev),
-            children: [
-              jsx(Codicon, {
-                name: activityOpen ? 'chevron-down' : 'chevron-right',
-                className: 'shrink-0 text-[0.65rem]'
-              }),
-              jsx('span', { className: 'shrink-0 font-medium', children: 'Activity' }),
-              latestActivity
-                ? jsx('span', {
-                    className: 'min-w-0 flex-1 truncate',
-                    children: `${groupActivityLabel(latestActivity)} · ${relativeTime(latestActivity.at)}`
-                  })
-                : null
-            ]
-          }),
-          room.running
-            ? jsx('button', {
-                type: 'button',
-                title: 'Stop this run — interrupts the member on turn and holds the rest',
-                className:
-                  'inline-flex shrink-0 items-center gap-1 rounded px-1.5 py-0.5 text-[0.7rem] font-medium text-(--ui-accent) transition-colors hover:bg-(--chrome-action-hover)',
-                onClick: () => void stopRoomRun(),
-                children: [
-                  jsx(Codicon, { name: 'debug-stop', className: 'shrink-0 text-[0.75rem]' }),
-                  'Stop'
-                ]
-              })
-            : null
-        ]
-      }),
-      activityOpen
-        ? jsx('div', {
-            id: `group-activity:${group}`,
-            className: 'grid gap-0.5 px-2.5 pb-1.5',
-            children: activityEvents.length
-              ? [...activityEvents]
-                  .reverse()
-                  .map((event, i) =>
-                    jsxs('div', {
-                      className: 'flex items-center gap-1.5 text-[0.7rem]',
-                      children: [
-                        jsx(Codicon, {
-                          name: GROUP_ACTIVITY_GLYPHS[event.kind] || 'circle-outline',
-                          className: cn('shrink-0 text-[0.65rem]', groupActivityTone(event.kind))
-                        }),
-                        jsx('span', {
-                          className: cn('min-w-0 flex-1 truncate', groupActivityTone(event.kind)),
-                          children: groupActivityLabel(event)
-                        }),
-                        jsx('span', {
-                          className: 'shrink-0 text-[0.625rem] text-(--ui-text-quaternary)',
-                          children: relativeTime(event.at)
-                        }),
-                        event.kind === 'working'
-                          ? jsx('button', {
-                              type: 'button',
-                              title: 'Stop this run — interrupts the member on turn and holds the rest',
-                              className:
-                                'inline-flex shrink-0 items-center gap-0.5 rounded px-1 py-px text-[0.65rem] font-medium text-(--ui-accent) transition-colors hover:bg-(--chrome-action-hover)',
-                              onClick: () => void stopRoomRun(),
-                              children: [
-                                jsx(Codicon, { name: 'debug-stop', className: 'shrink-0 text-[0.7rem]' }),
-                                'Stop'
-                              ]
-                            })
-                          : null
-                      ]
-                    }, `${event.at}:${i}`)
-                  )
-              : jsx('div', {
-                  className: 'px-0.5 pb-0.5 text-[0.625rem] text-(--ui-text-quaternary)',
-                  children: 'No activity in this turn yet.'
-                })
-          })
-        : null
-    ]
-  })
-
-  const submit = () => {
-    const text = draft.trim()
-    const images = imagesFor(null)
-
-    if (!text && !images.length) {
-      return
-    }
-
-    const before = groupComposerDraftSnapshot(composerKeyRef.current)
-    const cleared = updateComposerDraft(current => ({
-      ...current,
-      main: '',
-      pendingAttachments: { ...(current.pendingAttachments || {}), main: [] }
-    }))
-    // Main composer = START A NEW THREAD with the whole group (Slack shape).
-    // Full descriptors ride into the turn loop: remote members keep their
-    // connection fields so their turns route to their own machines.
-    const minted = sendToGroupChat(group, memberDescriptors(), text, null, images)
-
-    if (minted) {
-      setOpenThreads(prev => ({ ...prev, [minted]: true }))
-    } else {
-      const restored = restoreGroupComposerDraft(composerKeyRef.current, cleared.revision, before)
-
-      if (restored) {
-        setComposerDraft(restored)
-      }
-    }
-  }
-
-  const submitReply = thread => {
-    const text = (replyDrafts[thread] || '').trim()
-    const images = imagesFor(thread)
-
-    if (!text && !images.length) {
-      return
-    }
-
-    const before = groupComposerDraftSnapshot(composerKeyRef.current)
-    const cleared = updateComposerDraft(current => ({
-      ...current,
-      pendingAttachments: { ...(current.pendingAttachments || {}), [thread]: [] },
-      replies: { ...(current.replies || {}), [thread]: '' }
-    }))
-    // Reply box = CONTINUE this thread; the member turns it triggers are
-    // scoped to it.
-    const sent = sendToGroupChat(group, memberDescriptors(), text, thread, images)
-
-    if (sent) {
-      setOpenThreads(prev => ({ ...prev, [thread]: true }))
-    } else {
-      const restored = restoreGroupComposerDraft(composerKeyRef.current, cleared.revision, before)
-
-      if (restored) {
-        setComposerDraft(restored)
-      }
-    }
-  }
-
-  /** Pending-attachment chips + the picker for one composer (thread = null →
-   *  main). Image chips preview the pixels; PDFs/files show a type icon.
-   *  X removes it. */
-  const attachmentRow = thread => {
-    const images = imagesFor(thread)
-
-    if (!images.length) {
-      return null
-    }
-
-    return jsx('div', {
-      className: 'flex flex-wrap items-center gap-1.5 px-1 pb-1',
-      children: images.map((img, index) =>
-        jsxs('div', {
-          className:
-            'flex items-center gap-1 rounded-md border border-(--ui-stroke-secondary) bg-(--ui-bg-secondary,#181818) px-1 py-0.5',
-          children: [
-            img.kind === 'pdf' || img.kind === 'file'
-              ? jsx(Codicon, {
-                  name: img.kind === 'pdf' ? 'file-pdf' : 'file',
-                  className: 'text-[0.9rem] text-(--ui-text-tertiary)'
-                })
-              : jsx('img', { src: img.data, alt: '', className: 'size-6 rounded object-cover' }),
-            jsx('span', {
-              className: 'max-w-32 truncate text-[0.65rem] text-(--ui-text-tertiary)',
-              children: img.name || 'image'
-            }),
-            jsx('button', {
-              type: 'button',
-              className: 'cursor-pointer border-0 bg-transparent p-0 text-(--ui-text-quaternary) hover:text-foreground',
-              title: 'Remove attachment',
-              onClick: () => removeImage(thread, index),
-              children: jsx(Codicon, { name: 'close', className: 'text-[0.65rem]' })
-            })
-          ]
-        }, `${img.name || 'img'}:${index}`)
-      )
-    })
-  }
-
-  const attachButton = thread =>
-    jsx(Button, {
-      type: 'button',
-      variant: 'ghost',
-      size: 'sm',
-      className: 'shrink-0 text-(--ui-text-tertiary) hover:text-foreground',
-      title: 'Attach files — every responding bot sees them',
-      onClick: () => void pickGroupAttachments().then(picked => addImages(thread, picked)),
-      children: jsx(Codicon, { name: 'attach' })
-    })
-
-  // One log entry, rendered exactly as before conversation folding existed.
-  const renderEntry = (entry, index) => {
-                  const isUser = entry.from.kind === 'user'
-                  const meta = isUser || entry.from.source ? null : allMeta[entry.from.name]
-                  // Match this speaker back to its member descriptor so display
-                  // names and disambiguating handles come from the roster (the
-                  // primary "default" profile renders as Hermes, remote dupes
-                  // carry their @name-device handle) instead of raw profile ids.
-                  const member = isUser
-                    ? null
-                    : members.find(b =>
-                        b.name === entry.from.name &&
-                        (entry.from.source
-                          ? (b.connectionLabel || b.connectionId) === entry.from.source
-                          : !b.remoteSource)
-                      ) || null
-                  const display = isUser ? 'You' : displayName(member || { name: entry.from.name }, meta)
-                  const entryKey = `${entry.at}:${index}`
-                  const revealed = !isUser && revealedSpeaker === entryKey
-                  // Clicked: append the gateway name so same-named agents on
-                  // two connections are tellable apart on demand.
-                  const label = isUser
-                    ? 'You'
-                    : revealed
-                      ? `${display}${entry.from.source ? `-${entry.from.source}` : ''} (@${botHandle(entry.from.name, member || undefined)})`
-                      : display
-                  // Speaker avatar: same appearance pipeline as the roster
-                  // (custom image/pet, else deterministic shape+color face).
-                  // Remote speakers have no local meta and get the
-                  // deterministic face for their name — stable per bot.
-                  const { shape, color, image } = isUser
-                    ? { shape: null, color: null, image: null }
-                    : botAppearance(entry.from.name, meta)
-                  const photo = Boolean(image && !isBackfilledFacePng(image))
-
-                  return jsxs('div', {
-                    className: cn(
-                      'group flex items-start gap-2',
-                      isUser ? 'rounded-md bg-(--chrome-action-hover) px-2 py-1.5' : 'px-2 py-1'
-                    ),
-                    children: [
-                      isUser
-                        ? null
-                        : jsx('div', {
-                            className: 'mt-0.5 shrink-0',
-                            children: jsx(BotFace, {
-                              shape,
-                              color,
-                              image: photo ? image : null,
-                              size: 24,
-                              name: entry.from.name
-                            })
-                          }),
-                      jsxs('div', {
-                        className: 'min-w-0 flex-1',
-                        children: [
-                          jsxs('div', {
-                            className: 'flex items-center gap-2',
-                            children: [
-                              isUser
-                                ? jsx('span', {
-                                    className: 'text-[0.7rem] font-semibold text-foreground',
-                                    children: label
-                                  })
-                                : jsx('button', {
-                                    type: 'button',
-                                    className:
-                                      'cursor-pointer border-0 bg-transparent p-0 text-left text-[0.7rem] font-semibold text-(--ui-accent,#4f9cf9)',
-                                    title: revealed ? 'Hide full handle' : 'Show full handle',
-                                    onClick: () => setRevealedSpeaker(revealed ? null : entryKey),
-                                    children: label
-                                  }),
-                              jsx('span', {
-                                className: 'text-[0.625rem] text-(--ui-text-quaternary)',
-                                children: relativeTime(entry.at)
-                              }),
-                              entry.text.trim()
-                                ? jsx('div', {
-                                    className:
-                                      'ml-auto shrink-0 opacity-0 pointer-events-none group-hover:pointer-events-auto group-hover:opacity-100 focus-within:pointer-events-auto focus-within:opacity-100',
-                                    children: jsx(CopyButton, {
-                                      appearance: 'icon',
-                                      buttonSize: 'icon',
-                                      stopPropagation: true,
-                                      text: entry.text
-                                    })
-                                  })
-                                : null
-                            ]
-                          }),
-                          jsx('div', {
-                            className:
-                              'text-xs text-(--ui-text-secondary) [&_p]:mb-1 [&_p:last-child]:mb-0 [&_ul]:mb-1 [&_ul]:list-disc [&_ul]:pl-4 [&_ol]:mb-1 [&_ol]:list-decimal [&_ol]:pl-4 [&_pre]:overflow-x-auto',
-                            // The app shell sets user-select: none globally; message bodies opt
-                            // back in so drag-select and ⌘C work in group chat logs.
-                            'data-selectable-text': 'true',
-                            children: Streamdown ? jsx(Streamdown, { children: entry.text }) : entry.text
-                          }),
-                          // User attachments: what every responding bot was
-                          // shown — image previews, or a named chip for
-                          // PDFs/files.
-                          Array.isArray(entry.images) && entry.images.length
-                            ? jsx('div', {
-                                className: 'mt-1 flex flex-wrap items-center gap-1.5',
-                                children: entry.images.map((img, imgIndex) =>
-                                  img.kind === 'pdf' || img.kind === 'file'
-                                    ? jsxs('div', {
-                                        className:
-                                          'flex items-center gap-1 rounded-md border border-(--ui-stroke-secondary) px-1.5 py-1 text-[0.65rem] text-(--ui-text-tertiary)',
-                                        title: img.name || 'attached file',
-                                        children: [
-                                          jsx(Codicon, { name: img.kind === 'pdf' ? 'file-pdf' : 'file', className: 'text-[0.8rem]' }),
-                                          jsx('span', { className: 'max-w-48 truncate', children: img.name || 'attached file' })
-                                        ]
-                                      }, `${entryKey}:img:${imgIndex}`)
-                                    : jsx('img', {
-                                        src: img.data,
-                                        alt: img.name || 'attached image',
-                                        title: img.name || 'attached image',
-                                        className:
-                                          'max-h-40 max-w-60 rounded-md border border-(--ui-stroke-secondary) object-contain'
-                                      }, `${entryKey}:img:${imgIndex}`)
-                                )
-                              })
-                            : null
-                        ]
-                      })
-                    ]
-                  }, entryKey)
-  }
-
-  // Threads: group entries by thread id (hydration assigned legacy ids, but
-  // guard live pre-thread entries too), ordered by last activity — oldest
-  // first, so the busiest/newest thread sits at the bottom by the composer.
-  // The most recently ACTIVE thread renders open; older ones collapse to a
-  // Slack-style summary row unless explicitly opened. Every open thread gets
-  // its own reply box, which continues THAT thread.
-  const threadsById = new Map()
-
-  for (let i = 0; i < room.log.length; i++) {
-    const entry = room.log[i]
-    const id = groupThreadOf(entry)
-    let bucket = threadsById.get(id)
-
-    if (!bucket) {
-      bucket = { entries: [], id, startIndex: i }
-      threadsById.set(id, bucket)
-    }
-
-    bucket.entries.push({ entry, index: i })
-  }
-
-  const threads = [...threadsById.values()].sort(
-    (a, b) => (a.entries[a.entries.length - 1].entry.at || 0) - (b.entries[b.entries.length - 1].entry.at || 0)
-  )
-  const newestThread = threads.length ? threads[threads.length - 1].id : null
-  const logChildren = []
-
-  threads.forEach(threadBucket => {
-    const { entries, id } = threadBucket
-    const head = entries.find(({ entry }) => entry.from.kind === 'user')?.entry || entries[0].entry
-    const isNewest = id === newestThread
-    const expanded = openThreads[id] ?? isNewest
-
-    if (!expanded) {
-      const replies = entries.length - 1
-      const headText = stripPreviewMarkdown(head?.text || '').slice(0, 80)
-
-      logChildren.push(
-        jsxs('button', {
-          type: 'button',
-          className:
-            'flex w-full items-center gap-2 rounded-md border border-(--ui-stroke-secondary) px-2 py-1.5 text-left text-xs text-(--ui-text-tertiary) transition-colors hover:bg-(--chrome-action-hover)',
-          title: 'Open this thread',
-          onClick: () => setOpenThreads(prev => ({ ...prev, [id]: true })),
-          children: [
-            jsx(Codicon, { name: 'chevron-right', className: 'shrink-0 text-[0.65rem]' }),
-            jsx('span', { className: 'min-w-0 flex-1 truncate', children: headText || 'Thread' }),
-            jsx('span', {
-              className: 'shrink-0 text-[0.625rem] text-(--ui-text-quaternary)',
-              children: `${replies} ${replies === 1 ? 'reply' : 'replies'} · ${relativeTime(entries[entries.length - 1].entry.at)}`
-            })
-          ]
-        }, `fold:${id}`)
-      )
-
-      return
-    }
-
-    // Open thread: a rail-indented block — collapse affordance, its entries,
-    // and its own reply box (Slack's "reply in thread").
-    const threadRows = []
-
-    if (!isNewest || openThreads[id] !== undefined) {
-      threadRows.push(
-        jsxs('button', {
-          type: 'button',
-          className:
-            'flex w-full items-center gap-1.5 px-2 pt-1 text-left text-[0.65rem] text-(--ui-text-quaternary) transition-colors hover:text-foreground',
-          title: 'Collapse this thread',
-          onClick: () => setOpenThreads(prev => ({ ...prev, [id]: false })),
-          children: [jsx(Codicon, { name: 'chevron-down', className: 'text-[0.6rem]' }), 'Collapse thread']
-        }, `unfold:${id}`)
-      )
-    }
-
-    for (const { entry, index } of entries) {
-      threadRows.push(renderEntry(entry, index))
-    }
-
-    // Reply-in-thread: the newest thread's continuation ALSO lives here, so
-    // the main composer below can stay "new thread" without ambiguity.
-    threadRows.push(
-      replyThread === id
-        ? jsxs('form', {
-            className: 'grid gap-0 px-2 pb-1',
-            onSubmit: event => {
-              event.preventDefault()
-              submitReply(id)
-            },
-            children: [
-              attachmentRow(id),
-              jsxs('div', {
-                className: 'flex items-center gap-1.5',
-                children: [
-                  jsx(GroupMentionInput, {
-                    'aria-label': 'Reply in thread',
-                    autoFocus: true,
-                    placeholder: 'Reply in thread…',
-                    members,
-                    value: replyDrafts[id] || '',
-                    onChange: text => setReplyDrafts(prev => ({ ...prev, [id]: text })),
-                    onSubmitDraft: () => submitReply(id),
-                    onPaste: event => pasteImages(id, event)
-                  }),
-                  attachButton(id),
-                  jsx(Button, {
-                    type: 'submit',
-                    size: 'sm',
-                    disabled: !(replyDrafts[id] || '').trim() && !imagesFor(id).length,
-                    children: 'Reply'
-                  })
-                ]
-              })
-            ]
-          }, `replybox:${id}`)
-        : jsx('button', {
-            type: 'button',
-            className:
-              'w-fit px-2 pb-1 text-left text-[0.65rem] text-(--ui-accent,#4f9cf9) transition-colors hover:underline',
-            onClick: () => setReplyThread(id),
-            children: 'Reply in thread'
-          }, `replylink:${id}`)
-    )
-
-    logChildren.push(
-      jsx('div', {
-        className: 'grid gap-1.5 border-l-2 border-(--ui-stroke-secondary) pl-1.5',
-        children: threadRows
-      }, `thread:${id}`)
-    )
-  })
-
-  return jsxs('div', {
-    className: 'relative flex h-full flex-col',
-    onDragOver: event => {
-      if ([...(event.dataTransfer?.types || [])].includes('Files')) {
-        event.preventDefault()
-        setDragOver(true)
-      }
-    },
-    onDragLeave: event => {
-      // Only clear when leaving the room container itself, not when the
-      // cursor moves between its children.
-      if (!event.currentTarget.contains(event.relatedTarget)) {
-        setDragOver(false)
-      }
-    },
-    onDrop: dropFiles,
-    children: [
-      dragOver
-        ? jsx('div', {
-            className:
-              'pointer-events-none absolute inset-0 z-40 flex items-center justify-center border-2 border-dashed border-(--ui-accent,#4f9cf9) text-sm font-medium text-(--ui-accent,#4f9cf9)',
-            children: replyThread ? 'Drop to attach to this thread reply' : 'Drop to attach — every responding bot sees it'
-          }, 'dropzone')
-        : null,
-      header,
-      activityPanel,
-      jsx(ScrollArea, {
-        className: 'min-h-0 flex-1',
-        children: jsxs('div', {
-          className: 'grid gap-1.5 px-2.5 pb-2',
-          children: [
-            ...(room.log.length
-              ? logChildren
-              : [
-                  jsx('div', {
-                    className: 'px-2 py-4 text-center text-xs text-(--ui-text-tertiary)',
-                    children: 'Say something — every bot in this group hears the room.'
-                  }, 'empty')
-                ]),
-            ...roomClarifies.map(entry =>
-              jsx(GroupClarifyCard, { entry, members }, `clarify:${entry.memberKey}:${entry.requestId}`)
-            ),
-            room.running
-              ? jsx('div', {
-                  className: 'px-2 py-1 text-[0.7rem] italic text-(--ui-text-quaternary)',
-                  children: roomClarifies.length
-                    ? 'Waiting for your answer…'
-                    : room.turn
-                      ? `${groupSpeakerLabel(room.turn)} is thinking…`
-                      : 'The room is working…'
-                }, 'working')
-              : null,
-            // Scroll anchor (#89835): rooms opened at scroll position 0, mid-
-            // history. The effect below scrolls this sentinel into view on
-            // mount and on log growth — unless the user has scrolled up.
-            jsx('div', { ref: bottomSentinelRef, 'aria-hidden': true }, 'bottom-sentinel')
-          ]
-        })
-      }),
-      jsx('div', {
-        className: 'border-t border-(--ui-stroke-secondary) p-2',
-        children: jsxs('form', {
-          className: 'grid gap-0',
-          onSubmit: event => {
-            event.preventDefault()
-            submit()
-          },
-          children: [
-            attachmentRow(null),
-            jsxs('div', {
-              className: 'flex items-center gap-1.5',
-              children: [
-                jsx(GroupMentionInput, {
-                  'aria-label': `Message ${group}`,
-                  placeholder: `New thread in ${group}… (@name to direct, @everyone for all)`,
-                  members,
-                  value: draft,
-                  onChange: setDraft,
-                  onSubmitDraft: submit,
-                  onPaste: event => pasteImages(null, event)
-                }),
-                attachButton(null),
-                jsx(Button, {
-                  type: 'submit',
-                  size: 'sm',
-                  disabled: !draft.trim() && !imagesFor(null).length,
-                  children: 'New Thread'
-                })
-              ]
-            })
-          ]
-        })
-      }),
-      jsx(GroupChatSettingsDialog, {
-        group,
-        members,
-        open: settingsOpen,
-        onClose: () => setSettingsOpen(false)
-      }),
-      jsx(ConfirmDialog, {
-        open: confirmDisband,
-        title: 'Disband group chat?',
-        description: jsxs('span', {
-          children: [
-            'This removes the ',
-            jsx('span', { className: 'font-medium text-foreground', children: group }),
-            ' grouping from its ',
-            String(members.length),
-            // New rooms title member sessions by roomId, legacy rooms by name —
-            // so the copy names the concept, not a literal session title.
-            ' bots and clears the shared room log. The bots themselves and their per-group sessions are kept.'
-          ]
-        }),
-        destructive: true,
-        confirmLabel: 'Disband',
-        busyLabel: 'Disbanding…',
-        doneLabel: 'Disbanded',
-        onClose: () => setConfirmDisband(false),
-        onConfirm: async () => {
-          clearGroupComposerDraft(composerKeyRef.current)
-          await disbandGroupChat(group, members)
-          host.notify({ kind: 'success', message: `Disbanded “${group}”` })
-        }
-      })
-    ]
-  })
-}
-
-/** Live closers for group-chat MAIN-window tabs, by group name — so a
- *  disband (or the room view's own Back) can retire the tab it opened. */
-const groupChatMainTabs = new Map()
-
-/** Reactive shadow of `groupChatMainTabs` membership. The Map itself can't
- *  notify React, and #89788's first fix read it non-reactively: a BotsPane
- *  render that landed between selecting the group and recording its main
- *  tab kept the in-pane room on screen forever (the map write repaints
- *  nothing). Every map mutation goes through the two helpers below so the
- *  rev bump re-evaluates the gate. */
-const $groupMainTabsRev = atom(0)
-
-function recordGroupMainTab(group, close) {
-  groupChatMainTabs.set(group, close)
-  $groupMainTabsRev.set($groupMainTabsRev.get() + 1)
-}
-
-function dropGroupMainTab(group) {
-  if (groupChatMainTabs.delete(group)) {
-    $groupMainTabsRev.set($groupMainTabsRev.get() + 1)
-  }
-}
-
-/** The in-panel room is the FALLBACK surface, not a second copy: it renders
- *  only while no main-window tab owns the group. On desktops with the door
- *  the room already lives in a main tab, and painting it here too produced
- *  two live panes with independent drafts driving one shared engine (#89788).
- *  The selection atom stays set either way so the roster row still
- *  highlights. Callers must subscribe to `$groupMainTabsRev` (BotsPane does)
- *  so ownership changes re-run this gate. */
-function shouldRenderGroupChatInPane(group) {
-  return Boolean(group && !groupChatMainTabs.has(group))
-}
-
-function closeGroupChatMainTab(group) {
-  const close = groupChatMainTabs.get(group)
-
-  dropGroupMainTab(group)
-
-  if ($groupChatWorkspace.get() === group) {
-    $groupChatWorkspace.set(null)
-  }
-
-  if (typeof close === 'function') {
-    try {
-      close()
-    } catch {
-      /* tab already gone */
-    }
-  }
-}
-
-function selectedRosterBot(roster, key) {
-  return (Array.isArray(roster) ? roster : []).find(bot => botRosterKey(bot) === key) || null
-}
-
-/** A selected owner whose roster row is absent because its SOURCE is down —
- *  not because the bot is gone. Identity comes from the key itself, so the
- *  selection survives a relaunch with that gateway offline and reconciles
- *  onto the live row (same key) when it returns, without duplicating it.
- *
- *  Returns null when the selection is provably invalid instead: a reachable
- *  source that no longer lists the bot, or a source that left the registry
- *  while other sources are live. Unknown (no sources yet) is NOT proof. */
-function ghostRosterOwner(key, sources) {
-  const { connectionId, name } = parseRosterKey(key)
-
-  if (!name) {
-    return null
-  }
-
-  const list = Array.isArray(sources) ? sources : []
-  const source = sourceByConnection(list).get(connectionId)
-
-  if (source ? source.reachable === true : list.length > 0) {
-    return null
-  }
-
-  return {
-    name,
-    connectionId,
-    ghost: true,
-    remoteSource: connectionId !== 'local',
-    connectionKind: source?.kind,
-    connectionLabel: source?.label,
-    sourceError: source?.error || null,
-    sourceMissing: false,
-    sourceReachable: false
-  }
-}
-
-/** Keep the exact selected owner visible through a cold-start outage without
- *  persisting the whole remote roster. The source registry supplies the
- *  gateway identity/status; the source-qualified selection supplies the bot
- *  identity. Once that source answers again, the live row replaces the ghost
- *  (or reconciliation clears it when the bot was actually removed). */
-function rosterWithSelectedOwner(roster, sources, key) {
-  const rows = Array.isArray(roster) ? roster : []
-
-  if (!key || selectedRosterBot(rows, key)) {
-    return rows
-  }
-
-  const ghost = ghostRosterOwner(key, sources)
-
-  return ghost ? [...rows, ghost] : rows
-}
-
-/** Keep the persisted selection honest against the live roster and seat a
- *  first selection when there is none. PRESENTATION ONLY: it never opens,
- *  prepares, activates, or creates anything — an unreachable owner keeps its
- *  selection rather than falling back onto some other gateway's bot. */
-function reconcileRosterSelection(roster, sources, metaByName) {
-  if (!$rosterHydrated.get() || !$selectedRosterHydrated.get()) {
-    return
-  }
-
-  const key = $selectedRosterKey.get()
-
-  if (key) {
-    if (selectedRosterBot(roster, key) || ghostRosterOwner(key, sources)) {
-      return
-    }
-
-    clearSelectedRosterKey(key)
-  }
-
-  const first = (Array.isArray(roster) ? roster : []).find(
-    bot => !isBotHidden(bot, metaByName) && botSourceStatus(annotateBotSource(bot, sources)).available
-  )
-
-  if (first) {
-    saveSelectedRosterBot(first)
-  }
-}
-
-function BotsHomeView() {
-  const roster = useValue($lastRoster)
-  const sources = useValue($lastSources)
-  const selectedKey = useValue($selectedRosterKey)
-  const rosterHydrated = useValue($rosterHydrated)
-  const selectionHydrated = useValue($selectedRosterHydrated)
-  const allMeta = useValue($botMeta)
-  const live = selectedRosterBot(roster, selectedKey)
-
-  if (!rosterHydrated || !selectionHydrated) {
-    return jsx('div', {
-      className: 'flex h-full items-center justify-center',
-      'aria-label': 'Loading bots',
-      children: jsx(GlyphSpinner, { spinner: 'breathe', className: 'text-(--ui-text-tertiary)' })
-    })
-  }
-
-  const ghost = live ? null : ghostRosterOwner(selectedKey, sources)
-  const bot = live ? annotateBotSource(live, sources) : ghost
-
-  if (!bot) {
-    return jsx('div', {
-      className: 'flex h-full items-center justify-center px-6',
-      children: jsx(EmptyState, {
-        icon: roster.length ? 'hubot' : 'add',
-        title: roster.length ? 'Choose a bot or group chat' : 'No bots yet',
-        description: roster.length ? 'Pick one from the Bots sidebar.' : 'Create your first bot from the Bots sidebar.'
-      })
-    })
-  }
-
-  const meta = botRosterMeta(bot, allMeta)
-  const status = botSourceStatus(bot)
-  // A ghost is reconstructed from a persisted owner key while its gateway is
-  // offline. That proves the profile name, not its public mention handle.
-  const handle = bot.ghost ? '' : botHandle(bot.name, bot)
-  const gateway = bot.connectionLabel || (bot.connectionId === 'local' ? 'This device' : 'Hermes gateway')
-  const gatewayKind = bot.connectionKind || (bot.connectionId === 'local' ? 'local' : 'remote')
-  const { shape, color, image } = botAppearance(bot.name, meta)
-  const photo = image && !isBackfilledFacePng(image) ? image : null
-  const description = String(meta?.description || bot.description || '').trim()
-  const unavailable = !status.available
-  const sourceRemoved = status.key === 'missing'
-  // Retry re-polls the roster on the bot's OWN source. It never activates or
-  // re-routes anything: if the gateway is back, its row reappears under the
-  // same key and this view reconciles onto it.
-  const retrySource = () => {
-    haptic('tap')
-    queryClient.invalidateQueries({ queryKey: ROSTER_KEY })
-  }
-
-  return jsxs('div', {
-    className: 'flex h-full min-h-0 flex-col bg-background',
-    children: [
-      jsxs('header', {
-        className:
-          'flex min-w-0 items-center gap-3 border-b border-(--ui-stroke-tertiary) px-5 py-3.5',
-        children: [
-          jsx(BotFace, { shape, color, image: photo, size: 38, name: bot.name, mood: 'idle' }),
-          jsxs('div', {
-            className: 'min-w-0 flex-1',
-            children: [
-              jsx('h1', {
-                className: 'truncate text-sm font-semibold text-foreground',
-                children: displayName(bot, meta)
-              }),
-              jsxs('div', {
-                className: 'flex min-w-0 items-center gap-1.5 text-xs text-(--ui-text-tertiary)',
-                children: [
-                  jsx('span', { children: 'Bot' }),
-                  handle
-                    ? jsx('span', { className: 'truncate font-mono', children: `· @${handle}` })
-                    : null
-                ]
-              })
-            ]
-          }),
-          // Tip wraps ONE element (Radix asChild) — the screen-reader text
-          // rides inside the trigger, not beside it.
-          jsx(Tip, {
-            label: `${gateway} · ${gatewayKind} · ${status.label}`,
-            children: jsxs('div', {
-              className: 'flex max-w-[45%] items-center gap-1.5 text-xs text-(--ui-text-tertiary)',
-              children: [
-                jsx('span', { className: 'sr-only', children: `${gateway}, ${status.label}` }),
-                jsx(GatewayKindGlyph, { kind: gatewayKind }),
-                jsx('span', { className: 'min-w-0 truncate', children: gateway }),
-                unavailable
-                  ? jsx(Codicon, {
-                      name: 'debug-disconnect',
-                      className: 'shrink-0 text-amber-600 dark:text-amber-300',
-                      'aria-hidden': true
-                    })
-                  : null
-              ]
-            })
-          })
-        ]
-      }),
-      jsx('main', {
-        className: 'flex min-h-0 flex-1 items-center justify-center overflow-y-auto px-6 py-10',
-        children: jsxs('div', {
-          className: 'flex w-full max-w-2xl flex-col items-center text-center',
-          children: [
-            jsx(BotFace, { shape, color, image: photo, size: 76, name: bot.name, mood: 'idle' }),
-            jsx('h2', {
-              className: 'mt-5 text-xl font-semibold text-foreground',
-              children: displayName(bot, meta)
-            }),
-            description
-              ? jsx('p', {
-                  className: 'mt-2 max-w-xl text-sm leading-6 text-(--ui-text-tertiary)',
-                  children: description
-                })
-              : null,
-            jsx('p', {
-              className: cn(
-                'mt-4 max-w-lg text-xs leading-5',
-                unavailable ? 'text-amber-700 dark:text-amber-300' : 'text-(--ui-text-tertiary)'
-              ),
-              children: unavailable
-                ? sourceRemoved
-                  ? `${gateway} was removed. Choose another bot from the sidebar.`
-                  : `${gateway} is unavailable. Retry when it is back online.`
-                : 'Open this bot’s continuous chat. Its background work keeps running when you switch away.'
-            }),
-            unavailable && !sourceRemoved
-              ? jsx(Button, {
-                  variant: 'secondary',
-                  size: 'sm',
-                  className: 'mt-5',
-                  onClick: retrySource,
-                  children: 'Retry'
-                })
-              : jsx(Button, {
-                  variant: 'secondary',
-                  size: 'sm',
-                  className: 'mt-5',
-                  // The home's button names the continuous chat itself — an
-                  // explicit ask, unlike a row click that returns to open tabs.
-                  onClick: () => void openRosterBot(bot, { canonical: true }),
-                  children: 'Open chat'
-                })
-          ]
-        })
-      })
-    ]
-  })
-}
-
-function closeBotsHomeWorkspace() {
-  if (typeof botsHomeClose !== 'function') {
-    return
-  }
-
-  const close = botsHomeClose
-  botsHomeClose = null
-  suppressBotsHomeReopen = true
-  // Retiring the tab ends the current attempt's budget: the next open is a
-  // new surface, and it gets its own re-front chance. The re-front path sets
-  // the latch again AFTER calling us, so this cannot erase its own attempt.
-  botsHomeRefrontTried = false
-
-  try {
-    close()
-  } catch {
-    /* workspace already closed */
-  } finally {
-    suppressBotsHomeReopen = false
-  }
-}
-
-/** The Bot home needs BOTH the main-area door and pane visibility to behave.
- *  Older shells keep their previous surfaces untouched (no home at all). */
-function botsHomeEnabled() {
-  return typeof host.openWorkspace === 'function' && typeof host.paneVisibility === 'function'
-}
-
-/** True when a session owns the main workspace. Prefers the focused STORED
- *  session (tab focus moves without swapping the gateway socket); bare test
- *  harnesses with neither atom drive $botChatFocused directly. */
-function sessionOwnsWorkspace() {
-  const focused = host.state?.focusedStoredSessionId?.get?.()
-
-  if (focused !== undefined) {
-    return Boolean(focused)
-  }
-
-  const active = host.state?.activeSessionId?.get?.()
-
-  return active === undefined ? $botChatFocused.get() : Boolean(active)
-}
-
-/** The home tab currently holds the center's active tab slot. */
-function botsHomeVisible() {
-  if (typeof host.paneVisibility !== 'function') {
-    return false
-  }
-
-  try {
-    return host.paneVisibility(BOTS_HOME_PANE_ID).get() === true
-  } catch {
-    return false
-  }
-}
-
-/** A real bot chat owns the center. Cronjobs are BOT-scoped, so this — not
- *  mere Bot Mode visibility — is what may seat the Cronjobs tile: beside the
- *  ownerless home or a group chat it would describe whichever profile the
- *  socket happens to be homed on. While the home tab is fronted the chat is
- *  a hidden sibling layer, so the focused session does NOT count. */
-function botChatOwnsWorkspace() {
-  return (
-    $botsPaneVisible.get() &&
-    !$groupChatWorkspace.get() &&
-    !botsHomeVisible() &&
-    Boolean($openBotChat.get() || sessionOwnsWorkspace())
-  )
-}
-
-/** May the home OPEN right now? `explicit` is a user gesture aimed at the
- *  home itself (selecting a remote/unavailable owner): it overrides the
- *  focused-session veto — the veto exists so PASSIVE events (boot, restore,
- *  polls) never cover a chat the user left in the center. */
-function botsHomeMayOpen(explicit) {
-  return (
-    $botsPaneVisible.get() &&
-    !$groupChatWorkspace.get() &&
-    !$openBotChat.get() &&
-    !botOpenInFlight &&
-    (explicit || !sessionOwnsWorkspace())
-  )
-}
-
-function openBotsHomeWorkspace(explicit = false) {
-  if (!botsHomeEnabled() || !botsHomeMayOpen(explicit)) {
-    return false
-  }
-
-  const selected = selectedRosterBot($lastRoster.get(), $selectedRosterKey.get())
-  const ownerKey = selected ? botWorkspaceOwnerKey(selected) : BOTS_HOME_OWNER_KEY
-  setBotsWorkspaceOwner(ownerKey, selected)
-  // Already open and fronted: nothing to do. Already open but backgrounded
-  // (a persisted layout can restore the tab behind the draft): re-open to
-  // re-front it. Never stack a second registration — a stale disposer would
-  // tear down the newer one. This cannot yank the center from a tab the
-  // user just chose: plugin events are sparse (sidebar/group/focus edges),
-  // and each of those either legitimately claims the center or cleared it.
-  if (botsHomeClose) {
-    if (botsHomeVisible()) {
-      botsHomeRefrontTried = false
-
-      return true
-    }
-
-    // A re-front is a close + re-open, so it REMOUNTS the whole Bots view.
-    // That is affordable once, against the backgrounded-tab case above. It is
-    // not affordable per signal: the shell does not always answer a reveal
-    // with the active slot (revealTreePane returns early for a pane in
-    // $hiddenTreePanes without activating it; a minimized zone and a pane the
-    // tree never adopted are never visible either). Pinned in one of those
-    // states the old code re-fronted on every passive pass — sidebar flips,
-    // focus churn and group changes all reach here — and the view strobed.
-    // One attempt proves whether this shell will front the tab; if it will
-    // not, keep the surface and wait for a signal that changes the answer.
-    if (botsHomeRefrontTried && !explicit) {
-      return true
-    }
-
-    closeBotsHomeWorkspace()
-    botsHomeRefrontTried = true
-  }
-
-  try {
-    botsHomeClose = host.openWorkspace(`${ID}:home`, {
-      title: 'Bots',
-      minWidth: '24rem',
-      render: () => jsx(BotsHomeView, {}),
-      // Closing the tab is a decision, not a glitch: drop the handle and
-      // leave the center alone. The home returns on the next real signal
-      // (Bots tab regains focus, a chat closes, a group is left).
-      onClose: () => {
-        if (!suppressBotsHomeReopen) {
-          botsHomeClose = null
-        }
-      }
-    })
-
-    // The reveal has already either granted the tab its zone's active slot or
-    // refused it, so settle the re-front budget on that answer directly rather
-    // than waiting for a visibility notification to schedule another pass. A
-    // computed store stays silent when the value does not change, so on the
-    // shells that refuse, no such pass is coming.
-    if (botsHomeVisible()) {
-      botsHomeRefrontTried = false
-    }
-
-    return typeof botsHomeClose === 'function'
-  } catch {
-    botsHomeClose = null
-    return false
-  }
-}
-
-/** Passive reconcile. Opens the home only into an ownerless center; closes
- *  it only when a surface with a REAL owner claims the center (bot chat,
- *  group chat) or Bot Mode leaves the screen. The focused-session LEVEL
- *  deliberately does not close an open home — the home may sit over a
- *  focused-but-hidden chat after an explicit selection; the chat reclaims
- *  the center on its focus EDGE (handleWorkspaceFocusChange). */
-function syncBotsHomeWorkspace() {
-  if (!$botsPaneVisible.get() || $groupChatWorkspace.get() || $openBotChat.get()) {
-    closeBotsHomeWorkspace()
-    return
-  }
-
-  openBotsHomeWorkspace(false)
-}
-
-/** An opened bot chat stops owning the center once focus leaves it (closed,
- *  or another session took over). Without this the home could never come
- *  back: $openBotChat would claim ownership for a chat nobody is reading.
- *
- *  The legacy newChat fallback has no registry id to compare — a draft with no
- *  focused session is still that bot's draft, so it only yields once some
- *  session actually takes focus. */
-function releaseStaleOpenBotChat(focusedStoredId) {
-  const open = $openBotChat.get()
-
-  if (!open) {
-    return
-  }
-
-  const focused = focusedStoredId === null || focusedStoredId === undefined ? '' : String(focusedStoredId)
-  // The focused stored id is the compression-lineage TIP; the claim carries
-  // both the durable registry id and the tip it actually opened. Either
-  // match keeps the claim — comparing only the registry id released it on
-  // the very focus edge the open itself caused (first-click home bounce).
-  const owned = [open.openedSessionId, open.openedRegistryId].filter(Boolean)
-  const stale = owned.length ? !owned.includes(focused) : Boolean(focused)
-
-  if (stale) {
-    $openBotChat.set(null)
-  }
-}
-
-/** Bot-open handoff: capture the selected group and retire its registered
- * main tab (or clear the in-panel selection) before async source prep /
- * canonical open. */
-function dismissGroupChatForLocalBotOpen() {
-  const group = $groupChatWorkspace.get()
-
-  if (!group) {
-    return null
-  }
-
-  const roomId = String($groupChats.get()[group]?.roomId || '')
-  closeGroupChatMainTab(group)
-  return { group, roomId }
-}
-
-/** Main-window wrapper: seats the member roster reactively (live roster +
- *  bot meta + the room's stored cross-connection descriptors) so the room
- *  keeps working as members change while the tab is open. Also subscribes to
- *  this pane's visibility (feature-detected host.paneVisibility): retained
- *  panes stay mounted while hidden, so the workspace needs the hidden →
- *  visible edge to re-anchor its log to the bottom (#89835 follow-up). */
-function GroupChatMainView({ group }) {
-  const allMeta = useValue($botMeta)
-  // Subscribe: membership changes ride bot meta AND the room record.
-  useValue($groupChats)
-  const roster = useValue($lastRoster)
-  const members = groupChatMemberBots(group, roster, allMeta)
-  // Older SDKs have no paneVisibility: fall back to an always-visible atom so
-  // the hook order stays stable and behavior matches the previous build.
-  const $visible = useMemo(
-    () => (typeof host.paneVisibility === 'function' ? host.paneVisibility(`plugin-workspace:${ID}:group:${slugify(group)}`) : atom(true)),
-    [group]
-  )
-  const visible = useValue($visible)
-
-  return jsx(GroupChatWorkspace, { group, members, visible, onBack: () => closeGroupChatMainTab(group) })
-}
-
-/** Open a group chat the Discord way: a tab taking over the MAIN chat window
- *  (host.openWorkspace, newer desktops), falling back to the in-panel room
- *  view on desktops whose SDK predates the main-area door.
- *
- *  Ordering matters (#89788 follow-up): the main tab must be RECORDED before
- *  the selection atom is set. Setting the atom first opened a window where
- *  BotsPane rendered with a selected group and an empty tab map — the
- *  in-pane fallback painted alongside the main tab, and because the map
- *  write itself repaints nothing, the duplicate stuck until an unrelated
- *  re-render. */
-function openGroupChat(group) {
-  // A room selection supersedes any bot-open transition still hydrating.
-  // The in-flight host navigation may complete underneath this workspace,
-  // but it may not later close or visually steal the room the user chose.
-  cancelBotOpen()
-  $groupNeedsYou.set({ ...$groupNeedsYou.get(), [group]: false })
-  const ownerKey = groupWorkspaceOwnerKey(group)
-  setBotsWorkspaceOwner(ownerKey, null, 'New group conversations start in the group composer.')
-
-  if (typeof host.openWorkspace === 'function') {
-    try {
-      const close = host.openWorkspace(`${ID}:group:${slugify(group)}`, {
-        title: group,
-        minWidth: '24rem',
-        render: () => jsx(GroupChatMainView, { group }),
-        onClose: () => {
-          dropGroupMainTab(group)
-
-          if ($groupChatWorkspace.get() === group) {
-            $groupChatWorkspace.set(null)
-          }
-        }
-      })
-
-      recordGroupMainTab(group, close)
-      // Tab ownership is on record — the atom now only drives the roster
-      // highlight; shouldRenderGroupChatInPane stays false throughout.
-      $groupChatWorkspace.set(group)
-
-      return
-    } catch {
-      // Fall through to the in-panel room below.
-    }
-  }
-
-  // No main-window door (older desktop) or it threw: select the group so
-  // the in-panel room renders as the fallback surface.
-  $groupChatWorkspace.set(group)
-}
-
-/** One group chat as one quiet roster row. The room owns one visual identity;
- *  member details stay in its tooltip and workspace instead of competing
- *  with bot avatars in the narrow sidebar. */
-function GroupRow({ active, group, members, needsYou, onOpen, onDisband }) {
-  const rooms = useValue($groupChats)
-  const room = rooms[group] || { log: [] }
-  const log = Array.isArray(room.log) ? room.log : []
-  const last = log.length ? log[log.length - 1] : null
-  const lastAt = groupLastActivity(room)
-  // Room previews speak the same handle vocabulary as the roster, mentions
-  // and the group prompt: the primary profile is @hermes, not @default.
-  const lastFrom = last?.from?.name || ''
-  const lastHandle = botHandle(lastFrom || 'bot', members.find(member => member?.name === lastFrom))
-  const preview = last
-    ? `${last.from?.kind === 'user' ? 'You' : `@${lastHandle}`}: ${stripPreviewMarkdown(last.text) || '…'}`
-    : `${members.length} bots`
-  const availableMembers = members.filter(member => botSourceStatus(member).available).length
-  const availabilityLabel = `${availableMembers} of ${members.length} available`
-
-  const row = jsxs('button', {
-    type: 'button',
-    onClick: () => {
-      haptic('tap')
-      onOpen(group)
-    },
-    className: cn(
-      'flex w-full min-w-0 max-w-full items-center gap-2.5 overflow-hidden rounded-md px-2 py-2 text-left transition-colors',
-      'hover:bg-(--chrome-action-hover)',
-      active && 'bg-(--ui-row-active-background)'
-    ),
-    'aria-label': `${group}, ${members.length} bots, ${availabilityLabel}`,
-    children: [
-      jsxs('div', {
-        className: 'relative flex w-[34px] shrink-0 items-center justify-center',
-        children: [
-          room.image
-            ? jsx('img', {
-                src: room.image,
-                alt: '',
-                className: cn(
-                  'size-8 rounded-md object-cover ring-1 ring-(--ui-stroke-tertiary)',
-                  availableMembers === 0 && 'grayscale opacity-60'
-                )
-              })
-            : jsx('span', {
-                className: cn(
-                  'flex size-8 items-center justify-center rounded-md bg-(--chrome-action-hover) text-(--ui-text-tertiary)',
-                  availableMembers === 0 && 'opacity-60'
-                ),
-                children: jsx(Codicon, { name: 'organization' })
-              }),
-          members.length > 0 && availableMembers < members.length
-            ? jsx(Tip, {
-                label: availabilityLabel,
-                children: jsx('span', {
-                  className:
-                    'absolute -bottom-0.5 -right-0.5 flex size-4 items-center justify-center rounded-full bg-(--ui-bg-primary) text-[0.625rem] text-amber-600 ring-1 ring-(--ui-stroke-tertiary) dark:text-amber-300',
-                  'aria-label': availabilityLabel,
-                  children: jsx(Codicon, { name: 'debug-disconnect' })
-                })
-              })
-            : null
-        ]
-      }),
-      jsxs('div', {
-        className: 'min-w-0 flex-1',
-        children: [
-          jsxs('div', {
-            className: 'flex items-baseline justify-between gap-2',
-            children: [
-              jsx('span', {
-                className: 'min-w-0 flex-1 truncate text-[0.8125rem] font-medium',
-                children: group
-              }),
-              needsYou
-                ? jsx(Tip, {
-                    label: 'A bot in this group chat needs your input',
-                    children: jsx(Codicon, {
-                      name: 'question',
-                      className: 'shrink-0 text-(--ui-accent)',
-                      'aria-label': 'Needs your input'
-                    })
-                  })
-                : null,
-              lastAt
-                ? jsx('span', {
-                    className: 'shrink-0 text-[0.6875rem] text-(--ui-text-quaternary)',
-                    children: relativeTime(lastAt)
-                  })
-                : null
-            ]
-          }),
-          jsx('div', {
-            className: 'min-w-0 truncate text-xs text-(--ui-text-tertiary)',
-            children: preview
-          })
-        ]
-      })
-    ]
-  })
-
-  return jsxs(ContextMenu, {
-    children: [
-      jsx(ContextMenuTrigger, { asChild: true, children: row }),
-      jsxs(ContextMenuContent, {
-        children: [
-          jsx(ContextMenuItem, {
-            onSelect: () => onOpen(group),
-            children: 'Open Group Chat'
-          }),
-          jsx(ContextMenuSeparator, {}),
-          jsx(ContextMenuItem, {
-            className: 'text-destructive focus:text-destructive',
-            onSelect: () => onDisband({ name: group, members }),
-            children: 'Delete Group'
-          })
-        ]
-      })
-    ]
-  })
-}
-
-/** Foldable roster heading. It organizes rows visually but never supplies or
- * reconstructs ownership; every action still receives the full bot row. */
-function RosterSectionHeader({ collapsed, count, gatewayKind, icon, label, onToggle, status, tip }) {
-  const button = jsxs('button', {
-    type: 'button',
-    'aria-expanded': !collapsed,
-    className:
-      'mt-1 flex w-full min-w-0 items-center gap-1.5 rounded-md px-2 py-1.5 text-left text-[0.6875rem] font-semibold uppercase tracking-wider text-(--ui-text-quaternary) transition-colors hover:bg-(--chrome-action-hover) hover:text-(--ui-text-secondary)',
-    onClick: onToggle,
-    children: [
-      jsx(Codicon, { name: collapsed ? 'chevron-right' : 'chevron-down', className: 'shrink-0' }),
-      gatewayKind
-        ? jsx(GatewayKindGlyph, { kind: gatewayKind })
-        : jsx(Codicon, { name: icon, className: 'shrink-0' }),
-      jsxs('span', {
-        className: 'flex min-w-0 items-center gap-1',
-        children: [
-          jsx('span', { className: 'min-w-0 truncate', children: label }),
-          status && !status.available
-            ? jsx('span', { className: 'sr-only', children: status.label })
-            : null
-        ]
-      }),
-      jsx('span', { className: 'min-w-0 flex-1', 'aria-hidden': true }),
-      jsx('span', {
-        className: 'shrink-0 font-normal tabular-nums text-(--ui-text-quaternary)',
-        children: count
-      }),
-      status && !status.available
-        ? jsx(Codicon, {
-            name: 'debug-disconnect',
-            className: 'shrink-0 text-amber-600 dark:text-amber-300',
-            'aria-hidden': true
-          })
-        : null
-    ]
-  })
-
-  return tip ? jsx(Tip, { label: tip, children: button }) : button
-}
-
-function GatewaySectionHeading({ collapsed, count, onToggle, option }) {
-  const status = botSourceStatus({ sourceError: option?.error, sourceReachable: option?.reachable })
-  const label = option?.label || option?.connectionId || 'Current gateway'
-  const kind = option?.kind || 'remote'
-
-  return jsx(RosterSectionHeader, {
-    collapsed,
-    count,
-    gatewayKind: kind,
-    label,
-    onToggle,
-    status,
-    tip: `${label} · ${kind} · ${status.label}`
-  })
-}
-
-function BotsPane() {
-  const { data, error, isLoading, refetch } = useRoster()
-  const gatewayState = useValue(host.state.gateway)
-  const gatewayUp = gatewayState === 'open'
-  const activeProfile = (useValue(host.state.profile) || 'default').trim() || 'default'
-  const [createOpen, setCreateOpen] = useState(false)
-  const [groupCreateOpen, setGroupCreateOpen] = useState(false)
-  const [editing, setEditing] = useState(null)
-  const [deleting, setDeleting] = useState(null)
-  const [deletingGroup, setDeletingGroup] = useState(null)
-  const [grouping, setGrouping] = useState(null)
-  const [query, setQuery] = useState('')
-  const [rowKindFilter, setRowKindFilter] = useState('all')
-  const [activityFilter, setActivityFilter] = useState('all')
-  const [gatewayFilter, setGatewayFilter] = useState('all')
-  const [collapsedRosterSections, setCollapsedRosterSections] = useState(() => new Set())
-  const hiddenSectionRef = useRef(null)
-  const activityToasts = useValue($activityToasts)
-  const groupChatName = useValue($groupChatWorkspace)
-  // Main-tab ownership is a module Map; this rev subscription makes the
-  // shouldRenderGroupChatInPane gate below reactive to tab open/close
-  // (#89788 follow-up — without it a stale render could paint the in-pane
-  // room beside a live main tab and stick).
-  useValue($groupMainTabsRev)
-  const groupNeedsYou = useValue($groupNeedsYou)
-  const groupRooms = useValue($groupChats)
-  const rememberedSources = useValue($lastSources)
-  const rosterHydrated = useValue($rosterHydrated)
-  const selectionHydrated = useValue($selectedRosterHydrated)
-  const selectedRosterKey = useValue($selectedRosterKey)
-
-  // The socket opening (boot, SSH reconnect, sleep/wake) is the signal to
-  // retry immediately instead of waiting out the poll interval.
-  useEffect(() => {
-    if (gatewayUp) {
-      void refetch()
-    }
-  }, [gatewayUp, refetch])
-  const allMeta = useValue($botMeta)
-  // Messaging-app order: most recent activity first, where "activity" is
-  // the newest of (bot created, last message in any of its sessions). A
-  // freshly created bot tops the list until another bot gets a message.
-  // No special slot for the primary bot — it competes on recency too.
-  const activityOf = bot => {
-    const created = botRosterMeta(bot, allMeta)?.created || bot.ui_meta?.['hermes-bots']?.created || 0
-    const lastMsg = (botActivitySession(bot)?.last_active || 0) * 1000
-
-    return Math.max(created, lastMsg)
-  }
-  // Pin is a source-qualified Desktop preference, not gateway profile state.
-  const isPinned = bot => isBotPinned(bot, allMeta)
-  // Resilience (@wesleysimplicio, #13): a failed refresh must not erase a
-  // roster the user already had — mixed local+cloud gateways and remotes
-  // waking from sleep fail transiently. Render the last good snapshot with
-  // a notice; the full error card is reserved for "never had a roster".
-  const live = Array.isArray(data?.profiles) ? data.profiles : null
-  const source = live ?? (error ? $lastRoster.get() : [])
-  const sourceSnapshot = Array.isArray(data?.sources) ? data.sources : rememberedSources
-  const sourceWithSelectedOwner = selectionHydrated && rosterHydrated
-    ? rosterWithSelectedOwner(source, sourceSnapshot, selectedRosterKey)
-    : source
-  const roster = sourceWithSelectedOwner.slice().sort((a, b) => {
-    const pa = isPinned(a) ? 1 : 0
-    const pb = isPinned(b) ? 1 : 0
-
-    if (pa !== pb) {
-      return pb - pa
-    }
-
-    return activityOf(b) - activityOf(a)
-  })
-  // React Query can briefly report neither loading nor data while the plugin
-  // and the persisted connection registry hydrate. Keep that transition in a
-  // neutral loading state instead of flashing the first-run "No bots" copy.
-  const initialRosterLoading = !data && !error && roster.length === 0
-  const activeRosterKeys = new Set(activeBots(roster, activeProfile, gatewayState).map(botRosterKey))
-  const gatewayOptions = rosterGatewayOptions(sourceSnapshot, roster)
-  const selectedGateway = gatewayOptions.find(option => option.connectionId === gatewayFilter)
-  const gatewayFilterExists = gatewayFilter === 'all' || Boolean(selectedGateway)
-
-  useEffect(() => {
-    if (!gatewayFilterExists) {
-      setGatewayFilter('all')
-    }
-  }, [gatewayFilterExists])
-
-  const activeSourceRoster = roster.filter(bot => !bot.remoteSource)
-  // Hidden rows remain fully alive and recoverable at the bottom. Every
-  // non-display consumer continues to receive the complete roster.
-  const hiddenExpanded = useValue($showHiddenBots)
-  const hiddenBots = roster.filter(bot => isBotHidden(bot, allMeta))
-  const visibleRoster = roster.filter(bot => !isBotHidden(bot, allMeta))
-  const gatewayRoster = filterBotsByGateway(visibleRoster, gatewayFilter)
-  const filteredRoster = filterBots(gatewayRoster, allMeta, query).filter(bot =>
-    rosterActivityMatches(
-      { activity: activityOf(bot), active: activeRosterKeys.has(botRosterKey(bot)) },
-      activityFilter
-    )
-  )
-  const filteredHiddenBots = filterBots(filterBotsByGateway(hiddenBots, gatewayFilter), allMeta, query).filter(bot =>
-    rosterActivityMatches(
-      { activity: activityOf(bot), active: activeRosterKeys.has(botRosterKey(bot)) },
-      activityFilter
-    )
-  )
-  const groupNames = groupChatNames(allMeta, groupRooms)
-  const groupRows = groupNames
-    .map(name => ({ name, members: groupChatMemberBots(name, roster, allMeta) }))
-    .filter(row => groupMatchesRosterFilters(row.name, row.members, allMeta, query, gatewayFilter))
-    .map(row => ({
-      kind: 'group',
-      name: row.name,
-      members: row.members,
-      pinned: Boolean(groupRooms[row.name]?.pinned),
-      activity: groupLastActivity(groupRooms[row.name]),
-      active:
-        Boolean(
-          groupLastActivity(groupRooms[row.name]) &&
-          Date.now() - groupLastActivity(groupRooms[row.name]) <= ACTIVE_WINDOW_S * 1000
-        ) || row.members.some(member => activeRosterKeys.has(botRosterKey(member)))
-    }))
-    .filter(row => rowKindFilter !== 'bots' && rosterActivityMatches(row, activityFilter))
-  const botRows =
-    rowKindFilter === 'groups'
-      ? []
-      : preferReachableSameNameRows(filteredRoster).map(bot => ({
-          kind: 'bot',
-          bot,
-          pinned: isPinned(bot),
-          activity: activityOf(bot),
-          active: activeRosterKeys.has(botRosterKey(bot))
-        }))
-  const sortRosterRows = rows => rows.slice().sort((a, b) => {
-    const pa = a.pinned ? 1 : 0
-    const pb = b.pinned ? 1 : 0
-
-    if (pa !== pb) {
-      return pb - pa
-    }
-
-    return b.activity - a.activity
-  })
-  const rosterRows = sortRosterRows([...botRows, ...groupRows])
-  const sortedGroupRows = sortRosterRows(groupRows)
-  const gatewaySections = rosterGatewaySections(botRows, gatewayOptions, gatewayFilter)
-  const showGatewaySections = gatewaySections.sectioned && botRows.length > 0
-  const activeFilterCount =
-    (rowKindFilter === 'all' ? 0 : 1) +
-    (activityFilter === 'all' ? 0 : 1) +
-    (gatewayFilter === 'all' ? 0 : 1)
-  const hasRosterConstraint = Boolean(query.trim()) || activeFilterCount > 0
-  const matchingHiddenBots = rowKindFilter === 'groups' ? [] : filteredHiddenBots
-  const showHiddenSection = hiddenBots.length > 0 && (!hasRosterConstraint || matchingHiddenBots.length > 0)
-  const showHiddenRows = hiddenExpanded || hasRosterConstraint
-  const rosterItemCount = roster.length + groupNames.length
-  const allBotsHidden =
-    !hasRosterConstraint && visibleRoster.length === 0 && groupNames.length === 0 && hiddenBots.length > 0
-  const showRosterSearch =
-    gatewayOptions.length > 1 || rosterItemCount >= BOT_ROSTER_SEARCH_THRESHOLD || Boolean(query.trim())
-  const showRosterFilters =
-    gatewayOptions.length > 1 ||
-    groupNames.length > 0 ||
-    rosterItemCount >= BOT_ROSTER_SEARCH_THRESHOLD ||
-    activeFilterCount > 0
-  const showRosterTools = showRosterSearch || showRosterFilters
-  const rosterSectionCollapsed = id => !hasRosterConstraint && collapsedRosterSections.has(id)
-  const hiddenGatewaySections = rosterGatewaySections(
-    matchingHiddenBots.map(bot => ({ kind: 'bot', bot })),
-    gatewayOptions,
-    gatewayFilter
-  )
-
-  const toggleRosterSection = id => {
-    setCollapsedRosterSections(previous => {
-      const next = new Set(previous)
-
-      if (next.has(id)) {
-        next.delete(id)
-      } else {
-        next.add(id)
-      }
-
-      return next
-    })
-  }
-
-  useEffect(() => {
-    if (!hiddenExpanded || hasRosterConstraint) {
-      return
-    }
-
-    const frame = requestAnimationFrame(() => hiddenSectionRef.current?.scrollIntoView({ block: 'nearest' }))
-
-    return () => cancelAnimationFrame(frame)
-  }, [hiddenExpanded, hasRosterConstraint])
-
-  useEffect(() => {
-    if (!live) {
-      return
-    }
-
-    // Offline-owner ghosts belong only to this render. Shared roster state
-    // feeds merge caching, group membership, creation, and durable sync. These
-    // writes must settle after render: BotsHomeView subscribes to the same
-    // atoms, so publishing here used to update it while BotsPane was rendering.
-    $lastRoster.set(roster.filter(row => !row?.ghost))
-    if (Array.isArray(data?.sources)) {
-      $lastSources.set(data.sources)
-    }
-    mergeServerMeta(activeSourceRoster, data?.fetchedAt || 0)
-    pullServerAvatars(activeSourceRoster)
-    trackInboundActivity(roster)
-    backfillMessagingProtocol(activeSourceRoster)
-    // React Query owns the stable server snapshot; derived arrays intentionally
-    // follow that snapshot rather than retriggering on their own atom writes.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [data])
-
-  // The roster has ANSWERED once data or a terminal error exists — that, not
-  // row count, is what lets the home stop showing its loading state (an empty
-  // answer is a real answer; a pending one must not flash "No bots"). Keep the
-  // persisted-selection writes out of render: React may replay a render, but
-  // an abandoned render must never become a storage mutation.
-  useEffect(() => {
-    if (!data && !error) {
-      return
-    }
-
-    $rosterHydrated.set(true)
-
-    if (selectionHydrated) {
-      reconcileRosterSelection(roster, sourceSnapshot, allMeta)
-      const selected = selectedRosterBot(roster, $selectedRosterKey.get())
-
-      if ($botsPaneVisible.get() && !$groupChatWorkspace.get() && selected) {
-        setBotsWorkspaceOwner(botWorkspaceOwnerKey(selected), selected)
-      }
-    }
-  }, [data, error, selectionHydrated, roster, sourceSnapshot, allMeta])
-
-  const staleNotice = error && !live && roster.length
-    ? 'Roster refresh failed — showing the last good list.' + (gatewayUp ? '' : ' Waiting for the gateway to reconnect…')
-    : null
-  const groupChatMembers = groupChatName ? groupChatMemberBots(groupChatName, roster, allMeta) : []
-
-  if (shouldRenderGroupChatInPane(groupChatName) && groupChatMembers.length) {
-    return jsx(GroupChatWorkspace, { group: groupChatName, members: groupChatMembers })
-  }
-
-  const renderBotRow = (bot, keyPrefix = '') =>
-    jsx(
-      BotRow,
-      {
-        bot,
-        onDelete: setDeleting,
-        onEdit: setEditing,
-        onGroup: setGrouping,
-        showHandle: botNeedsHandleLabel(bot, roster, allMeta)
-      },
-      `${keyPrefix}${botRosterKey(bot)}`
-    )
-
-  const renderGroupRow = row =>
-    jsx(
-      GroupRow,
-      {
-        active: groupChatName === row.name,
-        group: row.name,
-        members: row.members,
-        needsYou: Boolean(groupNeedsYou[row.name]),
-        onOpen: openGroupChat,
-        onDisband: setDeletingGroup
-      },
-      `group:${row.name}`
-    )
-
-  const renderGatewaySection = section => {
-    const sectionId = `gateway:${section.id}`
-    const collapsed = rosterSectionCollapsed(sectionId)
-
-    return jsxs(
-      'div',
-      {
-        className: 'min-w-0',
-        children: [
-          jsx(GatewaySectionHeading, {
-            collapsed,
-            count: section.rows.length,
-            onToggle: () => toggleRosterSection(sectionId),
-            option: section.option
-          }),
-          collapsed
-            ? null
-            : jsx('div', {
-                className: 'grid min-w-0 gap-0.5',
-                children: section.rows.map(row => renderBotRow(row.bot, `${section.id}:`))
-              })
-        ]
-      },
-      sectionId
-    )
-  }
-
-  const renderGroupChatSection = () => {
-    const sectionId = 'group-chats'
-    const collapsed = rosterSectionCollapsed(sectionId)
-
-    return jsxs(
-      'div',
-      {
-        className: 'min-w-0',
-        children: [
-          jsx(RosterSectionHeader, {
-            collapsed,
-            count: sortedGroupRows.length,
-            icon: 'organization',
-            label: 'Group chats',
-            onToggle: () => toggleRosterSection(sectionId),
-            tip: `${sortedGroupRows.length} global group chat${sortedGroupRows.length === 1 ? '' : 's'}`
-          }),
-          collapsed
-            ? null
-            : jsx('div', {
-                className: 'grid min-w-0 gap-0.5',
-                children: sortedGroupRows.map(renderGroupRow)
-              })
-        ]
-      },
-      sectionId
-    )
-  }
-
-  const renderHiddenGatewaySection = section =>
-    jsxs(
-      'div',
-      {
-        className: 'min-w-0',
-        children: [
-          jsx('div', {
-            className:
-              'flex min-w-0 items-center gap-1.5 px-2 py-1 text-[0.625rem] font-semibold uppercase tracking-wider text-(--ui-text-quaternary)',
-            children: [
-              jsx(GatewayKindGlyph, { kind: section.option?.kind }),
-              jsx('span', {
-                className: 'min-w-0 flex-1 truncate',
-                children: section.option?.label || section.option?.connectionId || 'Current gateway'
-              }),
-              jsx('span', { className: 'shrink-0 font-normal tabular-nums', children: section.rows.length })
-            ]
-          }),
-          ...section.rows.map(row => renderBotRow(row.bot, `hidden:${section.id}:`))
-        ]
-      },
-      `hidden-gateway:${section.id}`
-    )
-
-  return jsxs('div', {
-    className: 'flex h-full flex-col',
-    children: [
-      jsxs('div', {
-        className: 'flex items-center justify-between gap-2 px-2.5 pt-2.5 pb-1.5',
-        children: [
-          jsx('span', {
-            className: 'text-[0.6875rem] font-semibold uppercase tracking-wider text-(--ui-text-quaternary)',
-            children: 'Bots'
-          }),
-          jsxs('div', {
-            className: 'flex items-center gap-0.5',
-            children: [
-              jsx(Tip, {
-                label: activityToasts ? 'Activity toasts on — click to silence' : 'Activity toasts off — click to enable',
-                children: jsx('button', {
-                  type: 'button',
-                  className:
-                    'flex size-6 items-center justify-center rounded-md text-(--ui-text-tertiary) transition-colors hover:bg-(--chrome-action-hover) hover:text-foreground',
-                  onClick: () => setActivityToasts(!activityToasts),
-                  children: jsx(Codicon, { name: activityToasts ? 'bell' : 'bell-slash' })
-                })
-              }),
-              jsxs(DropdownMenu, {
-                children: [
-                  jsx(Tip, {
-                    label: 'New…',
-                    children: jsx(DropdownMenuTrigger, {
-                      asChild: true,
-                      children: jsx('button', {
-                        type: 'button',
-                        'aria-label': 'New bot or group chat',
-                        className:
-                          'flex size-6 items-center justify-center rounded-md text-(--ui-text-tertiary) transition-colors hover:bg-(--chrome-action-hover) hover:text-foreground',
-                        children: jsx(Codicon, { name: 'add' })
-                      })
-                    })
-                  }),
-                  jsxs(DropdownMenuContent, {
-                    align: 'end',
-                    children: [
-                      jsxs(DropdownMenuItem, {
-                        onSelect: () => setCreateOpen(true),
-                        children: [jsx(Codicon, { name: 'hubot', className: 'mr-1.5' }), 'New Bot']
-                      }),
-                      jsxs(DropdownMenuItem, {
-                        disabled: activeSourceRoster.length < 2,
-                        onSelect: () => setGroupCreateOpen(true),
-                        children: [jsx(Codicon, { name: 'organization', className: 'mr-1.5' }), 'New Group Chat']
-                      })
-                    ]
-                  })
-                ]
-              })
-            ]
-          })
-        ]
-      }),
-      jsx(ActiveNowStrip, {
-        roster: visibleRoster,
-        activeProfile,
-        gatewayState,
-        metaByName: allMeta,
-        // Keep the Active Now strip and sidebar rows on the same exact-owner
-        // route: source activation first, then canonical name-registry open.
-        onOpen: bot => void openRosterBot(bot)
-      }),
-      showRosterTools
-        ? jsx('div', {
-            className: 'flex min-w-0 items-center gap-1 px-2.5 pb-1.5',
-            children: [
-              showRosterSearch
-                ? jsx(
-                    SearchField,
-                    {
-                      'aria-label': 'Search bots and group chats',
-                      containerClassName: cn(
-                        'min-w-0 flex-1',
-                        query ? 'opacity-100!' : 'opacity-50 focus-within:opacity-100'
-                      ),
-                      inputClassName:
-                        'w-full text-[0.75rem] placeholder:text-(--ui-text-tertiary)',
-                      placeholder: 'Search bots and group chats…',
-                      value: query,
-                      onChange: setQuery
-                    },
-                    'roster-search'
-                  )
-                : jsx('span', { className: 'min-w-0 flex-1' }, 'roster-search-spacer'),
-              showRosterFilters
-                ? jsxs(
-                    DropdownMenu,
-                    {
-                      children: [
-                      jsx(Tip, {
-                        label: activeFilterCount ? `Filters (${activeFilterCount} active)` : 'Filter roster',
-                        children: jsx(DropdownMenuTrigger, {
-                          asChild: true,
-                          children: jsx('button', {
-                            type: 'button',
-                            'aria-label': activeFilterCount ? `Filter roster, ${activeFilterCount} active` : 'Filter roster',
-                            className: cn(
-                              'flex size-7 shrink-0 items-center justify-center rounded-md text-(--ui-text-tertiary) transition-colors hover:bg-(--chrome-action-hover) hover:text-foreground',
-                              activeFilterCount && 'text-(--ui-accent)'
-                            ),
-                            children: jsx(Codicon, { name: 'list-filter' })
-                          })
-                        })
-                      }),
-                      jsxs(DropdownMenuContent, {
-                        align: 'end',
-                        children: [
-                          ...[
-                            ['all', 'Bots and group chats'],
-                            ['bots', 'Bots only'],
-                            ['groups', 'Group chats only']
-                          ].map(([value, label]) =>
-                            jsxs(
-                              DropdownMenuItem,
-                              {
-                                onSelect: () => setRowKindFilter(value),
-                                children: [
-                                  jsx('span', { className: 'min-w-0 flex-1', children: label }),
-                                  rowKindFilter === value ? jsx(Codicon, { name: 'check' }) : null
-                                ]
-                              },
-                              `kind:${value}`
-                            )
-                          ),
-                          jsx(DropdownMenuSeparator, {}),
-                          ...[
-                            ['all', 'Any activity'],
-                            ['active', 'Active now'],
-                            ['recent', 'Recently active'],
-                            ['older', 'Older']
-                          ].map(([value, label]) =>
-                            jsxs(
-                              DropdownMenuItem,
-                              {
-                                onSelect: () => setActivityFilter(value),
-                                children: [
-                                  jsx('span', { className: 'min-w-0 flex-1', children: label }),
-                                  activityFilter === value ? jsx(Codicon, { name: 'check' }) : null
-                                ]
-                              },
-                              `activity:${value}`
-                            )
-                          ),
-                          gatewayOptions.length > 1 ? jsx(DropdownMenuSeparator, {}) : null,
-                          gatewayOptions.length > 1
-                            ? jsxs(DropdownMenuItem, {
-                                onSelect: () => setGatewayFilter('all'),
-                                children: [
-                                  jsx(Codicon, { name: 'globe', className: 'mr-1.5' }),
-                                  jsx('span', { className: 'min-w-0 flex-1', children: 'All gateways' }),
-                                  gatewayFilter === 'all' ? jsx(Codicon, { name: 'check' }) : null
-                                ]
-                              })
-                            : null,
-                          ...(gatewayOptions.length > 1
-                            ? gatewayOptions.map(option => {
-                                const status = botSourceStatus({
-                                  sourceError: option.error,
-                                  sourceReachable: option.reachable
-                                })
-
-                                return jsxs(
-                                  DropdownMenuItem,
-                                  {
-                                    onSelect: () => setGatewayFilter(option.connectionId),
-                                    children: [
-                                      jsx(GatewayKindGlyph, {
-                                        kind: option.kind,
-                                        className: cn(
-                                          'mr-1.5',
-                                          !status.available && 'text-amber-600 dark:text-amber-300'
-                                        )
-                                      }),
-                                      jsx('span', {
-                                        className: 'min-w-0 flex-1 truncate',
-                                        children: option.label || option.connectionId
-                                      }),
-                                      jsx('span', {
-                                        className: 'text-[0.625rem] tabular-nums text-(--ui-text-quaternary)',
-                                        children: option.count
-                                      }),
-                                      gatewayFilter === option.connectionId ? jsx(Codicon, { name: 'check' }) : null
-                                    ]
-                                  },
-                                  option.connectionId
-                                )
-                              })
-                            : []),
-                          activeFilterCount ? jsx(DropdownMenuSeparator, {}) : null,
-                          activeFilterCount
-                            ? jsx(DropdownMenuItem, {
-                                onSelect: () => {
-                                  setRowKindFilter('all')
-                                  setActivityFilter('all')
-                                  setGatewayFilter('all')
-                                },
-                                children: 'Clear filters'
-                              })
-                            : null
-                        ]
-                      })
-                      ]
-                    },
-                    'roster-filters'
-                  )
-                : null
-            ]
-          })
-        : null,
-      staleNotice
-        ? jsx('div', {
-            className: 'mx-2.5 mb-1 rounded-md bg-(--chrome-action-hover) px-2 py-1.5 text-[0.6875rem] text-(--ui-text-tertiary)',
-            children: staleNotice
-          })
-        : null,
-      (isLoading || initialRosterLoading) && !roster.length
-        ? jsx('div', {
-            className: 'flex flex-1 items-center justify-center',
-            children: jsx(GlyphSpinner, { spinner: 'breathe', className: 'text-(--ui-text-tertiary)' })
-          })
-        : error && !roster.length
-          ? jsxs('div', {
-              className: 'grid gap-2 px-3 py-4 text-xs text-(--ui-text-tertiary)',
-              children: [
-                jsx('div', {
-                  children: gatewayUp
-                    ? `Roster unavailable: ${error instanceof Error ? error.message : 'gateway error'}. If your gateway predates profiles.list, update Hermes and restart the gateway.`
-                    : 'Waiting for the gateway connection… (remote gateways can take a few seconds; retries automatically)'
-                }),
-                jsx(Button, {
-                  variant: 'secondary',
-                  size: 'sm',
-                  className: 'justify-self-start',
-                  onClick: () => void refetch(),
-                  children: 'Retry now'
-                })
-              ]
-            })
-          : roster.length === 0
-            ? jsx(EmptyState, {
-                icon: 'hubot',
-                title: 'No bots yet',
-                description: 'Create your first bot.'
-              })
-            : allBotsHidden && !hiddenExpanded
-              ? jsxs('div', {
-                  className: 'grid content-start gap-2 px-3 py-4 text-xs text-(--ui-text-tertiary)',
-                  children: [
-                    jsxs('div', {
-                      className: 'flex items-center gap-1.5 font-medium text-(--ui-text-secondary)',
-                      children: [
-                        jsx(Codicon, { name: 'eye-closed', className: 'text-(--ui-text-quaternary)' }),
-                        'All bots are hidden'
-                      ]
-                    }),
-                    jsx('p', { className: 'leading-relaxed', children: 'They keep working and retain their history.' }),
-                    jsx(Button, {
-                      variant: 'secondary',
-                      size: 'sm',
-                      className: 'justify-self-start',
-                      onClick: () => $showHiddenBots.set(true),
-                      children: 'Show hidden bots'
-                    })
-                  ]
-                })
-              : rosterRows.length === 0 && matchingHiddenBots.length === 0
-                ? jsx('div', {
-                    'aria-live': 'polite',
-                    className:
-                      'flex flex-1 items-center justify-center px-4 text-center text-xs text-(--ui-text-tertiary)',
-                    role: 'status',
-                    children: query.trim()
-                      ? `No bots or group chats match “${query.trim()}”${selectedGateway ? ` on ${selectedGateway.label}` : ''}`
-                      : selectedGateway
-                        ? `No bots or group chats match these filters on ${selectedGateway.label}`
-                        : 'No bots or group chats match these filters.'
-                  })
-                : jsx(ScrollArea, {
-                    className: 'hermes-bots-roster min-h-0 flex-1',
-                    children: jsx('div', {
-                      className: 'grid w-full min-w-0 gap-0.5 px-1.5 pb-2',
-                      children: [
-                        ...(showGatewaySections
-                          ? [
-                              sortedGroupRows.length ? renderGroupChatSection() : null,
-                              ...gatewaySections.sections.map(renderGatewaySection)
-                            ].filter(Boolean)
-                          : rosterRows.map(row =>
-                              row.kind === 'group' ? renderGroupRow(row) : renderBotRow(row.bot)
-                            )),
-                        showHiddenSection
-                          ? jsxs(
-                              'div',
-                              {
-                                ref: hiddenSectionRef,
-                                className: 'mt-1 border-t border-(--ui-stroke-tertiary) pt-1',
-                                children: [
-                                hasRosterConstraint
-                                  ? jsxs('div', {
-                                      className:
-                                        'flex w-full items-center gap-1 px-2 py-1.5 text-[0.6875rem] font-medium text-(--ui-text-tertiary)',
-                                      children: [
-                                        jsx(Codicon, { name: 'eye-closed' }),
-                                        jsx('span', { children: 'Hidden' }),
-                                        jsx('span', {
-                                          className: 'text-(--ui-text-quaternary)',
-                                          children: matchingHiddenBots.length
-                                        })
-                                      ]
-                                    })
-                                  : jsxs('button', {
-                                      type: 'button',
-                                      'aria-expanded': hiddenExpanded,
-                                      className:
-                                        'flex w-full items-center gap-1 rounded-md px-2 py-1.5 text-left text-[0.6875rem] font-medium text-(--ui-text-tertiary) transition-colors hover:bg-(--chrome-action-hover) hover:text-foreground',
-                                      onClick: () => $showHiddenBots.set(!hiddenExpanded),
-                                      children: [
-                                        jsx(Codicon, { name: hiddenExpanded ? 'chevron-down' : 'chevron-right' }),
-                                        jsx('span', { children: 'Hidden' }),
-                                        jsx('span', {
-                                          className: 'text-(--ui-text-quaternary)',
-                                          children: hiddenBots.length
-                                        })
-                                      ]
-                                    }),
-                                showHiddenRows
-                                  ? matchingHiddenBots.length
-                                    ? hiddenGatewaySections.sectioned
-                                      ? hiddenGatewaySections.sections.map(renderHiddenGatewaySection)
-                                      : matchingHiddenBots.map(bot => renderBotRow(bot, 'hidden:'))
-                                    : jsx('div', {
-                                        className: 'px-2 py-2 text-xs text-(--ui-text-quaternary)',
-                                        children: 'No hidden bots match these filters.'
-                                      })
-                                  : null
-                                ]
-                              },
-                              'hidden-section'
-                            )
-                          : null
-                      ]
-                    })
-                  }),
-      jsx(CreateAgentDialog, {
-        open: createOpen,
-        onClose: () => {
-          setCreateOpen(false)
-          void refetch()
-        },
-        roster: activeSourceRoster
-      }),
-      jsx(CreateGroupChatDialog, {
-        open: groupCreateOpen,
-        // Full multi-source roster: group chats can seat bots from other
-        // registered connections — their turns route to their own machines.
-        roster,
-        onClose: () => setGroupCreateOpen(false),
-        onCreated: groupName => openGroupChat(groupName)
-      }),
-      jsx(EditProfileDialog, {
-        bot: editing,
-        open: Boolean(editing),
-        onClose: () => {
-          setEditing(null)
-          void refetch()
-        }
-      }),
-      grouping ? jsx(GroupDialog, { bot: grouping, onClose: () => setGrouping(null) }) : null,
-      jsx(ConfirmDialog, {
-        open: Boolean(deleting),
-        title: 'Delete bot and profile?',
-        description: deleting
-          ? jsxs('span', {
-              children: [
-                'This will permanently delete the bot ',
-                jsx('span', { className: 'font-medium text-foreground', children: deleting.name }),
-                ' and its associated Hermes profile at ',
-                jsx('span', { className: 'font-mono text-xs', children: deleting.path }),
-                '. This cannot be undone.'
-              ]
-            })
-          : null,
-        destructive: true,
-        confirmLabel: 'Delete',
-        busyLabel: 'Deleting…',
-        doneLabel: 'Deleted',
-        onClose: () => setDeleting(null),
-        onConfirm: async () => {
-          if (!deleting) {
-            return
-          }
-
-          const name = deleting.name
-          await deleteBot(deleting)
-          await refetch()
-          host.notify({ kind: 'success', message: `Deleted profile ${name}` })
-        }
-      }),
-      jsx(ConfirmDialog, {
-        open: Boolean(deletingGroup),
-        title: 'Delete group chat?',
-        description: deletingGroup
-          ? `This removes “${deletingGroup.name}” from its bots and clears the shared room log. The bots and their individual chats are kept.`
-          : null,
-        destructive: true,
-        confirmLabel: 'Delete Group',
-        busyLabel: 'Deleting…',
-        doneLabel: 'Deleted',
-        onClose: () => setDeletingGroup(null),
-        onConfirm: async () => {
-          if (!deletingGroup) return
-          await disbandGroupChat(deletingGroup.name, deletingGroup.members)
-          host.notify({ kind: 'success', message: `Deleted group “${deletingGroup.name}”` })
-        }
-      })
-    ]
-  })
-}
-
-// ── plugin ───────────────────────────────────────────────────────────────────
-
-export default {
-  id: ID,
-  name: 'Bots',
-  description: 'Bot Mode — a one-chat-per-agent roster with avatars, routines, group chats, and bot-to-bot messaging. Ships with the app; disable here if unwanted.',
-  register(ctx) {
-    pluginCtx = ctx
-    groupChatSyncDisposed = false
-    startFaceClock()
-    // The cross-connection relay rides every gateway socket this Desktop
-    // holds: roster sync + envelope drain/deliver/reply loops.
-    startBotRelay()
-    // Disabling the plugin (or a hot reload) must actually stop the clock —
-    // before this, the rAF loop + 1Hz document scan ran until app restart.
-    if (typeof ctx.onDispose === 'function') {
-      ctx.onDispose(stopFaceClock)
-      ctx.onDispose(stopBotRelay)
-    }
-
-    // @-mention autocomplete: typing "@rese…" in ANY composer offers the
-    // roster's handles (issue #88060). Reads the roster straight from the
-    // query cache — useRoster keeps it ≤5s stale and the popover must answer
-    // synchronously per keystroke. Multi-source rosters contribute their
-    // precomputed @name-device handles via botHandle. The active profile is
-    // excluded (a bot doesn't @ itself); 'default' surfaces as @hermes.
-    ctx.register({
-      id: 'mention-completions',
-      area: COMPOSER_AREAS.atCompletions,
-      data: {
-        provide: query => {
-          const roster = cachedUnionRoster()
-          const profiles = Array.isArray(roster?.profiles) ? roster.profiles : []
-
-          if (!profiles.length) {
-            return []
-          }
-
-          const active = focusedMentionProfile()
-          const q = (query || '').toLowerCase()
-          const items = []
-          const live = {
-            name: active,
-            connectionId: String(host.state.connectionId?.get?.() || host.activeConnectionId?.() || 'local')
-          }
-
-          for (const profile of profiles) {
-            if (!profile?.name || isActiveRosterBot(profile, live)) {
-              continue
-            }
-
-            const handle = botHandle(profile.name, profile)
-            const display = displayName(profile, $botMeta.get()[profile.name])
-            // Renamed bots complete on their friendly name — the tag is the
-            // renamed slug when one exists, the profile handle otherwise.
-            const tag = botMentionTag(profile)
-
-            if (
-              q &&
-              !tag.toLowerCase().startsWith(q) &&
-              !handle.toLowerCase().startsWith(q) &&
-              !display.toLowerCase().startsWith(q)
-            ) {
-              continue
-            }
-
-            const source = profile.connectionLabel ? ` · ${profile.connectionLabel}` : ''
-
-            items.push({
-              insert: `@${tag}`,
-              display: `@${tag}`,
-              meta: `Bot · ${display}${source}`
-            })
-          }
-
-          return items.slice(0, 8)
-        }
-      }
-    })
-
-    // Keyframes for the pet bob — injected because plugin classes aren't in
-    // the app's precompiled CSS. Idempotent across hot reloads.
-    if (!document.getElementById('hermes-bots-keyframes')) {
-      const style = document.createElement('style')
-      style.id = 'hermes-bots-keyframes'
-      style.textContent = '@keyframes hermes-bots-bob { from { transform: translateY(0); } to { transform: translateY(-3px); } }'
-      document.head.appendChild(style)
-    }
-
-    // Hydrate persisted avatars/titles. Migration writes v2 only after a
-    // provable sole-local topology and deliberately leaves v1 untouched for
-    // one-version rollback.
-    void migrateBotMeta(ctx.storage).catch(() => undefined)
-
-    // The last selected bot, source-qualified. Restoring it is PRESENTATION
-    // ONLY: it paints the Bots home and the roster highlight, and never
-    // activates a gateway, opens a chat, or creates a session. The hydrated
-    // flag must flip on every settle path — the home holds a loading state
-    // until it does, and a storage quirk must not strand it there.
-    try {
-      Promise.resolve(ctx.storage?.get?.('selected-roster-bot-v1'))
-        .then(value => {
-          if (typeof value === 'string' && value.trim()) {
-            $selectedRosterKey.set(value.trim())
-          }
-        })
-        .catch(() => undefined)
-        .finally(() => $selectedRosterHydrated.set(true))
-    } catch {
-      /* no storage — this window starts with no restored selection */
-      $selectedRosterHydrated.set(true)
-    }
-
-    // Bot Mode sessions are always hidden now — the old "hide Bot Chats"
-    // pref is gone (its stored key is simply ignored). The reconciliation
-    // sweep below hides any rows born visible under the old pref.
-
-    // Hydrate the activity-toast pref (default OFF).
-    try {
-      Promise.resolve(ctx.storage?.get?.('activity-toasts'))
-        .then(value => {
-          if (typeof value === 'boolean') {
-            $activityToasts.set(value)
-          }
-        })
-        .catch(() => undefined)
-    } catch {
-      /* no storage — default (silent) stays */
-    }
-
-    // Hydrate persisted group-chat room logs (epoch/running are runtime-only
-    // and always reset — a loop can't survive a window reload anyway).
-    try {
-      Promise.resolve(ctx.storage?.get?.('group-chats'))
-        .then(async value => {
-          if (value && typeof value === 'object' && !Array.isArray(value)) {
-            const rooms = {}
-
-            for (const [name, room] of Object.entries(value)) {
-              if (room && Array.isArray(room.log)) {
-                rooms[name] = {
-                  // Pre-thread entries get synthetic thread ids on hydrate so
-                  // every UI/engine path can assume entry.thread exists.
-                  log: assignLegacyThreads(room.log),
-                  watermarks: room.watermarks && typeof room.watermarks === 'object' ? room.watermarks : {},
-                  sessions: room.sessions && typeof room.sessions === 'object' ? room.sessions : {},
-                  sessionOwners: room.sessionOwners && typeof room.sessionOwners === 'object' ? room.sessionOwners : {},
-                  stranded: room.stranded && typeof room.stranded === 'object' ? room.stranded : {},
-                  // #93129: rehydrate sticky stop holds with the same shape
-                  // guard as the other maps — a held bot stays held across
-                  // window restarts until explicitly released.
-                  holds: room.holds && typeof room.holds === 'object' ? room.holds : {},
-                  members: Array.isArray(room.members) ? room.members : [],
-                  roomId: typeof room.roomId === 'string' && room.roomId ? room.roomId : null,
-                  image: typeof room.image === 'string' && room.image ? room.image : null,
-                  syncRevision: Math.max(0, Number(room.syncRevision || 0)),
-                  epoch: 0,
-                  running: false
-                }
-              }
-            }
-
-            $groupChats.set({ ...rooms, ...$groupChats.get() })
-
-            // #93492: annotate rows orphaned before this build (their
-            // connection was deleted while an older Desktop ran, so no
-            // 'removed' push ever swept them). Registry read is
-            // feature-detected; when unavailable only the unresolvable-route
-            // shape (lost connectionId) is annotated.
-            try {
-              const registry =
-                typeof window !== 'undefined'
-                  ? await Promise.resolve(window.hermesDesktop?.connections?.list?.()).catch(() => null)
-                  : null
-              const liveIds = Array.isArray(registry?.connections)
-                ? new Set(registry.connections.map(connection => String(connection?.id || '').trim()).filter(Boolean))
-                : null
-              const annotated = annotateOrphanedGroupChatMembers($groupChats.get(), liveIds)
-
-              if (annotated.changed) {
-                // Per-room updateGroupChat keeps the durable record's full
-                // shape (sessionOwners, holds) in storage; sync:false —
-                // the scheduleGroupChatServerSync below publishes once.
-                for (const [roomName, room] of Object.entries(annotated.rooms)) {
-                  if (room !== $groupChats.get()[roomName]) {
-                    updateGroupChat(roomName, () => room, { sync: false })
-                  }
-                }
-              }
-            } catch {
-              /* registry unavailable — the lost-connectionId shape is still safe to render */
-            }
-          }
-
-          // Receive before publish. A fresh Desktop with no local room cache
-          // must hydrate the gateway projection instead of merely avoiding an
-          // empty overwrite and then rendering an empty conversation.
-          await pullGroupChatServerState().catch(() => false)
-          scheduleGroupChatServerSync($groupChats.get())
-        })
-        .catch(() => undefined)
-    } catch {
-      /* no storage — rooms start empty */
-    }
-
-    // Routines follow the chat you're in: track the focused chat's owner
-    // profile (falls back to the live gateway profile on older desktops —
-    // see $focusedBotProfile). Keying this off the socket's home alone left
-    // the unread-suppression and Routines scope on the wrong bot whenever a
-    // focused tab showed another profile's chat.
-    // Capture the unbinds: without them a disable → re-enable cycle stacks a
-    // duplicate listener per cycle (same survives-disable class as the face
-    // clock before its onDispose hook — these kept firing until app restart).
-    const unbindProfileListener = bindProfileSync($focusedBotOwner)
-    const unbindGatewayListener = host.state.gateway.listen(handleSessionsGatewayTransition)
-
-    // #93492 root fix: the registry pushes a lifecycle event when a
-    // connection is removed. The gateway store already disposes the dead
-    // sockets; the persisted group-chat rosters referencing that connection
-    // were never touched, which is what left panes throwing "Bot X has no
-    // connection owner" forever. Annotate (never silently delete) those
-    // member rows the moment the connection goes away. Feature-detected:
-    // older Electron mains don't emit it, and bare vm test harnesses have
-    // no window global.
-    let unbindConnectionsChanged = null
-    try {
-      if (typeof window !== 'undefined') {
-        unbindConnectionsChanged =
-          window.hermesDesktop?.connections?.onChanged?.(payload => {
-            if (payload?.reason === 'removed') {
-              sweepGroupChatMembersForRemovedConnection(payload.connectionId)
-            }
-          }) || null
-      }
-    } catch {
-      /* registry lifecycle push unavailable — hydrate-time annotate still covers it */
-    }
-
-    if (typeof ctx.onDispose === 'function') {
-      ctx.onDispose(() => {
-        stopGroupChatServerSync()
-        if (typeof unbindProfileListener === 'function') {
-          unbindProfileListener()
-        }
-        if (typeof unbindGatewayListener === 'function') {
-          unbindGatewayListener()
-        }
-        if (typeof unbindConnectionsChanged === 'function') {
-          unbindConnectionsChanged()
-        }
-      })
-    }
-
-    // Reconciliation sweep: hide every Bot Mode session we know about, on
-    // load and again on each reconnect (a swap can land on a gateway whose
-    // rows were created before the always-hidden policy). Deferred a tick so
-    // the meta/room storage hydrates above have landed; idempotent after that.
-    // (Feature-guarded: bare vm test harnesses have no setTimeout global.)
-    startHideSweepScheduler(ctx)
-
-    ctx.register({
-      id: 'pane',
-      area: 'panes',
-      title: 'Bots',
-      // dock: explicit adoption gesture — CENTER-STACK into the sessions zone
-      // so the sidebar grows a SESSIONS | BOTS tab strip instead of splitting
-      // two cramped panes down the column. Center is safe now: insertAtGroup
-      // pins the zone's header explicitly shown on a center gain (and it
-      // stays shown once the zone has stacked), so the sessions pane can
-      // never vanish behind a stripless Bots tab — the lone-pane auto-hide
-      // trap this dock used to work around with a 'bottom' split.
-      // enforce: standing invariant, not a one-shot migration — the pane
-      // re-homes into the sessions strip at EVERY boot it isn't already
-      // there, whatever tokens or user placement an older install persisted.
-      // The one-time heal ('sessions-tab-v1') burned its token even when its
-      // guards skipped the move, so exactly the users who had fought the old
-      // stacked layout (dragged panes → $userPlacedPanes) stayed stacked
-      // forever. Owner's order: SESSIONS | BOTS is always a tab strip.
-      // An intra-session drag still sticks until the next launch (the
-      // invariant runs at adoption time only — see enforceDockedPanes in the
-      // tree store).
-      // collapsible: the pane lives in the sessions zone, so it must LEAVE
-      // the grid with that zone below the sidebar-collapse breakpoint. The
-      // sessions pane collapses alone without this flag. The zone then keeps
-      // a stranded BOTS tab on screen. The narrow edge overlay mirrors the
-      // zone's tab strip, so the pane stays reachable while collapsed.
-      data: { placement: 'left', width: '260px', collapsible: true, hideOnly: true, dock: { pane: 'sessions', pos: 'center', enforce: true } },
-      render: () => jsx(BotsPane, {})
-    })
-
-    // Routines — its OWN tiling pane splitting the workspace's right edge
-    // (NOT the collapsible right sidebar; placement 'right' is that sidebar's
-    // role and hides the pane until "Show Right Sidebar").
-    //
-    // Registered ONLY while Bot Mode is on screen: the pane exists while the
-    // Bots pane is visible (its zone's active tab, or a lone pane in a
-    // stacked pre-heal layout) and unregisters when the user tabs back to
-    // Sessions — no Cronjobs tile squatting beside the chat outside Bot Mode.
-    // `ctx.register` returns the disposer that makes this cheap; the tree
-    // keeps the pane's spot, so re-registering re-adopts it where it was.
-    // host.paneVisibility is feature-detected: older desktops without the SDK
-    // export keep the always-registered behavior.
-    const registerRoutinesPane = () =>
-      ctx.register({
-        id: 'routines',
-        area: 'panes',
-        title: 'Cronjobs',
-        data: {
-          placement: 'main',
-          // Repair persisted layouts that stranded Cronjobs in the Bots tab strip.
-          dock: { pane: 'workspace', pos: 'right', enforce: true },
-          width: '250px'
-        },
-        render: () => jsx(RoutinesPane, {})
-      })
-
-    if (typeof host.paneVisibility === 'function') {
-      // The contribution-scoped pane id (`register` prefixes `${ID}:`).
-      const $sidebarVisible = host.paneVisibility(`${ID}:pane`)
-      let unregisterRoutines = null
-
-      const syncRoutinesPane = () => {
-        if (botChatOwnsWorkspace()) {
-          unregisterRoutines ??= registerRoutinesPane()
-        } else if (unregisterRoutines) {
-          // Clicking the Cronjobs tile moves focus onto the tile itself, which
-          // drops bot-chat workspace ownership for a beat. While Bot Mode is
-          // still on screen and the tile is the one holding focus, keep it —
-          // a pane must never unregister itself out from under its own click.
-          // Leaving Bot Mode ($botsPaneVisible false) still unregisters.
-          const $self = host.paneVisibility(`${ID}:routines`)
-          if ($botsPaneVisible.get() && $self && typeof $self.get === 'function' && $self.get()) return
-          unregisterRoutines()
-          unregisterRoutines = null
-        }
-      }
-
-      // One recompute for both main-area surfaces: they answer the same
-      // question (who owns the center) from the same three signals.
-      const syncWorkspaceSurfaces = () => {
-        syncBotsHomeWorkspace()
-        syncRoutinesPane()
-      }
-
-      const stopSidebarSync = $sidebarVisible.listen(visible => {
-        $botsPaneVisible.set(Boolean(visible))
-        if (visible) {
-          const group = $groupChatWorkspace.get()
-          const selected = selectedRosterBot($lastRoster.get(), $selectedRosterKey.get())
-          setBotsWorkspaceOwner(
-            group ? groupWorkspaceOwnerKey(group) : selected ? botWorkspaceOwnerKey(selected) : BOTS_HOME_OWNER_KEY,
-            group ? null : selected,
-            group ? 'New group conversations start in the group composer.' : 'Select a Bot or group first.'
-          )
-        } else {
-          // Strand any owner wake still dialing. Its SDK open will fail the
-          // workspace token too; this plugin generation prevents that expected
-          // cancellation from repainting Bots home or showing an error after
-          // the user deliberately returned to Sessions.
-          cancelBotOpen()
-          host.setWorkspaceScope?.('sessions')
-        }
-        // A generic composer has no stored-session owner, so passive sync
-        // replaces it with the Bot home. A real restored chat keeps the
-        // center until the user explicitly selects a Bot owner.
-        syncWorkspaceSurfaces()
-      })
-      const stopGroupSync = $groupChatWorkspace.listen(syncWorkspaceSurfaces)
-      // The home tab's visibility flips are the ONLY signal for two real
-      // transitions: layout hydration re-asserting a persisted active tab
-      // over the home after boot, and the user swapping between the home tab
-      // and a chat tab. React on the NEXT tick — the notification arrives
-      // mid-layout-mutation, and registering/unregistering panes from inside
-      // it would re-enter the tree store.
-      const scheduleSurfaceSync = () => {
-        try {
-          setTimeout(syncWorkspaceSurfaces, 0)
-        } catch {
-          syncWorkspaceSurfaces()
-        }
-      }
-      const homeVisibleStore = host.paneVisibility(BOTS_HOME_PANE_ID)
-      const stopHomeVisibleSync = homeVisibleStore.listen(visible => {
-        // Update selection ownership immediately; the deferred pass below may
-        // mutate registrations, but the visible row must never lag a frame.
-        $botsHomeFronted.set(Boolean(visible))
-        scheduleSurfaceSync()
-      })
-      // Tab focus moves without swapping the gateway socket, so the focused
-      // STORED session is the truth about session focus; older shells fall
-      // back to the active session id. A RISING edge means a session just
-      // claimed the center (opened or refocused): the home yields then — and
-      // only then, so an explicitly selected owner can hold the center over
-      // a focused-but-hidden chat without the next poll snatching it back.
-      const focusStore = host.state.focusedStoredSessionId || host.state.activeSessionId
-      const stopFocusSync =
-        typeof focusStore?.listen === 'function'
-          ? focusStore.listen(id => {
-              $botChatFocused.set(Boolean(id))
-              releaseStaleOpenBotChat(id)
-
-              if (id) {
-                closeBotsHomeWorkspace()
-              }
-
-              syncWorkspaceSurfaces()
-            })
-          : null
-
-      // Proactive reclaim refresh: when the gateway reaps the runtime behind
-      // the OPEN bot chat (idle TTL, LRU cap, WS-orphan reap — the mass-reap
-      // shape hits every background bot at once), re-resume the canonical
-      // chat immediately instead of letting the user's next send eat the
-      // stale-id error + recovery retry. Matched on the STORED id (the
-      // claim's ids are stored ids; the payload carries both). Best-effort:
-      // a failed re-resume (backend still down) leaves the lazy recovery on
-      // next send as the backstop. Feature-detected — older shells have no
-      // host.onEvent.
-      const stopReclaimSync =
-        typeof host.onEvent === 'function'
-          ? host.onEvent('session.reclaimed', event => {
-              const payload = event?.payload || {}
-              const stored = String(payload.stored_session_id || '')
-              const claim = $openBotChat.get()
-
-              if (!stored || !claim) {
-                return
-              }
-
-              const owned = [claim.openedSessionId, claim.openedRegistryId].filter(Boolean)
-
-              if (!owned.includes(stored)) {
-                return
-              }
-
-              // A claim without a registry id is a fronted non-canonical tab
-              // (focusExistingBotTab / the draft fallback): re-resolving the
-              // canonical chat here would open the Bot Chat the user has
-              // closed. Its tile recovers on the next send like any tab.
-              if (!claim.openedRegistryId) {
-                return
-              }
-
-              const bot = selectedRosterBot($lastRoster.get(), $selectedRosterKey.get())
-
-              if (!bot) {
-                return
-              }
-
-              const generation = botOpenGeneration
-              void openBotCanonicalChat(bot)
-                .then(opened => {
-                  // A user action while the re-resume ran owns the center now.
-                  if (!opened || generation !== botOpenGeneration) {
-                    return
-                  }
-
-                  $openBotChat.set({
-                    key: claim.key,
-                    openedRegistryId: opened.registryId,
-                    openedSessionId: opened.openedId
-                  })
-                })
-                .catch(() => {
-                  /* backend still down — next send recovers via the ladder */
-                })
-            })
-          : null
-
-      $botsPaneVisible.set(Boolean($sidebarVisible.get()))
-      $botChatFocused.set(sessionOwnsWorkspace())
-      $botsHomeFronted.set(Boolean(homeVisibleStore.get()))
-      // A persisted layout can boot directly into Bot Mode while restoring
-      // the generic Sessions workspace as the active sibling. Reconcile now,
-      // then once more after the layout mutation finishes: the deferred pass
-      // remains passive, so a real restored chat is never covered.
-      syncWorkspaceSurfaces()
-      scheduleSurfaceSync()
-
-      if (typeof ctx.onDispose === 'function') {
-        // The registration disposer is already tracked by ctx.register; only
-        // the listeners need explicit teardown or they survive plugin disable.
-        ctx.onDispose(() => {
-          stopSidebarSync()
-          stopGroupSync()
-          stopHomeVisibleSync()
-          stopFocusSync?.()
-          stopReclaimSync?.()
-          $botsHomeFronted.set(false)
-          closeBotsHomeWorkspace()
-        })
-      }
-    } else {
-      registerRoutinesPane()
-    }
-
-    ctx.register({
-      id: 'new-agent',
-      area: PALETTE_AREA,
-      data: {
-        id: `${ID}.new-agent`,
-        label: 'New Bot…',
-        keywords: ['bot', 'agent', 'profile', 'teammate', 'create'],
-        run: () => {
-          host.notify({ kind: 'info', message: 'Open the Bots pane and hit “New Bot”.' })
-        }
-      }
-    })
-
-    // @-mention middleware: "@<bot> do the thing" in any chat gets an
-    // IDENTIFICATION note — who the user is referring to, resolved against
-    // the LIVE roster ("user@example.com" or an unknown @ passes through
-    // untouched). The middleware never delivers anything itself: the agent
-    // owns messaging via its message_agent tool (Bot Chats), so there is
-    // exactly one send path and user text is never forwarded verbatim by
-    // the renderer. The composer's @-autocomplete remains the picking aid.
-    ctx.register({
-      id: 'mention-middleware',
-      area: COMPOSER_AREAS.middleware,
-      data: {
-        handler: async draft => {
-          const text = draft.text || ''
-
-          // /new inside a bot's canonical forever-chat would fork the
-          // relationship into a scratch session — the one thing Bots mode
-          // promises never happens. Reroute to /compact (same felt effect:
-          // fresh working context, SAME conversation) and say so. Only
-          // guards the canonical chat: Sessions-mode scratchpads on the
-          // same profile keep full /new freedom.
-          const slashNew = /^\/(new|reset)\s*$/.exec(text.trim())
-
-          if (slashNew) {
-            const activeBot = $selectedBot.get()
-            // Canonical identity is the profile's "Bot Chat" registry row —
-            // read it from the roster cache (canonical_session, resolved
-            // server-side by name), matching either the durable row id or
-            // the compression-lineage tip currently on screen.
-            const roster = $lastRoster.get()
-            const row = Array.isArray(roster) ? roster.find(bot => bot?.name === activeBot) : null
-            const canonical = row?.canonical_session || null
-            const currentId = host.activeSessionId?.get?.() ?? null
-            const canonicalIds = [canonical?.id, canonical?.resolved_id].filter(Boolean).map(String)
-
-            if (activeBot && currentId && canonicalIds.includes(String(currentId))) {
-              host.notify({
-                kind: 'info',
-                title: 'This chat never resets',
-                message:
-                  'Bot chats are one continuous conversation — compacting instead. ' +
-                  'For a throwaway session with this agent, use Sessions mode.'
-              })
-
-              return { ...draft, text: '/compact' }
-            }
-          }
-
-          if (!/(^|\s)@[a-z0-9][a-z0-9_-]*/i.test(text)) {
-            return draft
-          }
-
-          const live = {
-            name: focusedMentionProfile(),
-            connectionId: String(host.state.connectionId?.get?.() || host.activeConnectionId?.() || 'local')
-          }
-          const cached = cachedUnionRoster()
-          const roster = Array.isArray(cached?.profiles) ? cached.profiles : null
-          let mentionedBots = roster ? resolveRosterMentions(text, roster, live) : []
-
-          if (!roster) {
-            try {
-              const res = await host.request('profiles.list', { include_sessions: false })
-              // Same resolver as the cached path — renamed bots (display_name
-              // / ui_meta title) stay taggable when the roster cache is cold.
-              mentionedBots = resolveRosterMentions(text, res?.profiles ?? [], live).map(bot => ({ ...bot, remoteSource: false }))
-            } catch {
-              return draft
-            }
-          }
-
-          if (!mentionedBots.length) {
-            return draft
-          }
-
-          // Identification only. Each line names the agent the user's tag
-          // resolves to (friendly title + device for cross-connection rows),
-          // so the agent knows exactly who "@research-buddy" is. Cross-
-          // connection targets carry the '@connection' suffix message_agent
-          // resolves against the Desktop-synced relay roster.
-          const lines = mentionedBots.map(bot => {
-            const handle = botHandle(bot.name, bot)
-            const title = String(botRosterMeta(bot, $botMeta.get())?.title || bot.ui_meta?.['hermes-bots']?.title || bot.title || '').trim()
-            const target = bot.remoteSource && bot.connectionId ? `${handle}@${bot.connectionId}` : handle
-            const where = bot.remoteSource
-              ? ` — on ${bot.connectionLabel || bot.connectionId} (message_agent target: "${target}")`
-              : ''
-            return `@${handle} = agent profile "${bot.name}"${title ? ` ("${title}")` : ''}${where}`
-          })
-          const note =
-            '\n\n[@mentions resolved from the Bot Mode roster — the user is referring to: ' +
-            lines.join('; ') +
-            '. If they want one of these agents contacted, compose your own message and send it with your message_agent tool (agents on other connected machines are reachable too — the Desktop relays it); never forward the user\u2019s text verbatim. If this session has no message_agent tool, agent messaging is unavailable here — say so.]'
-
-          return { ...draft, text: text + note }
-        }      }
-    })
-  }
-}
diff --git a/apps/desktop/src/plugins/hermes-bots/plugin.mentions.test.ts b/apps/desktop/src/plugins/hermes-bots/plugin.mentions.test.ts
new file mode 100644
index 000000000000..1844349c38ec
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/plugin.mentions.test.ts
@@ -0,0 +1,323 @@
+/**
+ * The two composer contributions Bot Mode registers, driven through the real
+ * `plugin.register()`: @-mention completions and the mention middleware.
+ *
+ * Both read the roster IMPERATIVELY (a popover must answer per keystroke, and
+ * the middleware runs on submit), so both go through the query cache rather
+ * than the hook. `useRoster` keys its query on `[...ROSTER_KEY, connectionId]`
+ * — one entry per connection the window has been on — and these readers used
+ * to call `getQueryData(ROSTER_KEY)` with the BARE key. That is an exact-key
+ * match in TanStack Query, so it matched NOTHING: completions offered no
+ * roster handles, and a remote `@name-device` mention passed through the
+ * middleware unhandled (the local `profiles.list` fallback only knows bare
+ * local names). Reproduced on a two-source install where the same profile
+ * name exists locally and on an SSH connection ("Vera"): typing
+ * `@default-vera` did nothing.
+ *
+ * The middleware is IDENTIFICATION-ONLY by design. It annotates who a tag
+ * resolves to and hands the agent a `message_agent` target; the renderer
+ * composes no CLI handoff and delivers nothing itself.
+ */
+
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+interface MentionCompletionItem {
+  display: string
+  insert: string
+  meta: string
+}
+
+interface ComposerDraft {
+  text: string
+}
+
+interface Contribution {
+  area: string
+  data: {
+    handler?: (draft: ComposerDraft) => Promise<ComposerDraft>
+    provide?: (query: string) => MentionCompletionItem[]
+  }
+  id: string
+}
+
+/** One profile name on two sources: locally and on the SSH connection "vera".
+ *  The union roster disambiguates the remote row as @default-vera. */
+const ROSTER = {
+  profiles: [
+    { connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device', name: 'default' },
+    {
+      connectionId: 'vera',
+      connectionKind: 'ssh',
+      connectionLabel: 'Vera',
+      handle: 'default-vera',
+      name: 'default',
+      remoteSource: true,
+      sourceScoped: true
+    }
+  ]
+}
+
+const { cache, hostMock, live } = vi.hoisted(() => {
+  const live = { focused: 'default', profile: 'default' }
+
+  return {
+    cache: new Map<string, { key: unknown[]; value: unknown }>(),
+    hostMock: {
+      notify: vi.fn(),
+      request: vi.fn(async () => ({})),
+      requestProfile: vi.fn(async () => ({})),
+      state: {
+        connectionId: { get: () => 'local', listen: () => () => undefined },
+        focusedSessionProfile: { get: () => live.focused, listen: () => () => undefined },
+        focusedStoredSessionId: { get: () => null, listen: () => () => undefined },
+        gateway: { get: () => null, listen: () => () => undefined },
+        profile: { get: () => live.profile, listen: () => () => undefined }
+      }
+    },
+    live
+  }
+})
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  const stub: unknown = new Proxy(function stubbed() {}, {
+    apply: () => stub,
+    get: (_target, key) => (key === 'then' ? undefined : stub)
+  })
+
+  // A faithful-enough TanStack Query v5 cache: getQueryData matches ONLY the
+  // exact key; getQueriesData prefix-matches a key family.
+  const keyOf = (key: unknown[]) => JSON.stringify(key)
+
+  const queryClient = {
+    getQueriesData: ({ queryKey }: { queryKey: unknown[] }) =>
+      [...cache.values()]
+        .filter(entry => queryKey.every((part, index) => entry.key[index] === part))
+        .map(entry => [entry.key, entry.value]),
+    getQueryData: (key: unknown[]) => cache.get(keyOf(key))?.value,
+    invalidateQueries: () => undefined,
+    setQueryData: (key: unknown[], value: unknown) => cache.set(keyOf(key), { key, value })
+  }
+
+  const known: Record<string, unknown> = {
+    atom,
+    COMPOSER_AREAS: { atCompletions: 'composer.atCompletions', middleware: 'composer.middleware' },
+    host: hostMock,
+    PALETTE_AREA: 'palette',
+    queryClient
+  }
+
+  return new Proxy(known, {
+    get: (target, key) =>
+      typeof key === 'symbol' || key in target ? target[key as string] : key === 'then' ? undefined : stub,
+    has: () => true
+  })
+})
+
+interface Fixture {
+  /** Which connection id the cache entry is filed under — 'local' is the one
+   *  the live window would write. */
+  cacheKeyConnection?: string
+  /** Profile owning the chat on screen; a bot never @s itself. */
+  focused?: string
+  profiles?: Array<Record<string, unknown>>
+}
+
+/** Register the plugin and hand back its composer contributions. */
+async function contributions({
+  cacheKeyConnection = 'local',
+  focused = 'default',
+  profiles = ROSTER.profiles
+}: Fixture = {}) {
+  vi.resetModules()
+  cache.clear()
+  live.focused = focused
+  // Exactly where useRoster writes it: suffixed with the connection id.
+  cache.set(JSON.stringify(['hermes-bots', 'roster', cacheKeyConnection]), {
+    key: ['hermes-bots', 'roster', cacheKeyConnection],
+    value: { profiles }
+  })
+
+  const plugin = (await import('./plugin')).default
+  const registered: Contribution[] = []
+
+  try {
+    plugin.register({
+      i18n: { register: () => () => undefined },
+      onDispose: () => undefined,
+      register: (contribution: Contribution) => registered.push(contribution),
+      storage: { get: async () => undefined, remove: async () => undefined, set: async () => undefined }
+    } as never)
+  } catch {
+    // Registration walks UI surfaces the stub does not fully model; the
+    // contributions registered before any throw are what these tests drive.
+  }
+
+  const completions = registered.find(entry => entry.id === 'mention-completions')
+  const middleware = registered.find(entry => entry.id === 'mention-middleware')
+
+  expect(completions?.data.provide).toBeTypeOf('function')
+  expect(middleware?.data.handler).toBeTypeOf('function')
+
+  return { handler: middleware!.data.handler!, provide: completions!.data.provide! }
+}
+
+// The plugin entry pulls in every Bot Mode surface; transforming that graph
+// once costs more than a single test's budget.
+beforeAll(async () => {
+  await import('./plugin')
+}, 120_000)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  live.focused = 'default'
+  live.profile = 'default'
+})
+
+describe('@-mention completions', () => {
+  it('offers the remote @name-device handle from the suffixed cache entry', async () => {
+    const { provide } = await contributions()
+
+    expect(provide('').map(item => item.insert)).toContain('@default-vera')
+  })
+
+  it('still resolves when the only cached roster is under another connection id', async () => {
+    // The window moved connections; the stale entry is the only one cached.
+    const { provide } = await contributions({ cacheKeyConnection: 'vera' })
+
+    expect(provide('').map(item => item.insert)).toContain('@default-vera')
+  })
+
+  it('surfaces default as @hermes and prefix-filters on the handle', async () => {
+    const { provide } = await contributions({
+      focused: 'researcher',
+      profiles: [
+        { name: 'default' },
+        { name: 'researcher' },
+        { connectionLabel: 'Homelab', handle: 'writer-homelab', name: 'writer' }
+      ]
+    })
+
+    expect(provide('').map(item => item.insert)).toEqual(expect.arrayContaining(['@hermes', '@writer-homelab']))
+    expect(provide('wri').map(item => item.insert)).toEqual(['@writer-homelab'])
+  })
+
+  it('filters self by the FOCUSED chat owner, not the gateway socket profile', async () => {
+    // The socket stays on `default` while the user is inside another bot's
+    // chat; the bot in front of you must not be offered as a handoff target,
+    // and a renamed `default` must stay mentionable from there.
+    const { provide } = await contributions({
+      focused: 'renametest',
+      profiles: [{ display_name: 'Lucy', name: 'default' }, { name: 'renametest' }]
+    })
+
+    const inserts = provide('').map(item => item.insert)
+
+    expect(inserts).toContain('@lucy')
+    expect(inserts).not.toContain('@renametest')
+  })
+
+  it('yields nothing, and never throws, on a cold roster cache', async () => {
+    const { provide } = await contributions({ profiles: [] })
+
+    expect(provide('')).toEqual([])
+  })
+
+  it('never offers the bot whose chat you are already in', async () => {
+    const { provide } = await contributions()
+
+    // 'default' on the LIVE connection is the active bot; only the Vera twin
+    // is a real handoff target.
+    expect(provide('').map(item => item.insert)).toEqual(['@default-vera'])
+  })
+
+  it('narrows on the typed prefix and labels the source device', async () => {
+    const { provide } = await contributions()
+
+    expect(provide('default-v')[0]).toMatchObject({ insert: '@default-vera', meta: expect.stringContaining('Vera') })
+    expect(provide('zzz')).toEqual([])
+  })
+})
+
+describe('the mention middleware', () => {
+  it('identifies a remote @name-device mention without delivering anything', async () => {
+    const { handler } = await contributions()
+    const result = await handler({ text: '@default-vera what is the disk space on the server?' })
+
+    expect(result.text).toMatch(/@mentions resolved from the Bot Mode roster/)
+    expect(result.text).toMatch(/@default-vera/)
+    // No CLI handoff is composed and the renderer performs NO delivery — the
+    // agent owns messaging via its message_agent tool.
+    expect(result.text).not.toMatch(/hermes -p '?default/)
+    expect(hostMock.requestProfile).not.toHaveBeenCalled()
+  })
+
+  it('hands the agent the connection-qualified message_agent target', async () => {
+    const { handler } = await contributions()
+    const result = await handler({ text: 'ping @default-vera' })
+
+    expect(result.text).toMatch(/message_agent target: "default-vera@vera"/)
+    expect(result.text).toMatch(/on Vera/)
+  })
+
+  it('passes a draft with no mention straight through', async () => {
+    const { handler } = await contributions()
+    const draft = { text: 'no tags here' }
+
+    expect(await handler(draft)).toBe(draft)
+  })
+
+  it('leaves an unresolvable tag alone rather than annotating a guess', async () => {
+    const { handler } = await contributions()
+    const draft = { text: 'hey @nobody' }
+
+    expect((await handler(draft)).text).toBe('hey @nobody')
+  })
+
+  it('names a local bot without inventing a device', async () => {
+    const { handler } = await contributions({ focused: 'research', profiles: [{ name: 'research' }, { name: 'ops' }] })
+    const result = await handler({ text: 'please @ops review the diff' })
+
+    expect(result.text).toMatch(/@ops = agent profile "ops"/)
+    expect(result.text).toMatch(/message_agent/)
+    expect(result.text).not.toMatch(/ — on /)
+  })
+
+  it('teaches no shellout and forbids forwarding the user’s text verbatim', async () => {
+    // The class behind #91397 / #91304 / #91339: the renderer used to compose
+    // a `hermes -p …` handoff, giving the model a second send path and a way
+    // to relay the raw draft.
+    const { handler } = await contributions({ focused: 'research', profiles: [{ name: 'research' }, { name: 'ops' }] })
+    const result = await handler({ text: 'ask @ops to summarize' })
+
+    expect(result.text).not.toMatch(/hermes -p/)
+    expect(result.text).not.toMatch(/terminal call/i)
+    expect(result.text).not.toMatch(/background=true/)
+    expect(result.text).toMatch(/compose your own message/i)
+    expect(result.text).toMatch(/never forward/i)
+  })
+
+  it('keeps a poisoned bot title inert prose', async () => {
+    // Nothing here is a command line, so there is nothing to break out of —
+    // the invariant that matters is that no hermes command is ever emitted.
+    const { handler } = await contributions({
+      focused: 'ops',
+      profiles: [
+        { name: 'ops' },
+        { display_name: 'Evil" ; touch /tmp/pwned ; echo "$(touch /tmp/pwned2)"', name: 'research' }
+      ]
+    })
+
+    const result = await handler({ text: 'ping @research please' })
+
+    expect(result.text).not.toMatch(/`hermes/)
+  })
+
+  it('ignores an email address', async () => {
+    const { handler } = await contributions({ focused: 'research', profiles: [{ name: 'research' }, { name: 'ops' }] })
+    const untouched = 'mail user@example.com and ping @nosuchbot'
+
+    expect((await handler({ text: untouched })).text).toBe(untouched)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/plugin.tsx b/apps/desktop/src/plugins/hermes-bots/plugin.tsx
new file mode 100644
index 000000000000..577d7db2e8e4
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/plugin.tsx
@@ -0,0 +1,755 @@
+/**
+ * Hermes Bot Mode — a "one chat per agent" roster for the Hermes desktop.
+ *
+ * Left pane "Bots": one row per Hermes profile (a bot = an agent profile) with
+ * a customizable avatar (shape + color + eyes, image, or pet). Click opens that
+ * bot's chat; right-click → Edit Profile (avatar, title, description).
+ * "New Bot" creates a profile — Name / Title / Description with an
+ * "Advanced" disclosure for full profile config.
+ *
+ * Right tile "Routines": scheduled tasks (Hermes cron jobs) scoped to the
+ * bot you're currently chatting with — follows the live gateway profile.
+ *
+ * Bots message each other straight into each bot's ONE canonical "Bot
+ * Chat" — @-mentions deliver over gateway RPCs (no CLI relay), and
+ * bot-initiated sends use `hermes -p <bot> chat --in ~ -c "Bot Chat"`.
+ */
+
+import { CHAT_EMPTY_AREA, COMPOSER_AREAS, host, PALETTE_AREA, translateNow } from '@hermes/plugin-sdk'
+import type { ChatEmptyProps, PluginContext } from '@hermes/plugin-sdk'
+
+import { startFaceClock, stopFaceClock } from './avatar'
+import {
+  $botChatFocused,
+  $botsPaneVisible,
+  $focusedBotOwner,
+  $openBotChat,
+  $selectedBot,
+  $selectedRosterHydrated,
+  $selectedRosterKey,
+  focusedMentionProfile
+} from './bot-state'
+import { isCanonicalChatOnScreen, openBotCanonicalChat } from './canonical-chat'
+import { BotChatEmpty } from './chat-empty'
+import { bindProfileSync, RoutinesPane } from './cron'
+import {
+  $botMeta,
+  $lastRoster,
+  botHandle,
+  botMentionTag,
+  cachedUnionRoster,
+  isActiveRosterBot,
+  migrateBotMeta,
+  resolveRosterMentions
+} from './data'
+import {
+  $groupChats,
+  $groupChatWorkspace,
+  assignLegacyThreads,
+  handleSessionsGatewayTransition,
+  pullGroupChatServerState,
+  scheduleGroupChatServerSync,
+  setGroupChatSyncDisposed,
+  stopGroupChatServerSync,
+  sweepGroupChatMembersForRemovedConnection,
+  updateGroupChat
+} from './group-chat'
+import { groupWorkspaceOwnerKey } from './group-membership'
+import { annotateOrphanedGroupChatMembers } from './hygiene'
+import { BOTS_LOCALES } from './i18n'
+import { displayName } from './labels'
+import { startBotRelay, stopBotRelay } from './relay'
+import { $activityToasts } from './roster-actions'
+import {
+  botChatOwnsWorkspace,
+  BotsPane,
+  releaseStaleOpenBotChat,
+  selectedRosterBot,
+  sessionOwnsWorkspace
+} from './roster-pane'
+import { botRosterMeta, botWorkspaceOwnerKey, setBotsWorkspaceOwner } from './routing'
+import { startHideSweepScheduler } from './session-sweep'
+import { bumpBotOpenGeneration, getBotOpenGeneration, ID, setPluginCtx } from './shared'
+import type { GroupChat, RosterRow } from './types'
+
+// ── plugin ───────────────────────────────────────────────────────────────────
+
+/** One row the composer's `@` popover renders from the roster. */
+interface MentionCompletionItem {
+  display: string
+  insert: string
+  meta: string
+}
+
+/** The draft a `composer.middleware` handler rewrites, passes through, or
+ *  cancels (this plugin never cancels). */
+interface ComposerDraftPayload {
+  attachments?: unknown[]
+  text: string
+}
+
+export default {
+  id: ID,
+  name: 'Bots',
+  description:
+    'Bot Mode — a one-chat-per-agent roster with avatars, routines, group chats, and bot-to-bot messaging. Ships with the app; disable here if unwanted.',
+  register(ctx: PluginContext) {
+    setPluginCtx(ctx)
+    const disposeLocales = ctx.i18n.register(BOTS_LOCALES)
+    setGroupChatSyncDisposed(false)
+    startFaceClock()
+    // The cross-connection relay rides every gateway socket this Desktop
+    // holds: roster sync + envelope drain/deliver/reply loops.
+    startBotRelay()
+
+    // Disabling the plugin (or a hot reload) must actually stop the clock —
+    // before this, the rAF loop + 1Hz document scan ran until app restart.
+    if (typeof ctx.onDispose === 'function') {
+      ctx.onDispose(disposeLocales)
+      ctx.onDispose(stopFaceClock)
+      ctx.onDispose(stopBotRelay)
+    }
+
+    // @-mention autocomplete: typing "@rese…" in ANY composer offers the
+    // roster's handles (issue #88060). Reads the roster straight from the
+    // query cache — useRoster keeps it ≤5s stale and the popover must answer
+    // synchronously per keystroke. Multi-source rosters contribute their
+    // precomputed @name-device handles via botHandle. The active profile is
+    // excluded (a bot doesn't @ itself); 'default' surfaces as @hermes.
+    ctx.register({
+      id: 'mention-completions',
+      area: COMPOSER_AREAS.atCompletions,
+      data: {
+        provide: (query: string): MentionCompletionItem[] => {
+          const roster = cachedUnionRoster()
+          const profiles = Array.isArray(roster?.profiles) ? roster.profiles : []
+
+          if (!profiles.length) {
+            return []
+          }
+
+          const active = focusedMentionProfile()
+          const q = (query || '').toLowerCase()
+          const items: MentionCompletionItem[] = []
+
+          const live = {
+            name: active,
+            connectionId: String(host.state.connectionId?.get?.() || host.activeConnectionId?.() || 'local')
+          }
+
+          for (const profile of profiles) {
+            if (!profile?.name || isActiveRosterBot(profile, live)) {
+              continue
+            }
+
+            const handle = botHandle(profile.name, profile)
+            const display = displayName(profile, $botMeta.get()[profile.name])
+            // Renamed bots complete on their friendly name — the tag is the
+            // renamed slug when one exists, the profile handle otherwise.
+            const tag = botMentionTag(profile)
+
+            if (
+              q &&
+              !tag.toLowerCase().startsWith(q) &&
+              !handle.toLowerCase().startsWith(q) &&
+              !display.toLowerCase().startsWith(q)
+            ) {
+              continue
+            }
+
+            const source = profile.connectionLabel ? ` · ${profile.connectionLabel}` : ''
+            items.push({
+              insert: `@${tag}`,
+              display: `@${tag}`,
+              meta: `Bot · ${display}${source}`
+            })
+          }
+
+          return items.slice(0, 8)
+        }
+      }
+    })
+
+    // Hydrate persisted avatars/titles. Migration writes v2 only after a
+    // provable sole-local topology and deliberately leaves v1 untouched for
+    // one-version rollback.
+    void migrateBotMeta(ctx.storage).catch(() => undefined)
+
+    // The last selected bot, source-qualified. Restoring it is PRESENTATION
+    // ONLY: it paints the roster highlight, and never activates a gateway,
+    // opens a chat, or creates a session. The hydrated flag must flip on
+    // every settle path — the roster holds a loading state until it does,
+    // and a storage quirk must not strand it there.
+    try {
+      // TODO(bot-mode-types): PluginStorage.get(key, fallback) requires the fallback; every
+      // Bot Mode read omits it (works at runtime, undefined fallback) — same at the two reads below.
+      // @ts-expect-error typed as written rather than changing the call.
+      Promise.resolve(ctx.storage?.get?.('selected-roster-bot-v1'))
+        .then(value => {
+          if (typeof value === 'string' && value.trim()) {
+            $selectedRosterKey.set(value.trim())
+          }
+        })
+        .catch(() => undefined)
+        .finally(() => $selectedRosterHydrated.set(true))
+    } catch {
+      /* no storage — this window starts with no restored selection */
+      $selectedRosterHydrated.set(true)
+    }
+
+    // Bot Mode sessions are always hidden now — the old "hide Bot Chats"
+    // pref is gone (its stored key is simply ignored). The reconciliation
+    // sweep below hides any rows born visible under the old pref.
+
+    // Hydrate the activity-toast pref (default OFF).
+    try {
+      // @ts-expect-error TODO(bot-mode-types): PluginStorage.get requires a fallback argument.
+      Promise.resolve(ctx.storage?.get?.('activity-toasts'))
+        .then(value => {
+          if (typeof value === 'boolean') {
+            $activityToasts.set(value)
+          }
+        })
+        .catch(() => undefined)
+    } catch {
+      /* no storage — default (silent) stays */
+    }
+
+    // Hydrate persisted group-chat room logs (epoch/running are runtime-only
+    // and always reset — a loop can't survive a window reload anyway).
+    try {
+      // @ts-expect-error TODO(bot-mode-types): PluginStorage.get requires a fallback argument.
+      Promise.resolve(ctx.storage?.get?.('group-chats'))
+        .then(async value => {
+          if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const rooms: Record<string, GroupChat> = {}
+
+            for (const [name, room] of Object.entries(value)) {
+              if (room && Array.isArray(room.log)) {
+                rooms[name] = {
+                  // Pre-thread entries get synthetic thread ids on hydrate so
+                  // every UI/engine path can assume entry.thread exists.
+                  log: assignLegacyThreads(room.log),
+                  watermarks: room.watermarks && typeof room.watermarks === 'object' ? room.watermarks : {},
+                  sessions: room.sessions && typeof room.sessions === 'object' ? room.sessions : {},
+                  sessionOwners: room.sessionOwners && typeof room.sessionOwners === 'object' ? room.sessionOwners : {},
+                  stranded: room.stranded && typeof room.stranded === 'object' ? room.stranded : {},
+                  // #93129: rehydrate sticky stop holds with the same shape
+                  // guard as the other maps — a held bot stays held across
+                  // window restarts until explicitly released.
+                  holds: room.holds && typeof room.holds === 'object' ? room.holds : {},
+                  members: Array.isArray(room.members) ? room.members : [],
+                  roomId: typeof room.roomId === 'string' && room.roomId ? room.roomId : null,
+                  image: typeof room.image === 'string' && room.image ? room.image : null,
+                  syncRevision: Math.max(0, Number(room.syncRevision || 0)),
+                  epoch: 0,
+                  running: false
+                }
+              }
+            }
+
+            $groupChats.set({
+              ...rooms,
+              ...$groupChats.get()
+            })
+
+            // #93492: annotate rows orphaned before this build (their
+            // connection was deleted while an older Desktop ran, so no
+            // 'removed' push ever swept them). Registry read is
+            // feature-detected; when unavailable only the unresolvable-route
+            // shape (lost connectionId) is annotated.
+            try {
+              const registry =
+                typeof window !== 'undefined'
+                  ? await Promise.resolve(window.hermesDesktop?.connections?.list?.()).catch(() => null)
+                  : null
+
+              const liveIds = Array.isArray(registry?.connections)
+                ? new Set(registry.connections.map(connection => String(connection?.id || '').trim()).filter(Boolean))
+                : null
+
+              const annotated = annotateOrphanedGroupChatMembers($groupChats.get(), liveIds)
+
+              if (annotated.changed) {
+                // Per-room updateGroupChat keeps the durable record's full
+                // shape (sessionOwners, holds) in storage; sync:false —
+                // the scheduleGroupChatServerSync below publishes once.
+                for (const [roomName, room] of Object.entries(annotated.rooms)) {
+                  if (room !== $groupChats.get()[roomName]) {
+                    updateGroupChat(roomName, () => room, {
+                      sync: false
+                    })
+                  }
+                }
+              }
+            } catch {
+              /* registry unavailable — the lost-connectionId shape is still safe to render */
+            }
+          }
+
+          // Receive before publish. A fresh Desktop with no local room cache
+          // must hydrate the gateway projection instead of merely avoiding an
+          // empty overwrite and then rendering an empty conversation.
+          await pullGroupChatServerState().catch(() => false)
+          scheduleGroupChatServerSync($groupChats.get())
+        })
+        .catch(() => undefined)
+    } catch {
+      /* no storage — rooms start empty */
+    }
+
+    // Routines follow the chat you're in: track the focused chat's owner
+    // profile (falls back to the live gateway profile on older desktops —
+    // see $focusedBotProfile). Keying this off the socket's home alone left
+    // the unread-suppression and Routines scope on the wrong bot whenever a
+    // focused tab showed another profile's chat.
+    // Capture the unbinds: without them a disable → re-enable cycle stacks a
+    // duplicate listener per cycle (same survives-disable class as the face
+    // clock before its onDispose hook — these kept firing until app restart).
+    const unbindProfileListener = bindProfileSync($focusedBotOwner)
+    const unbindGatewayListener = host.state.gateway.listen(handleSessionsGatewayTransition)
+
+    // #93492 root fix: the registry pushes a lifecycle event when a
+    // connection is removed. The gateway store already disposes the dead
+    // sockets; the persisted group-chat rosters referencing that connection
+    // were never touched, which is what left panes throwing "Bot X has no
+    // connection owner" forever. Annotate (never silently delete) those
+    // member rows the moment the connection goes away. Feature-detected:
+    // older Electron mains don't emit it, and bare vm test harnesses have
+    // no window global.
+    let unbindConnectionsChanged: null | (() => void) = null
+
+    try {
+      if (typeof window !== 'undefined') {
+        unbindConnectionsChanged =
+          window.hermesDesktop?.connections?.onChanged?.(payload => {
+            if (payload?.reason === 'removed') {
+              sweepGroupChatMembersForRemovedConnection(payload.connectionId)
+            }
+          }) || null
+      }
+    } catch {
+      /* registry lifecycle push unavailable — hydrate-time annotate still covers it */
+    }
+
+    if (typeof ctx.onDispose === 'function') {
+      ctx.onDispose(() => {
+        stopGroupChatServerSync()
+
+        if (typeof unbindProfileListener === 'function') {
+          unbindProfileListener()
+        }
+
+        if (typeof unbindGatewayListener === 'function') {
+          unbindGatewayListener()
+        }
+
+        if (typeof unbindConnectionsChanged === 'function') {
+          unbindConnectionsChanged()
+        }
+      })
+    }
+
+    // Reconciliation sweep: hide every Bot Mode session we know about, on
+    // load and again on each reconnect (a swap can land on a gateway whose
+    // rows were created before the always-hidden policy). Deferred a tick so
+    // the meta/room storage hydrates above have landed; idempotent after that.
+    // (Feature-guarded: bare vm test harnesses have no setTimeout global.)
+    startHideSweepScheduler(ctx)
+    ctx.register({
+      id: 'pane',
+      area: 'panes',
+      title: 'Bots',
+      // dock: explicit adoption gesture — CENTER-STACK into the sessions zone
+      // so the sidebar grows a SESSIONS | BOTS tab strip instead of splitting
+      // two cramped panes down the column. Center is safe now: insertAtGroup
+      // pins the zone's header explicitly shown on a center gain (and it
+      // stays shown once the zone has stacked), so the sessions pane can
+      // never vanish behind a stripless Bots tab — the lone-pane auto-hide
+      // trap this dock used to work around with a 'bottom' split.
+      // enforce: standing invariant, not a one-shot migration — the pane
+      // re-homes into the sessions strip at EVERY boot it isn't already
+      // there, whatever tokens or user placement an older install persisted.
+      // The one-time heal ('sessions-tab-v1') burned its token even when its
+      // guards skipped the move, so exactly the users who had fought the old
+      // stacked layout (dragged panes → $userPlacedPanes) stayed stacked
+      // forever. Owner's order: SESSIONS | BOTS is always a tab strip.
+      // An intra-session drag still sticks until the next launch (the
+      // invariant runs at adoption time only — see enforceDockedPanes in the
+      // tree store).
+      // collapsible: the pane lives in the sessions zone, so it must LEAVE
+      // the grid with that zone below the sidebar-collapse breakpoint. The
+      // sessions pane collapses alone without this flag. The zone then keeps
+      // a stranded BOTS tab on screen. The narrow edge overlay mirrors the
+      // zone's tab strip, so the pane stays reachable while collapsed.
+      data: {
+        placement: 'left',
+        width: '260px',
+        collapsible: true,
+        hideOnly: true,
+        dock: {
+          pane: 'sessions',
+          pos: 'center',
+          enforce: true
+        }
+      },
+      render: () => <BotsPane />
+    })
+
+    // Routines — its OWN tiling pane splitting the workspace's right edge
+    // (NOT the collapsible right sidebar; placement 'right' is that sidebar's
+    // role and hides the pane until "Show Right Sidebar").
+    //
+    // Registered ONLY while Bot Mode is on screen: the pane exists while the
+    // Bots pane is visible (its zone's active tab, or a lone pane in a
+    // stacked pre-heal layout) and unregisters when the user tabs back to
+    // Sessions — no Cronjobs tile squatting beside the chat outside Bot Mode.
+    // `ctx.register` returns the disposer that makes this cheap; the tree
+    // keeps the pane's spot, so re-registering re-adopts it where it was.
+    // host.paneVisibility is feature-detected: older desktops without the SDK
+    // export keep the always-registered behavior.
+    const registerRoutinesPane = () =>
+      ctx.register({
+        id: 'routines',
+        area: 'panes',
+        // The app's noun for these, so the tab agrees with the pane header and
+        // with the core Scheduled jobs surface. `translateNow`, not `useI18n`:
+        // a pane title is read at registration, outside React.
+        title: translateNow('cron.title'),
+        data: {
+          placement: 'main',
+          // Repair persisted layouts that stranded Cronjobs in the Bots tab strip.
+          dock: {
+            pane: 'workspace',
+            pos: 'right',
+            enforce: true
+          },
+          // A bot's schedule is glanceable, not something you sit in — it
+          // arrives as the right edge's vertical tab and takes no width off the
+          // chat until the user opens it.
+          defaultCollapsed: true,
+          width: '250px'
+        },
+        render: () => <RoutinesPane />
+      })
+
+    if (typeof host.paneVisibility === 'function') {
+      // The contribution-scoped pane id (`register` prefixes `${ID}:`).
+      const $sidebarVisible = host.paneVisibility(`${ID}:pane`)
+      let unregisterRoutines: null | (() => void) = null
+
+      const syncRoutinesPane = () => {
+        if (botChatOwnsWorkspace()) {
+          unregisterRoutines ??= registerRoutinesPane()
+        } else if (unregisterRoutines) {
+          // Clicking the Cronjobs tile moves focus onto the tile itself, which
+          // drops bot-chat workspace ownership for a beat. While Bot Mode is
+          // still on screen and the tile is the one holding focus, keep it —
+          // a pane must never unregister itself out from under its own click.
+          // Leaving Bot Mode ($botsPaneVisible false) still unregisters.
+          const $self = host.paneVisibility(`${ID}:routines`)
+
+          if ($botsPaneVisible.get() && $self && typeof $self.get === 'function' && $self.get()) {
+            return
+          }
+
+          unregisterRoutines()
+          unregisterRoutines = null
+        }
+      }
+
+      const stopSidebarSync = $sidebarVisible.listen(visible => {
+        $botsPaneVisible.set(Boolean(visible))
+
+        if (visible) {
+          const group = $groupChatWorkspace.get()
+          const selected = selectedRosterBot($lastRoster.get(), $selectedRosterKey.get())
+
+          // Owner routing only. With neither a group nor a selected bot there
+          // is no bot-owned surface to scope, so leave the workspace on
+          // whatever the user was already looking at — the roster-hydration
+          // effect in BotsPane scopes it the moment a real owner exists.
+          //
+          // This is where the Bots home used to claim the center and refuse a
+          // new chat with "Select a Bot or group first." Deleting the home
+          // deleted the dead end it was apologizing for: with nothing selected
+          // the center is an ordinary session and `+` works there. The refusal
+          // itself still stands for the cases that remain — a group room, and
+          // a selected row too orphaned to route (setBotsWorkspaceOwner's
+          // blocked target).
+          if (group) {
+            setBotsWorkspaceOwner(
+              groupWorkspaceOwnerKey(group),
+              null,
+              'New group conversations start in the group composer.'
+            )
+          } else if (selected) {
+            setBotsWorkspaceOwner(botWorkspaceOwnerKey(selected), selected)
+          }
+        } else {
+          // Strand any owner wake still dialing. Its SDK open will fail the
+          // workspace token too; this plugin generation prevents that expected
+          // cancellation from showing an error after the user deliberately
+          // returned to Sessions.
+          bumpBotOpenGeneration()
+          host.setWorkspaceScope?.('sessions')
+        }
+
+        syncRoutinesPane()
+      })
+
+      const stopGroupSync = $groupChatWorkspace.listen(syncRoutinesPane)
+
+      // React on the NEXT tick — a layout notification arrives mid-mutation,
+      // and registering/unregistering panes from inside it would re-enter the
+      // tree store.
+      const scheduleRoutinesSync = () => {
+        try {
+          setTimeout(syncRoutinesPane, 0)
+        } catch {
+          syncRoutinesPane()
+        }
+      }
+
+      // Tab focus moves without swapping the gateway socket, so the focused
+      // STORED session is the truth about session focus; older shells fall
+      // back to the active session id.
+      const focusStore = host.state.focusedStoredSessionId || host.state.activeSessionId
+
+      const stopFocusSync =
+        typeof focusStore?.listen === 'function'
+          ? focusStore.listen(id => {
+              $botChatFocused.set(Boolean(id))
+              releaseStaleOpenBotChat(id)
+              syncRoutinesPane()
+            })
+          : null
+
+      // Proactive reclaim refresh: when the gateway reaps the runtime behind
+      // the OPEN bot chat (idle TTL, LRU cap, WS-orphan reap — the mass-reap
+      // shape hits every background bot at once), re-resume the canonical
+      // chat immediately instead of letting the user's next send eat the
+      // stale-id error + recovery retry. Matched on the STORED id (the
+      // claim's ids are stored ids; the payload carries both). Best-effort:
+      // a failed re-resume (backend still down) leaves the lazy recovery on
+      // next send as the backstop. Feature-detected — older shells have no
+      // host.onEvent.
+      const stopReclaimSync =
+        typeof host.onEvent === 'function'
+          ? host.onEvent('session.reclaimed', event => {
+              const payload = (event?.payload || {}) as { stored_session_id?: string }
+              const stored = String(payload.stored_session_id || '')
+              const claim = $openBotChat.get()
+
+              if (!stored || !claim) {
+                return
+              }
+
+              const owned = [claim.openedSessionId, claim.openedRegistryId].filter(Boolean)
+
+              if (!owned.includes(stored)) {
+                return
+              }
+
+              // A claim without a registry id is a fronted non-canonical tab
+              // (focusExistingBotTab / the draft fallback): re-resolving the
+              // canonical chat here would open the Bot Chat the user has
+              // closed. Its tile recovers on the next send like any tab.
+              if (!claim.openedRegistryId) {
+                return
+              }
+
+              const bot = selectedRosterBot($lastRoster.get(), $selectedRosterKey.get())
+
+              if (!bot) {
+                return
+              }
+
+              const generation = getBotOpenGeneration()
+              void openBotCanonicalChat(bot)
+                .then(opened => {
+                  // A user action while the re-resume ran owns the center now.
+                  if (!opened || generation !== getBotOpenGeneration()) {
+                    return
+                  }
+
+                  $openBotChat.set({
+                    key: claim.key,
+                    openedRegistryId: opened.registryId,
+                    openedSessionId: opened.openedId
+                  })
+                })
+                .catch(() => {
+                  /* backend still down — next send recovers via the ladder */
+                })
+            })
+          : null
+
+      $botsPaneVisible.set(Boolean($sidebarVisible.get()))
+      $botChatFocused.set(sessionOwnsWorkspace())
+      // A persisted layout can boot directly into Bot Mode. Reconcile now,
+      // then once more after the layout mutation finishes.
+      syncRoutinesPane()
+      scheduleRoutinesSync()
+
+      if (typeof ctx.onDispose === 'function') {
+        // The registration disposer is already tracked by ctx.register; only
+        // the listeners need explicit teardown or they survive plugin disable.
+        ctx.onDispose(() => {
+          stopSidebarSync()
+          stopGroupSync()
+          stopFocusSync?.()
+          stopReclaimSync?.()
+        })
+      }
+    } else {
+      registerRoutinesPane()
+    }
+
+    // A bot's chat before it has spoken: core's splash is Hermes' wordmark and
+    // stands down for any session that exists, so the bot titles its own.
+    ctx.register({
+      id: 'chat-empty',
+      area: CHAT_EMPTY_AREA,
+      data: {
+        render: ({ sessionId }: ChatEmptyProps) => <BotChatEmpty sessionId={sessionId} />
+      }
+    })
+
+    ctx.register({
+      id: 'new-agent',
+      area: PALETTE_AREA,
+      data: {
+        id: `${ID}.new-agent`,
+        label: 'New Bot…',
+        keywords: ['bot', 'agent', 'profile', 'teammate', 'create'],
+        run: () => {
+          host.notify({
+            kind: 'info',
+            message: ctx.i18n.t('bot.createFirstHint')
+          })
+        }
+      }
+    })
+
+    // @-mention middleware: "@<bot> do the thing" in any chat gets an
+    // IDENTIFICATION note — who the user is referring to, resolved against
+    // the LIVE roster ("user@example.com" or an unknown @ passes through
+    // untouched). The middleware never delivers anything itself: the agent
+    // owns messaging via its message_agent tool (Bot Chats), so there is
+    // exactly one send path and user text is never forwarded verbatim by
+    // the renderer. The composer's @-autocomplete remains the picking aid.
+    ctx.register({
+      id: 'mention-middleware',
+      area: COMPOSER_AREAS.middleware,
+      data: {
+        handler: async (draft: ComposerDraftPayload): Promise<ComposerDraftPayload> => {
+          const text = draft.text || ''
+
+          // /new inside a bot's canonical forever-chat would fork the
+          // relationship into a scratch session — the one thing Bots mode
+          // promises never happens. Reroute to /compact (same felt effect:
+          // fresh working context, SAME conversation) and say so. Only
+          // guards the canonical chat: Sessions-mode scratchpads on the
+          // same profile keep full /new freedom.
+          const slashNew = /^\/(new|reset)\s*$/.exec(text.trim())
+
+          if (slashNew) {
+            const activeBot = $selectedBot.get()
+            // Canonical identity is the profile's "Bot Chat" registry row —
+            // read it from the roster cache (canonical_session, resolved
+            // server-side by name), matching either the durable row id or
+            // the compression-lineage tip currently on screen.
+            const roster = $lastRoster.get()
+            const row = Array.isArray(roster) ? roster.find(bot => bot?.name === activeBot) : null
+
+            // The STORED id, which is the id space canonical_session is keyed
+            // in. `host.state.activeSessionId` is the runtime id and could
+            // never match, so the guard read `host.activeSessionId` — no such
+            // property — and silently resolved to null on every turn: /new
+            // reset the forever-chat instead of compacting it.
+            if (activeBot && isCanonicalChatOnScreen(row, host.state.focusedStoredSessionId.get())) {
+              host.notify({
+                kind: 'info',
+                title: 'This chat never resets',
+                message:
+                  'Bot chats are one continuous conversation — compacting instead. ' +
+                  'For a throwaway session with this bot, use Sessions mode.'
+              })
+
+              return {
+                ...draft,
+                text: '/compact'
+              }
+            }
+          }
+
+          if (!/(^|\s)@[a-z0-9][a-z0-9_-]*/i.test(text)) {
+            return draft
+          }
+
+          const live = {
+            name: focusedMentionProfile(),
+            connectionId: String(host.state.connectionId?.get?.() || host.activeConnectionId?.() || 'local')
+          }
+
+          const cached = cachedUnionRoster()
+          const roster = Array.isArray(cached?.profiles) ? cached.profiles : null
+          let mentionedBots = roster ? resolveRosterMentions(text, roster, live) : []
+
+          if (!roster) {
+            try {
+              const res = await host.request<{ profiles?: RosterRow[] }>('profiles.list', {
+                include_sessions: false
+              })
+
+              // Same resolver as the cached path — renamed bots (display_name
+              // / ui_meta title) stay taggable when the roster cache is cold.
+              mentionedBots = resolveRosterMentions(text, res?.profiles ?? [], live).map(bot => ({
+                ...bot,
+                remoteSource: false
+              }))
+            } catch {
+              return draft
+            }
+          }
+
+          if (!mentionedBots.length) {
+            return draft
+          }
+
+          // Identification only. Each line names the agent the user's tag
+          // resolves to (friendly title + device for cross-connection rows),
+          // so the agent knows exactly who "@research-buddy" is. Cross-
+          // connection targets carry the '@connection' suffix message_agent
+          // resolves against the Desktop-synced relay roster.
+          const lines = mentionedBots.map(bot => {
+            const handle = botHandle(bot.name, bot)
+
+            const title = String(
+              botRosterMeta(bot, $botMeta.get())?.title || bot.ui_meta?.['hermes-bots']?.title || bot.title || ''
+            ).trim()
+
+            const target = bot.remoteSource && bot.connectionId ? `${handle}@${bot.connectionId}` : handle
+
+            const where = bot.remoteSource
+              ? ` — on ${bot.connectionLabel || bot.connectionId} (message_agent target: "${target}")`
+              : ''
+
+            return `@${handle} = agent profile "${bot.name}"${title ? ` ("${title}")` : ''}${where}`
+          })
+
+          const note =
+            '\n\n[@mentions resolved from the Bot Mode roster — the user is referring to: ' +
+            lines.join('; ') +
+            '. If they want one of these agents contacted, compose your own message and send it with your message_agent tool (agents on other connected machines are reachable too — the Desktop relays it); never forward the user\u2019s text verbatim. If this session has no message_agent tool, agent messaging is unavailable here — say so.]'
+
+          return {
+            ...draft,
+            text: text + note
+          }
+        }
+      }
+    })
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/profile-config-capabilities.test.tsx b/apps/desktop/src/plugins/hermes-bots/profile-config-capabilities.test.tsx
new file mode 100644
index 000000000000..d46a01dbf5d6
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/profile-config-capabilities.test.tsx
@@ -0,0 +1,302 @@
+/**
+ * The bot editor's Advanced section renders the REAL core Capabilities
+ * surfaces — SkillsView (installed skills + hub installs + detail),
+ * ToolsetConfigPanel (per-toolset env/keys/model/post-setup) and McpTab
+ * (per-server enable + OAuth + API keys) — pinned to the bot's own profile,
+ * instead of bare checkbox stand-ins.
+ *
+ * All three are optional SDK namespace exports (hermes-agent#87317), so every
+ * use site is feature-detected and older desktop builds keep the staged
+ * checklist UI. The sharp edge is a REMOTE bot on a build whose SkillsView
+ * predates `supportsFixedConnection`: rendering the live surface there would
+ * read and write the ACTIVE gateway's skills under the remote bot's name —
+ * the wrong machine — so those builds must fail closed to "staged only".
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { cleanup, render, screen } from '@testing-library/react'
+import type { ReactNode } from 'react'
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { translateBots } from './i18n-test-helper'
+import type { CapabilityEntry } from './profile-config'
+import type { RosterRow } from './types'
+
+interface StubProps {
+  fixedConnection?: string
+  fixedProfile?: string
+  gateway?: string
+  profile?: unknown
+  toolset?: string
+}
+
+/** The optional SDK exports, swapped per test to model each desktop build. */
+const sdk = vi.hoisted(() => {
+  const seen: Record<string, StubProps[]> = { McpTab: [], SkillsView: [], ToolsetConfigPanel: [] }
+
+  const spy = (name: string) => {
+    const Stub = (props: StubProps) => {
+      seen[name].push(props)
+
+      return null
+    }
+
+    return Stub
+  }
+
+  return {
+    exports: {} as Record<string, unknown>,
+    gatewayReads: { count: 0 },
+    request: vi.fn(async () => ({})),
+    requestProfile: vi.fn(async () => ({})),
+    seen,
+    spy
+  }
+})
+
+// The optional exports are read at MODULE scope, so each build's set has to
+// be live at the moment `vi.resetModules()` re-evaluates the editor — a value
+// baked into the factory would freeze the first test's build for the rest.
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const original = await importOriginal<typeof HermesSdk>()
+
+  const mocked: Record<string, unknown> = {
+    ...original,
+    host: {
+      ...original.host,
+      getGateway: () => {
+        sdk.gatewayReads.count += 1
+
+        return 'ambient-gateway'
+      },
+      request: sdk.request,
+      requestProfile: sdk.requestProfile
+    },
+    // The plugin bundle normally lands via `ctx.i18n.register` at load.
+    usePluginI18n: () => translateBots
+  }
+
+  for (const name of ['McpTab', 'SkillsView', 'ToolsetConfigPanel']) {
+    Object.defineProperty(mocked, name, { configurable: true, enumerable: true, get: () => sdk.exports[name] })
+  }
+
+  return mocked
+})
+
+// Each build re-imports the editor's whole module graph, which outruns the
+// default per-test budget on a cold transform cache.
+vi.setConfig({ testTimeout: 30_000 })
+
+const remoteBot: RosterRow = {
+  connectionId: 'remote-a',
+  name: 'default',
+  remoteSource: true,
+  route: { connectionId: 'remote-a', mode: 'remote', profile: 'default', targetProfile: 'backend-default' },
+  sourceScoped: true,
+  targetProfile: 'backend-default'
+}
+
+const localBot: RosterRow = {
+  connectionId: 'local',
+  name: 'default',
+  remoteSource: false,
+  route: { connectionId: 'local', mode: 'local', profile: 'default', targetProfile: 'default' },
+  sourceScoped: true,
+  targetProfile: 'default'
+}
+
+const advancedState: {
+  dirtyMcp: boolean
+  dirtyModel: boolean
+  dirtySkills: boolean
+  dirtySoul: boolean
+  dirtyToolsets: boolean
+  loaded: boolean
+  mcp: CapabilityEntry[]
+  model: string
+  provider: string
+  skills: CapabilityEntry[]
+  soul: string
+  toolsets: CapabilityEntry[]
+} = {
+  dirtyMcp: false,
+  dirtyModel: false,
+  dirtySkills: false,
+  dirtySoul: false,
+  dirtyToolsets: false,
+  loaded: true,
+  mcp: [{ enabled: false, fromCatalog: true, installed: false, name: 'remote-mcp', requires: ['TOKEN'] }],
+  model: '',
+  provider: '',
+  skills: [],
+  soul: '',
+  toolsets: []
+}
+
+function withQueryClient(children: ReactNode) {
+  return (
+    <QueryClientProvider client={new QueryClient({ defaultOptions: { queries: { retry: false } } })}>
+      {children}
+    </QueryClientProvider>
+  )
+}
+
+/** Load the editor against one desktop build's export set. */
+async function renderEditor(
+  exports: Record<string, unknown>,
+  bot: RosterRow,
+  state: Partial<typeof advancedState> = {}
+) {
+  sdk.exports = exports
+  vi.resetModules()
+
+  const { AdvancedProfileConfig } = await import('./profile-config')
+
+  return render(
+    withQueryClient(
+      <AdvancedProfileConfig bot={bot} setState={() => undefined} state={{ ...advancedState, ...state }} />
+    )
+  )
+}
+
+beforeAll(async () => {
+  // Warm the transform cache so the first test isn't charged for it.
+  await import('./profile-config')
+}, 120_000)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  sdk.gatewayReads.count = 0
+
+  for (const key of Object.keys(sdk.seen)) {
+    sdk.seen[key].length = 0
+  }
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('a build whose SkillsView cannot route connections', () => {
+  const oldBuild = () => ({
+    McpTab: sdk.spy('McpTab'),
+    SkillsView: sdk.spy('SkillsView'),
+    ToolsetConfigPanel: sdk.spy('ToolsetConfigPanel')
+  })
+
+  it('fails closed for a REMOTE bot \u2014 staged model + SOUL only', async () => {
+    const { container } = await renderEditor(oldBuild(), remoteBot)
+
+    // The model catalog settles first so the picker is past its spinner.
+    expect(await screen.findByText('Provider')).toBeTruthy()
+    expect(screen.getByText(/Remote capabilities require a newer desktop/)).toBeTruthy()
+    expect(sdk.seen.SkillsView).toHaveLength(0)
+    expect(sdk.seen.McpTab).toHaveLength(0)
+    expect(sdk.seen.ToolsetConfigPanel).toHaveLength(0)
+    expect(screen.queryByText('Skills Hub')).toBeNull()
+    expect(screen.queryByRole('button', { name: /Set up/ })).toBeNull()
+    // Model + SOUL still edit, and stay staged until the user saves.
+    expect(container.querySelector('textarea')).toBeTruthy()
+    // Nothing may read the AMBIENT gateway on behalf of a remote bot.
+    expect(sdk.gatewayReads.count).toBe(0)
+
+    container.querySelectorAll('button, input').forEach(node => (node as HTMLElement).click())
+
+    expect(sdk.request).not.toHaveBeenCalled()
+    expect(sdk.gatewayReads.count).toBe(0)
+  })
+
+  it('keeps the LOCAL capability surfaces, each scoped to the bot profile', async () => {
+    await renderEditor(oldBuild(), localBot, {
+      skills: [{ enabled: true, name: 'staged-skill' }],
+      toolsets: [{ enabled: true, name: 'local-tools' }]
+    })
+
+    // The staged checklist and the hub search section both survive here.
+    expect(screen.getByText('staged-skill')).toBeTruthy()
+    expect(screen.getByText('Skills Hub')).toBeTruthy()
+    expect(sdk.seen.ToolsetConfigPanel[0]).toEqual({
+      profile: { connectionId: 'local', profile: 'default' },
+      toolset: 'local-tools'
+    })
+    expect(sdk.seen.McpTab[0]).toEqual({
+      gateway: 'ambient-gateway',
+      profile: { connectionId: 'local', profile: 'default' }
+    })
+    expect(sdk.gatewayReads.count).toBe(1)
+  })
+})
+
+describe('a connection-aware SkillsView', () => {
+  it('receives the connection and the BACKEND profile separately', async () => {
+    const Routed = sdk.spy('SkillsView')
+
+    ;(Routed as unknown as { supportsFixedConnection: boolean }).supportsFixedConnection = true
+
+    await renderEditor({ SkillsView: Routed }, remoteBot)
+
+    // The alias's logical name is `default`; the backend row it activates into
+    // is `backend-default`. Pinning the logical name would edit the wrong one.
+    expect(sdk.seen.SkillsView[0]).toMatchObject({
+      fixedConnection: 'remote-a',
+      fixedProfile: 'backend-default'
+    })
+  })
+
+  it('#93492: degrades an orphaned row to its own name instead of throwing', async () => {
+    const Routed = sdk.spy('SkillsView')
+
+    ;(Routed as unknown as { supportsFixedConnection: boolean }).supportsFixedConnection = true
+
+    // A row whose owning connection was removed resolves to no route at all.
+    // The editor renders on the render path, so a throw here would take the
+    // whole pane down through the dialog's error boundary.
+    await renderEditor({ SkillsView: Routed }, { ...remoteBot, connectionId: '', route: undefined })
+
+    expect(sdk.seen.SkillsView[0]).toEqual({ embedded: true, fixedProfile: 'default' })
+  })
+})
+
+describe('a build with no Capabilities exports at all', () => {
+  const bareBuild = { McpTab: undefined, SkillsView: undefined, ToolsetConfigPanel: undefined }
+
+  it('keeps the checkbox MCP list with its inline setup button', async () => {
+    await renderEditor(bareBuild, localBot)
+
+    expect(screen.getByText('remote-mcp')).toBeTruthy()
+    expect(screen.getByRole('button', { name: /Set up/ })).toBeTruthy()
+  })
+
+  it('says so plainly when the profile has no MCP servers', async () => {
+    await renderEditor(bareBuild, localBot, { mcp: [] })
+
+    expect(screen.getByText('No MCP servers configured or in the catalog.')).toBeTruthy()
+  })
+})
+
+describe('the model catalog read', () => {
+  it('#95279: rides the bot\u2019s captured route and never forces a refresh', async () => {
+    sdk.exports = {}
+    vi.resetModules()
+
+    const { ModelPicker } = await import('./model-picker')
+
+    render(
+      withQueryClient(<ModelPicker bot={remoteBot} onChange={() => undefined} value={{ model: '', provider: '' }} />)
+    )
+
+    // No `refresh`: a forced network read on every mount bypassed the
+    // staleTime cache, so each Bots view remount re-entered the spinner and
+    // discarded the user's staged selection mid-edit.
+    expect(sdk.requestProfile).toHaveBeenCalledWith(
+      expect.objectContaining({ connectionId: 'remote-a' }),
+      'model.options',
+      {
+        explicit_only: false,
+        include_unconfigured: true
+      }
+    )
+    expect(sdk.request).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/profile-config.test.ts b/apps/desktop/src/plugins/hermes-bots/profile-config.test.ts
new file mode 100644
index 000000000000..e5876bb87c20
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/profile-config.test.ts
@@ -0,0 +1,231 @@
+/**
+ * `applyAdvancedConfig` — the advanced editor's save, which persists ONLY the
+ * dirty sections and reports per-section outcomes back to the dialog.
+ *
+ * Two contracts live here:
+ *
+ *  - **Inherit clears the pin.** A dirty model section with both fields empty
+ *    means "inherit the gateway default", which is a `config unset model`, not
+ *    a configure payload. Its success/failure has to merge into the same
+ *    `applied` map as the RPC sections, or the dialog toasts a contradictory
+ *    "saved" over a failed clear.
+ *  - **#95293 on this surface.** The gateway now guards data-policy /
+ *    expensive models for `profiles.configure` too, answering
+ *    `confirm_required` + `confirm_message`. Bots does NOT route through
+ *    use-model-controls, so before the fix that response matched no branch and
+ *    the pick silently dropped. It must go through the SAME shared handler the
+ *    core picker uses (one applier, no forked confirm UI), must not count as a
+ *    FAILED section while it is merely pending, and Confirm must resend ONLY
+ *    the model section with `confirm_expensive_model: true`.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { applyAdvancedConfig, emptyAdvancedState } from './profile-config'
+import type { RosterRow } from './types'
+
+type AdvancedConfigState = ReturnType<typeof emptyAdvancedState>
+
+/** The payload the shared core confirm flow receives — the same object the
+ *  model picker hands it. */
+interface ModelSwitchConfirmArgs {
+  confirmMessage: string
+  finish: () => void
+  requestConfirmed: () => Promise<{ applied?: Record<string, boolean> } | undefined>
+}
+
+const { confirmMock, hostMock, invalidateMock } = vi.hoisted(() => ({
+  confirmMock: vi.fn((_args: ModelSwitchConfirmArgs) => 'notification-1'),
+  hostMock: {
+    getGateway: () => 'ambient-gateway',
+    request: vi.fn(),
+    requestProfile: vi.fn(),
+    state: { connectionId: { get: () => 'local' }, gateway: { get: () => 'open' }, profile: { get: () => 'default' } }
+  },
+  invalidateMock: vi.fn()
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    atom,
+    Button: () => null,
+    Checkbox: () => null,
+    GlyphSpinner: () => null,
+    host: hostMock,
+    Input: () => null,
+    McpTab: undefined,
+    queryClient: { invalidateQueries: invalidateMock },
+    ScrollArea: () => null,
+    Select: () => null,
+    SelectContent: () => null,
+    SelectItem: () => null,
+    SelectTrigger: () => null,
+    SelectValue: () => null,
+    SkillsView: undefined,
+    surfaceModelSwitchConfirm: confirmMock,
+    Textarea: () => null,
+    ToolsetConfigPanel: undefined,
+    useQuery: vi.fn(() => ({ data: undefined, error: null, isLoading: false })),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+// The SOUL protocol append has its own suite; here it must not rewrite the
+// text under the assertions.
+vi.mock('./soul', () => ({ ensureMessagingProtocol: (soul: string) => soul }))
+
+const bot = { name: 'zeta' } as RosterRow
+
+const dirtyModel = (patch: Partial<AdvancedConfigState> = {}): AdvancedConfigState => ({
+  ...emptyAdvancedState(),
+  dirtyModel: true,
+  loaded: true,
+  model: 'muse-spark-1.2-contributor',
+  provider: 'opencode-go',
+  ...patch
+})
+
+/** Every RPC in order, with params frozen at call time. */
+const routed: Array<{ method: string; params: Record<string, unknown> }> = []
+
+function respondWith(handler: (method: string, params: Record<string, unknown>) => unknown) {
+  hostMock.request.mockImplementation(async (method: string, params: Record<string, unknown>) => {
+    routed.push({ method, params: structuredClone(params ?? {}) })
+
+    return handler(method, params)
+  })
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  routed.length = 0
+  respondWith(() => ({}))
+})
+
+describe('selecting Inherit', () => {
+  it('clears the profile model assignment through the CLI', async () => {
+    respondWith(() => ({ blocked: false, code: 0, output: 'Unset model' }))
+
+    const result = await applyAdvancedConfig(bot, dirtyModel({ model: '', provider: '' }))
+
+    expect(routed).toEqual([
+      { method: 'cli.exec', params: { argv: ['--profile', 'zeta', 'config', 'unset', 'model'] } }
+    ])
+    expect(result).toEqual({ applied: { model: true }, ok: true })
+  })
+
+  it('merges the clear with the other dirty sections’ outcomes', async () => {
+    respondWith(method => (method === 'cli.exec' ? { blocked: false, code: 0 } : { applied: { soul: true } }))
+
+    const result = await applyAdvancedConfig(
+      bot,
+      dirtyModel({ dirtySoul: true, model: '', provider: '', soul: '# Ops' })
+    )
+
+    expect(routed.map(call => call.method)).toEqual(['cli.exec', 'profiles.configure'])
+    expect(routed[1].params).toEqual({ name: 'zeta', soul: '# Ops' })
+    expect(result).toMatchObject({ applied: { model: true, soul: true }, ok: true })
+  })
+
+  it('reports a rejected clear as a failed section', async () => {
+    respondWith(() => ({ blocked: false, code: 1, output: 'Config key not set' }))
+
+    await expect(applyAdvancedConfig(bot, dirtyModel({ model: '', provider: '' }))).resolves.toEqual({
+      applied: { model: false },
+      ok: false
+    })
+  })
+
+  it('treats a thrown clear the same as a rejected one', async () => {
+    hostMock.request.mockRejectedValue(new Error('gateway down'))
+
+    await expect(applyAdvancedConfig(bot, dirtyModel({ model: '', provider: '' }))).resolves.toEqual({
+      applied: { model: false },
+      ok: false
+    })
+  })
+
+  it('refuses a half-filled model section outright', async () => {
+    // A provider with no model (or the reverse) is neither a pin nor a clear.
+    await expect(applyAdvancedConfig(bot, dirtyModel({ model: '' }))).resolves.toEqual({
+      applied: { model: false },
+      ok: false
+    })
+    expect(routed).toHaveLength(0)
+  })
+})
+
+describe('a guarded model switch (#95293)', () => {
+  it('surfaces the SHARED confirm flow instead of silently dropping the pick', async () => {
+    respondWith(() => ({
+      applied: {},
+      confirm_message: 'CONTRIBUTOR TIER: this model may train on your data.',
+      confirm_required: true,
+      ok: true
+    }))
+
+    const result = await applyAdvancedConfig(bot, dirtyModel())
+
+    expect(routed).toHaveLength(1)
+    expect(routed[0].method).toBe('profiles.configure')
+    expect(routed[0].params.model).toBe('muse-spark-1.2-contributor')
+    expect(routed[0].params.confirm_expensive_model).toBeFalsy()
+
+    expect(confirmMock).toHaveBeenCalledTimes(1)
+    expect(confirmMock.mock.calls[0][0].confirmMessage).toMatch(/CONTRIBUTOR TIER/)
+
+    // Pending confirmation is NOT a failed section — the editor must not toast
+    // "Some sections failed: model" while the confirm toast is still up.
+    expect(result.applied?.model).not.toBe(false)
+    expect(result.ok).toBe(true)
+  })
+
+  it('resends ONLY the model section on Confirm', async () => {
+    let calls = 0
+
+    respondWith(() => {
+      calls += 1
+
+      return calls === 1
+        ? { applied: {}, confirm_message: 'guarded', confirm_required: true, ok: true }
+        : { applied: { model: true }, ok: true }
+    })
+
+    await applyAdvancedConfig(bot, dirtyModel({ dirtySoul: true, soul: '# Zeta' }))
+
+    const confirmed = await confirmMock.mock.calls[0][0].requestConfirmed()
+
+    expect(routed).toHaveLength(2)
+    expect(routed[1].method).toBe('profiles.configure')
+    expect(Object.keys(routed[1].params).sort()).toEqual(['confirm_expensive_model', 'model', 'name', 'provider'])
+    expect(routed[1].params).toMatchObject({
+      confirm_expensive_model: true,
+      model: 'muse-spark-1.2-contributor',
+      name: 'zeta',
+      provider: 'opencode-go'
+    })
+    expect(confirmed?.applied?.model).toBe(true)
+  })
+
+  it('refreshes the roster once the confirmed switch lands', async () => {
+    respondWith(() => ({ applied: {}, confirm_message: 'guarded', confirm_required: true, ok: true }))
+
+    await applyAdvancedConfig(bot, dirtyModel())
+    confirmMock.mock.calls[0][0].finish()
+
+    expect(invalidateMock).toHaveBeenCalled()
+  })
+
+  it('leaves an unguarded save single-shot', async () => {
+    respondWith(() => ({ applied: { model: true }, ok: true }))
+
+    const result = await applyAdvancedConfig(bot, dirtyModel())
+
+    expect(routed).toHaveLength(1)
+    expect(confirmMock).not.toHaveBeenCalled()
+    expect(result).toMatchObject({ applied: { model: true }, ok: true })
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/profile-config.tsx b/apps/desktop/src/plugins/hermes-bots/profile-config.tsx
new file mode 100644
index 000000000000..eee01eccd5b2
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/profile-config.tsx
@@ -0,0 +1,641 @@
+/**
+ * The advanced profile editor: skills, toolsets, MCP servers, model and SOUL,
+ * backed by `profiles.describe` / `profiles.configure`.
+ *
+ * The optional-SDK feature detects live here because this is the surface that
+ * needs them, and the create dialog — which stages the same capabilities
+ * before a profile exists — reads them from here rather than duplicating the
+ * detection.
+ */
+
+import * as sdk from '@hermes/plugin-sdk'
+import {
+  Checkbox,
+  GlyphSpinner,
+  host,
+  Input,
+  queryClient,
+  surfaceModelSwitchConfirm,
+  Textarea
+} from '@hermes/plugin-sdk'
+import { useState } from 'react'
+
+import { $lastRoster, ROSTER_KEY } from './data'
+import { labeled, ResizableFrame } from './dialog-parts'
+import { useBots } from './i18n'
+import { McpSetupButton } from './mcp-setup'
+import { ModelPicker } from './model-picker'
+import { botBackendProfileScope, requestForBot, resolveBotConnectionRoute } from './routing'
+import { HubSkillsSection } from './skills-hub'
+import { ensureMessagingProtocol } from './soul'
+import type { RosterRow } from './types'
+
+// Keep optional exports feature-detected; test harnesses may strip the SDK namespace.
+// The Partial is the point: both are guarded at every use site because an older
+// build (or a stripped harness namespace) simply doesn't export them.
+const { McpTab, ToolsetConfigPanel }: Partial<Pick<typeof sdk, 'McpTab' | 'ToolsetConfigPanel'>> = sdk
+export const SkillsView = typeof sdk === 'undefined' ? undefined : sdk.SkillsView
+// TRUE only on builds whose SkillsView routes `fixedConnection` to the pinned
+// registry connection's backend. Older builds export SkillsView WITHOUT the
+// prop — rendering it for a remote-target draft there would read/write the
+// ACTIVE gateway's skills under the remote bot's name (the wrong machine),
+// so those builds keep the staged checklists for remote targets.
+export const skillsViewRoutesConnections = Boolean(SkillsView && SkillsView.supportsFixedConnection)
+
+// ── advanced profile config (skills / toolsets / model / SOUL) ──────────────
+//
+// Shared by Edit Profile and New Bot (edit mode only for skills/toolsets —
+// a not-yet-created profile has nothing installed to toggle). Backed by
+// profiles.describe / profiles.configure; feature-detects older gateways.
+
+/** One toggleable capability row. Skills, toolsets, and MCP servers all
+ *  arrive from `profiles.describe` / `mcp.catalog` in this shape and run
+ *  through the same toggle handlers, so they share one entry type. */
+export interface CapabilityEntry {
+  auth?: string
+  description?: string
+  enabled?: boolean
+  fromCatalog?: boolean
+  installed?: boolean
+  name: string
+  requires?: string[]
+  tool_count?: number
+}
+interface CheckListProps {
+  columns?: number
+  items: CapabilityEntry[]
+  onToggle: (name: string, enabled: boolean) => void
+}
+
+export function CheckList({ items, onToggle, columns = 2 }: CheckListProps) {
+  return (
+    <div
+      style={{
+        display: 'grid',
+        gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))`,
+        gap: '2px 12px'
+      }}
+    >
+      {items.map(item => (
+        <label
+          className="flex min-w-0 cursor-pointer items-center gap-1.5 py-0.5 text-xs text-(--ui-text-secondary)"
+          key={item.name}
+          title={item.description || item.name}
+        >
+          <Checkbox checked={item.enabled} onCheckedChange={value => onToggle(item.name, Boolean(value))} />
+          <span className="truncate">{item.name}</span>
+          {item.tool_count ? (
+            <span className="shrink-0 text-[0.6rem] text-(--ui-text-quaternary)">{`${item.tool_count}`}</span>
+          ) : null}
+        </label>
+      ))}
+    </div>
+  )
+}
+
+/** `profiles.describe` as the advanced editor reads it. */
+export interface ProfileDescribeResponse {
+  mcp_servers?: CapabilityEntry[]
+  model?: { default?: string; provider?: string }
+  skills?: CapabilityEntry[]
+  soul?: string
+  toolsets?: CapabilityEntry[]
+}
+/** `mcp.catalog` — the bundled, installable MCP menu. */
+export interface McpCatalogResponse {
+  servers?: CapabilityEntry[]
+}
+/** Staged advanced-config edits. Each `dirty*` flag gates one section of the
+ *  `profiles.configure` payload, so an untouched section is never written. */
+interface AdvancedConfigState {
+  dirtyMcp: boolean
+  dirtyModel: boolean
+  dirtySkills: boolean
+  dirtySoul: boolean
+  dirtyToolsets: boolean
+  loaded: boolean
+  mcp: CapabilityEntry[]
+  model: string
+  provider: string
+  skills: CapabilityEntry[]
+  soul: string
+  toolsets: CapabilityEntry[]
+}
+interface AdvancedProfileConfigProps {
+  bot: RosterRow
+  setState: (update: (prev: AdvancedConfigState) => AdvancedConfigState) => void
+  state: AdvancedConfigState
+}
+
+export function AdvancedProfileConfig({ bot, state, setState }: AdvancedProfileConfigProps) {
+  const b = useBots()
+  const [loaded, setLoaded] = useState(false)
+  const [unsupported, setUnsupported] = useState(false)
+  const [skillFilter, setSkillFilter] = useState('')
+  // Component body = render path: degrade an orphaned row to the bot's own
+  // name scope instead of throwing into the dialog's error boundary.
+  const botRoute = resolveBotConnectionRoute(bot).route
+  const backendProfile = botRoute?.targetProfile || botRoute?.profile || bot.name
+  const backendScope = botBackendProfileScope(botRoute, bot.name)
+
+  if (!loaded) {
+    setLoaded(true)
+    Promise.all([
+      requestForBot(bot, 'profiles.describe', {
+        name: bot.name
+      }) as Promise<ProfileDescribeResponse>,
+      (
+        requestForBot(bot, 'mcp.catalog', {
+          profile: bot.name
+        }) as Promise<McpCatalogResponse>
+      ).catch(() => null)
+    ])
+      .then(([res, cat]) => {
+        const configured = res.mcp_servers || []
+        const have = new Set(configured.map(m => m.name))
+        const catalog = ((cat && cat.servers) || []).filter(s => !have.has(s.name))
+        setState(prev => ({
+          ...prev,
+          provider: res.model?.provider || '',
+          model: res.model?.default || '',
+          soul: res.soul || '',
+          skills: res.skills || [],
+          toolsets: res.toolsets || [],
+          mcp: [
+            ...configured.map(m => ({
+              ...m,
+              enabled: m.enabled !== false
+            })),
+            ...catalog.map(s => ({
+              name: s.name,
+              enabled: false,
+              fromCatalog: true,
+              installed: s.installed,
+              auth: s.auth,
+              requires: s.requires || [],
+              description: s.description || ''
+            }))
+          ],
+          loaded: true
+        }))
+      })
+      .catch(() => setUnsupported(true))
+  }
+
+  if (unsupported) {
+    return (
+      <div className="px-2 py-3 text-center text-xs text-(--ui-text-tertiary)">
+        Full configuration needs a newer gateway (restart it after updating Hermes).
+      </div>
+    )
+  }
+
+  if (!state.loaded) {
+    return (
+      <div className="flex justify-center py-4">
+        <GlyphSpinner className="text-(--ui-text-tertiary)" spinner="breathe" />
+      </div>
+    )
+  }
+
+  const visibleSkills = skillFilter.trim()
+    ? state.skills.filter(s => s.name.toLowerCase().includes(skillFilter.trim().toLowerCase()))
+    : state.skills
+
+  const toggleSkill = (name: string, enabled: boolean) =>
+    setState(prev => ({
+      ...prev,
+      dirtySkills: true,
+      skills: prev.skills.map(s =>
+        s.name === name
+          ? {
+              ...s,
+              enabled
+            }
+          : s
+      )
+    }))
+
+  const toggleToolset = (name: string, enabled: boolean) =>
+    setState(prev => ({
+      ...prev,
+      dirtyToolsets: true,
+      toolsets: prev.toolsets.map(t =>
+        t.name === name
+          ? {
+              ...t,
+              enabled
+            }
+          : t
+      )
+    }))
+
+  const toggleMcp = (name: string, enabled: boolean) =>
+    setState(prev => ({
+      ...prev,
+      dirtyMcp: true,
+      mcp: (prev.mcp || []).map(m =>
+        m.name === name
+          ? {
+              ...m,
+              enabled
+            }
+          : m
+      )
+    }))
+
+  const enabledSkills = state.skills.filter(s => s.enabled).length
+  const enabledToolsets = state.toolsets.filter(t => t.enabled).length
+  const mcpList = state.mcp || []
+
+  // Newer desktop builds export the WHOLE core Capabilities surface
+  // (hermes-agent#87317): Skills (installed list + one-click hub installs +
+  // full-skill detail), Tools (per-toolset config), and MCP — pinned to this
+  // bot via fixedProfile, tab state kept out of the page router via embedded.
+  // Render THAT instead of the checkbox stand-ins; writes go straight to the
+  // bot's backend, so the dirty-section staging below only carries
+  // model + SOUL on these builds. Older builds keep the full checklist UI.
+  if (SkillsView && (!botRoute || skillsViewRoutesConnections)) {
+    return (
+      <div className="grid gap-4">
+        <ModelPicker
+          bot={bot}
+          onChange={patch =>
+            setState(prev => ({
+              ...prev,
+              dirtyModel: true,
+              ...patch
+            }))
+          }
+          value={{
+            provider: state.provider,
+            model: state.model
+          }}
+        />
+        {labeled(
+          'Capabilities (applies immediately — skills, tools, MCP)',
+          <ResizableFrame height={460} minHeight={300}>
+            <SkillsView
+              embedded
+              fixedProfile={backendProfile}
+              {...(botRoute
+                ? {
+                    fixedConnection: botRoute.connectionId
+                  }
+                : {})}
+            />
+          </ResizableFrame>
+        )}
+        {labeled(
+          'SOUL.md (persona + agent-messaging protocol)',
+          <Textarea
+            className="min-h-28 font-mono text-xs leading-5"
+            onChange={event =>
+              setState(prev => ({
+                ...prev,
+                dirtySoul: true,
+                soul: event.target.value
+              }))
+            }
+            value={state.soul}
+          />
+        )}
+      </div>
+    )
+  }
+
+  if (bot?.sourceScoped && botRoute?.mode === 'remote' && !skillsViewRoutesConnections) {
+    return (
+      <div className="grid gap-4">
+        <ModelPicker
+          bot={bot}
+          onChange={patch =>
+            setState(prev => ({
+              ...prev,
+              dirtyModel: true,
+              ...patch
+            }))
+          }
+          value={{
+            provider: state.provider,
+            model: state.model
+          }}
+        />
+        <div className="rounded-md border border-(--ui-stroke-secondary) px-3 py-2 text-xs text-(--ui-text-tertiary)">
+          Remote capabilities require a newer desktop. Model and SOUL changes remain staged until you save.
+        </div>
+        {labeled(
+          'SOUL.md (persona + agent-messaging protocol)',
+          <Textarea
+            className="min-h-28 font-mono text-xs leading-5"
+            onChange={event =>
+              setState(prev => ({
+                ...prev,
+                dirtySoul: true,
+                soul: event.target.value
+              }))
+            }
+            value={state.soul}
+          />
+        )}
+      </div>
+    )
+  }
+
+  return (
+    <div className="grid gap-4">
+      <ModelPicker
+        bot={bot}
+        onChange={patch =>
+          setState(prev => ({
+            ...prev,
+            dirtyModel: true,
+            ...patch
+          }))
+        }
+        value={{
+          provider: state.provider,
+          model: state.model
+        }}
+      />
+      {labeled(
+        `Skills (${enabledSkills}/${state.skills.length} enabled)`,
+        <div className="grid gap-1.5 rounded-md border border-(--ui-stroke-secondary) p-2">
+          <Input
+            className="h-7 text-xs"
+            onChange={event => setSkillFilter(event.target.value)}
+            placeholder={b.tools.filterSkills}
+            value={skillFilter}
+          />
+          <div
+            className="overflow-y-auto overscroll-contain"
+            style={{
+              maxHeight: 180
+            }}
+          >
+            <CheckList columns={2} items={visibleSkills} onToggle={toggleSkill} />
+          </div>
+          <HubSkillsSection
+            forProfile={backendScope}
+            onInstalled={name =>
+              setState(prev =>
+                prev.skills.some(s => s.name === name)
+                  ? prev
+                  : {
+                      ...prev,
+                      skills: [
+                        ...prev.skills,
+                        {
+                          name,
+                          enabled: true
+                        }
+                      ]
+                    }
+              )
+            }
+          />
+        </div>
+      )}
+      {labeled(
+        `Toolsets (${enabledToolsets}/${state.toolsets.length} enabled — unchecking all restores the default)`,
+        <div className="rounded-md border border-(--ui-stroke-secondary) p-2">
+          <div
+            className="overflow-y-auto overscroll-contain"
+            style={{
+              maxHeight: 320
+            }}
+          >
+            <div className="grid gap-1.5">
+              {state.toolsets.map(tset => (
+                <div className="rounded-md border border-(--ui-stroke-secondary) p-2" key={tset.name}>
+                  <label className="flex items-center gap-2 text-xs font-medium text-(--ui-text-secondary)">
+                    <Checkbox
+                      checked={!!tset.enabled}
+                      onCheckedChange={value => toggleToolset(tset.name, Boolean(value))}
+                    />
+                    <span>{tset.name}</span>
+                  </label>
+                  {/* The REAL per-toolset config (env vars / API keys / model */
+                  /* picker / post-setup), scoped to THIS bot's profile, when */
+                  /* the desktop build exposes it. Older builds: just the toggle. */}
+                  {ToolsetConfigPanel ? (
+                    <div className="mt-1.5 border-t border-(--ui-stroke-secondary) pt-1.5">
+                      <ToolsetConfigPanel profile={backendScope} toolset={tset.name} />
+                    </div>
+                  ) : null}
+                </div>
+              ))}
+            </div>
+          </div>
+        </div>
+      )}
+      {labeled(
+        'MCP servers',
+        <div className="overflow-hidden rounded-md border border-(--ui-stroke-secondary)">
+          {McpTab && typeof host.getGateway === 'function' ? (
+            <div
+              style={{
+                minHeight: 220,
+                maxHeight: 360
+              }}
+            >
+              <McpTab gateway={host.getGateway()} profile={backendScope} />
+            </div>
+          ) : mcpList.length === 0 ? (
+            <div className="px-1 py-2 text-center text-xs text-(--ui-text-tertiary)">{b.tools.noMcpServers}</div>
+          ) : (
+            <div
+              className="overflow-y-auto overscroll-contain"
+              style={{
+                maxHeight: 180
+              }}
+            >
+              <div className="grid gap-1 p-2">
+                {mcpList.map(m => {
+                  const needsSetup =
+                    m.fromCatalog &&
+                    !m.installed &&
+                    ((m.requires || []).length > 0 || (m.auth || '').toLowerCase() === 'oauth')
+
+                  return (
+                    <label className="flex items-start gap-2 text-xs text-(--ui-text-secondary)" key={m.name}>
+                      <Checkbox
+                        checked={!!m.enabled}
+                        disabled={needsSetup}
+                        onCheckedChange={value => toggleMcp(m.name, Boolean(value))}
+                      />
+                      <span className="min-w-0">
+                        <span>{m.name}</span>
+                        {m.fromCatalog && !needsSetup ? (
+                          <span className="ml-1.5 text-[0.65rem] text-(--ui-text-quaternary)">
+                            {m.installed ? 'catalog · installed' : 'catalog'}
+                          </span>
+                        ) : null}
+                        {needsSetup ? (
+                          <McpSetupButton entry={m} onDone={() => toggleMcp(m.name, true)} profile={backendScope} />
+                        ) : null}
+                        {m.description ? (
+                          <div className="truncate text-[0.65rem] leading-4 text-(--ui-text-quaternary)">
+                            {m.description}
+                          </div>
+                        ) : null}
+                      </span>
+                    </label>
+                  )
+                })}
+              </div>
+            </div>
+          )}
+        </div>
+      )}
+      {labeled(
+        'SOUL.md (persona + agent-messaging protocol)',
+        <Textarea
+          className="min-h-28 font-mono text-xs leading-5"
+          onChange={event =>
+            setState(prev => ({
+              ...prev,
+              dirtySoul: true,
+              soul: event.target.value
+            }))
+          }
+          value={state.soul}
+        />
+      )}
+    </div>
+  )
+}
+
+export function emptyAdvancedState(): AdvancedConfigState {
+  return {
+    loaded: false,
+    provider: '',
+    model: '',
+    soul: '',
+    skills: [],
+    toolsets: [],
+    mcp: [],
+    dirtyModel: false,
+    dirtySoul: false,
+    dirtySkills: false,
+    dirtyToolsets: false,
+    dirtyMcp: false
+  }
+}
+
+/** The `profiles.configure` body this editor writes — one key per dirty
+ *  section. A type alias, not an interface: it is handed straight to
+ *  `requestForBot`, whose params are a `Record<string, unknown>`, and only
+ *  aliases pick up the implicit index signature that requires. */
+export type ProfileConfigurePayload = {
+  disabled_skills?: string[]
+  enabled_mcp_servers?: string[]
+  enabled_toolsets?: string[]
+  model?: string
+  name: string
+  provider?: string
+  soul?: string
+}
+/** What `profiles.configure` answers: per-section success, plus the #95293
+ *  expensive-model / data-policy confirmation gate. */
+interface ProfileConfigureResult {
+  applied?: Record<string, boolean>
+  confirm_message?: string
+  confirm_required?: boolean
+}
+
+/** Persist only the dirty sections of the advanced editor. */
+export async function applyAdvancedConfig(bot: RosterRow, state: AdvancedConfigState) {
+  const payload: ProfileConfigurePayload = {
+    name: bot.name
+  }
+
+  const applied: Record<string, boolean> = {}
+
+  if (state.dirtySoul) {
+    payload.soul = ensureMessagingProtocol(state.soul, bot.name, $lastRoster.get())
+  }
+
+  if (state.dirtyModel) {
+    const model = state.model.trim()
+    const provider = state.provider.trim()
+
+    if (model && provider) {
+      payload.model = model
+      payload.provider = provider
+    } else if (!model && !provider) {
+      try {
+        const result = (await requestForBot(bot, 'cli.exec', {
+          argv: ['--profile', bot.name, 'config', 'unset', 'model']
+        })) as { blocked?: boolean; code?: number }
+
+        applied.model = result?.blocked !== true && result?.code === 0
+      } catch {
+        applied.model = false
+      }
+    } else {
+      applied.model = false
+    }
+  }
+
+  if (state.dirtySkills) {
+    payload.disabled_skills = state.skills.filter(s => !s.enabled).map(s => s.name)
+  }
+
+  if (state.dirtyToolsets) {
+    const all = state.toolsets.length
+    const enabled = state.toolsets.filter(t => t.enabled)
+    // All enabled (or none) = clear the pin; otherwise pin the checked set.
+    payload.enabled_toolsets = enabled.length === all || enabled.length === 0 ? [] : enabled.map(t => t.name)
+  }
+
+  if (state.dirtyMcp) {
+    payload.enabled_mcp_servers = (state.mcp || []).filter(m => m.enabled).map(m => m.name)
+  }
+
+  if (Object.keys(payload).length === 1) {
+    return {
+      ok: Object.values(applied).every(Boolean),
+      applied
+    }
+  }
+
+  const result = (await requestForBot(bot, 'profiles.configure', payload)) as ProfileConfigureResult
+
+  const merged = {
+    ...applied,
+    ...(result?.applied || {})
+  }
+
+  // #95293 remainder: the gateway now guards data-policy / expensive models
+  // on THIS surface too — `confirm_required` means the model section is
+  // PENDING the user's confirmation, not failed. Route it through the SAME
+  // shared confirm handler the core picker uses (one applier, no forked
+  // confirm logic per surface): the Confirm action resends ONLY the model
+  // section with `confirm_expensive_model: true`.
+  if (result?.confirm_required && payload.model && payload.provider) {
+    delete merged.model
+    surfaceModelSwitchConfirm({
+      confirmLabel: 'Confirm',
+      confirmMessage: result.confirm_message,
+      failureMessage: 'Model switch failed',
+      finish: () =>
+        queryClient.invalidateQueries({
+          queryKey: ROSTER_KEY
+        }),
+      requestConfirmed: () =>
+        requestForBot(bot, 'profiles.configure', {
+          name: bot.name,
+          model: payload.model,
+          provider: payload.provider,
+          confirm_expensive_model: true
+        }) as Promise<ProfileConfigureResult>
+    })
+  }
+
+  return {
+    ...result,
+    ok: Object.values(merged).every(Boolean),
+    applied: merged
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/profile-ops.test.ts b/apps/desktop/src/plugins/hermes-bots/profile-ops.test.ts
new file mode 100644
index 000000000000..6b794421fd15
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/profile-ops.test.ts
@@ -0,0 +1,155 @@
+/**
+ * Duplicating a bot: clone the profile (config/skills/SOUL/memory via
+ * `clone_from`) and copy the LOOK, but never the things that belong to the
+ * original — its canonical-chat pointer and its creation stamp.
+ *
+ * The name search is the other half. Candidates are `<base>-2`, `-3`, … and
+ * the BASE is truncated to fit, never the suffix (#19): slicing the joined
+ * string chops the "-2" off a max-length name, so the candidate collides with
+ * the base forever and the search runs out at -99.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { $botMeta } from './data'
+import { duplicateBot } from './profile-ops'
+import type { RosterRow } from './types'
+
+const { ensureBotMetadataMock, hostMock, storageMock } = vi.hoisted(() => ({
+  ensureBotMetadataMock: vi.fn(),
+  hostMock: {
+    request: vi.fn(),
+    requestProfile: vi.fn(),
+    state: { connectionId: { get: () => 'local' }, focusedSessionOwner: null, profile: { get: () => 'default' } }
+  },
+  storageMock: { get: vi.fn(), set: vi.fn() }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    atom,
+    forgetSessionUnread: vi.fn(),
+    host: hostMock,
+    queryClient: { invalidateQueries: vi.fn() },
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => ({ storage: storageMock }), ID: 'hermes-bots' }))
+vi.mock('./avatar-image', () => ({ isBackfilledFacePng: () => false }))
+vi.mock('./canonical-chat', () => ({ ensureBotMetadata: ensureBotMetadataMock }))
+
+const calls: Array<{ method: string; params: Record<string, unknown> }> = []
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  calls.length = 0
+  $botMeta.set({})
+  storageMock.set.mockResolvedValue(undefined)
+  hostMock.request.mockImplementation(async (method: string, params: Record<string, unknown>) => {
+    calls.push({ method, params: structuredClone(params ?? {}) })
+
+    return { ok: true }
+  })
+})
+
+describe('duplicating a bot', () => {
+  it('copies the look but neither the chat pointer nor the creation stamp', async () => {
+    $botMeta.set({
+      researcher: {
+        chat: 'sess-source-forever',
+        color: '#f97316',
+        created: 1_700_000_000_000,
+        image: 'data:image/png;base64,xx',
+        shape: 'circle',
+        title: 'Researcher'
+      }
+    })
+
+    const name = await duplicateBot({ description: 'finds things', name: 'researcher' } as RosterRow, [
+      { name: 'researcher' } as RosterRow
+    ])
+
+    expect(name).toBe('researcher-2')
+
+    const clone = $botMeta.get()['researcher-2']
+
+    expect(clone).toMatchObject({
+      color: '#f97316',
+      image: 'data:image/png;base64,xx',
+      shape: 'circle',
+      title: 'Researcher (copy)'
+    })
+    expect(clone.chat).toBeUndefined()
+    expect(clone.created).toBeUndefined()
+
+    expect(calls.find(call => call.method === 'profiles.create')?.params).toMatchObject({
+      clone_from: 'researcher',
+      name: 'researcher-2'
+    })
+
+    const configure = calls.filter(call => call.method === 'profiles.configure').at(-1)
+    const uiMeta = (configure?.params.ui_meta as Record<string, Record<string, unknown>>)['hermes-bots']
+
+    expect(uiMeta.title).toBe('Researcher (copy)')
+    expect(uiMeta.chat).toBeUndefined()
+    expect(uiMeta.created).toBeUndefined()
+  })
+
+  it('duplicates the look of a bot that never had a pointer', async () => {
+    $botMeta.set({ painter: { color: '#38bdf8', shape: 'cloud', title: 'Painter' } })
+
+    const name = await duplicateBot({ name: 'painter' } as RosterRow, [{ name: 'painter' } as RosterRow])
+
+    expect($botMeta.get()[name]).toMatchObject({ shape: 'cloud', title: 'Painter (copy)' })
+    expect($botMeta.get()[name].chat).toBeUndefined()
+  })
+
+  it('walks past taken suffixes to the first free slot', async () => {
+    const roster = ['ops', 'ops-2', 'ops-3'].map(name => ({ name }) as RosterRow)
+
+    expect(await duplicateBot({ name: 'ops' } as RosterRow, roster)).toBe('ops-4')
+  })
+
+  it('truncates the BASE so a max-length name still gets a distinct suffix (#19)', async () => {
+    const base = 'b'.repeat(64)
+
+    const name = await duplicateBot({ name: base } as RosterRow, [{ name: base } as RosterRow])
+
+    expect(name).toHaveLength(64)
+    expect(name.endsWith('-2')).toBe(true)
+    expect(name).not.toBe(base)
+  })
+
+  it('ensures the source bot has its metadata before cloning', async () => {
+    // clone_from copies the profile dir; the source's Bot Chat has to exist
+    // first or the clone inherits a half-built profile.
+    await duplicateBot({ name: 'ops' } as RosterRow, [])
+
+    expect(ensureBotMetadataMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('only collides against rows on the SAME connection', async () => {
+    // A same-named bot on another gateway is a different agent entirely.
+    const bot = {
+      connectionId: 'vera',
+      name: 'ops',
+      route: { connectionId: 'vera', mode: 'remote', profile: 'ops', targetProfile: 'ops' },
+      sourceScoped: true
+    } as RosterRow
+
+    const elsewhere = {
+      connectionId: 'other',
+      name: 'ops-2',
+      route: { connectionId: 'other', mode: 'remote', profile: 'ops-2', targetProfile: 'ops-2' },
+      sourceScoped: true
+    } as RosterRow
+
+    hostMock.requestProfile.mockResolvedValue({ ok: true })
+
+    expect(await duplicateBot(bot, [bot, elsewhere])).toBe('ops-2')
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/profile-ops.ts b/apps/desktop/src/plugins/hermes-bots/profile-ops.ts
new file mode 100644
index 000000000000..033548f6b790
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/profile-ops.ts
@@ -0,0 +1,459 @@
+/**
+ * The profile operations that reach the gateway rather than the screen:
+ * two-way avatar sync, duplicate, and delete.
+ *
+ * They sit below every surface because both the roster and the create dialog
+ * drive them — the dialog deletes its own draft profile on cancel, the roster
+ * deletes for real — and neither can own them without the other importing a
+ * surface.
+ */
+
+import { forgetSessionUnread, host, queryClient } from '@hermes/plugin-sdk'
+
+import { isBackfilledFacePng } from './avatar-image'
+import {
+  $focusedBotOwner,
+  $openBotChat,
+  $selectedBot,
+  clearSelectedRosterBot,
+  focusedRosterOwner,
+  rosterWatermarks
+} from './bot-state'
+import { ensureBotMetadata } from './canonical-chat'
+import {
+  $botMeta,
+  BOT_META_V1_KEY,
+  botMetaKey,
+  botMetaWriteAt,
+  botRosterKey,
+  botSelectionKey,
+  commitBotMetaV2,
+  isDefaultBot,
+  persistBotMetaSnapshot,
+  ROSTER_KEY,
+  saveBotMeta
+} from './data'
+import { botConnectionRoute, botRouteKey, requestForBot } from './routing'
+import { getPluginCtx } from './shared'
+import type { RosterRow } from './types'
+
+const avatarFetchInflight = new Set<string>()
+const avatarPushInflight = new Set<string>()
+
+/** Backfill: local meta has art the server lacks -> profiles.set_asset.
+ *  Server-side avatars power the inter-agent notice pfp (core #85855) and
+ *  cross-machine roster art, so local-only images are a bug, not a state. */
+function pushLocalAvatars(roster: RosterRow[]) {
+  for (const bot of roster) {
+    const key = botMetaKey(bot)
+
+    if (bot.has_avatar || avatarPushInflight.has(key)) {
+      continue
+    }
+
+    const image = $botMeta.get()[key]?.image
+
+    if (image && typeof image === 'string' && image.startsWith('data:')) {
+      avatarPushInflight.add(key)
+
+      const request = bot.sourceScoped
+        ? requestForBot(bot, 'profiles.set_asset', {
+            name: bot.name,
+            asset: 'avatar',
+            data: image
+          })
+        : host.request('profiles.set_asset', {
+            name: bot.name,
+            asset: 'avatar',
+            data: image
+          })
+
+      Promise.resolve(request)
+        .then(() =>
+          queryClient.invalidateQueries({
+            queryKey: ['hermes-bots', 'roster']
+          })
+        )
+        .catch(() => avatarPushInflight.delete(key))
+
+      continue
+    }
+
+    // Vector shape/color face: no image exists anywhere — rasterize the
+    // live SVG (tagged data-bot-face) to a PNG and push that, so the
+    // inter-agent notices (core #85855/#85888) can show the real pfp.
+    const svg = document.querySelector('svg[data-bot-face=' + JSON.stringify(bot.name) + ']')
+
+    if (!svg) {
+      continue
+    }
+
+    avatarPushInflight.add(key)
+    rasterizeSvgToPng(svg, 160)
+      .then(png =>
+        png
+          ? (bot.sourceScoped
+              ? requestForBot(bot, 'profiles.set_asset', {
+                  name: bot.name,
+                  asset: 'avatar',
+                  data: png
+                })
+              : host.request('profiles.set_asset', {
+                  name: bot.name,
+                  asset: 'avatar',
+                  data: png
+                })
+            ).then(() =>
+              queryClient.invalidateQueries({
+                queryKey: ['hermes-bots', 'roster']
+              })
+            )
+          : Promise.reject(new Error('rasterize failed'))
+      )
+      .catch(() => avatarPushInflight.delete(key))
+  }
+}
+
+/** Serialize an inline SVG and draw it to a canvas -> PNG data URL. */
+function rasterizeSvgToPng(svgEl: Element, size: number): Promise<null | string> {
+  return new Promise(resolve => {
+    try {
+      // `Node.cloneNode` is declared to return `Node`, which has no
+      // setAttribute — the clone of an Element is always an Element.
+      const clone = svgEl.cloneNode(true) as Element
+      clone.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
+      clone.setAttribute('width', String(size))
+      clone.setAttribute('height', String(size))
+      const markup = new XMLSerializer().serializeToString(clone)
+      const url = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(markup)
+      const img = new Image()
+
+      img.onload = () => {
+        try {
+          const canvas = document.createElement('canvas')
+          canvas.width = size
+          canvas.height = size
+          // A null 2d context throws here on purpose: the catch below resolves
+          // null, which is the same "no raster" answer the caller expects.
+          canvas.getContext('2d')!.drawImage(img, 0, 0, size, size)
+          resolve(canvas.toDataURL('image/png'))
+        } catch {
+          resolve(null)
+        }
+      }
+
+      img.onerror = () => resolve(null)
+      img.src = url
+    } catch {
+      resolve(null)
+    }
+  })
+}
+
+/** `profiles.get_asset` reply for the `avatar` asset. */
+interface ProfilesGetAssetResult {
+  /** Data URL. */
+  data?: string
+  found?: boolean
+}
+
+/** Fetch server-side avatars for roster rows flagged has_avatar when the
+ *  local cache doesn't already have an image for them. Fire-and-forget. */
+export function pullServerAvatars(roster: RosterRow[]) {
+  pushLocalAvatars(roster)
+
+  for (const bot of roster) {
+    const key = botMetaKey(bot)
+
+    if (!bot.has_avatar || avatarFetchInflight.has(key)) {
+      continue
+    }
+
+    if ($botMeta.get()[key]?.image) {
+      continue
+    }
+
+    avatarFetchInflight.add(key)
+
+    const assetRequest = bot.sourceScoped
+      ? requestForBot(bot, 'profiles.get_asset', {
+          name: bot.name,
+          asset: 'avatar'
+        })
+      : host.request('profiles.get_asset', {
+          name: bot.name,
+          asset: 'avatar'
+        })
+
+    Promise.resolve(assetRequest as Promise<ProfilesGetAssetResult>)
+      .then(res => {
+        if (res?.found && res.data) {
+          const current = $botMeta.get()
+          const mine = current[key] || {}
+
+          // A 160px raster of the vector face is only for inter-agent
+          // notices. Do not park it on the roster or the live face dies.
+          if (isBackfilledFacePng(res.data) && mine.imageKind !== 'photo' && !mine.pet) {
+            return
+          }
+
+          $botMeta.set({
+            ...current,
+            [key]: {
+              ...mine,
+              image: res.data
+            }
+          })
+          persistBotMetaSnapshot($botMeta.get(), Boolean(bot.sourceScoped))
+        }
+      })
+      .catch(() => undefined)
+      .finally(() => avatarFetchInflight.delete(key))
+  }
+}
+
+/** Server ui_meta (per roster row) beats local storage for the compact
+ *  fields it carries; local-only fields (avatar image data URL, extracted
+ *  pet icon) are PRESERVED — the server copy never includes them, so a
+ *  naive replace would wipe a just-saved image avatar on the next roster
+ *  paint. When server bot metadata exists, an omitted chat is authoritative
+ *  deletion; local still fills all gaps for older gateways with no metadata.
+ *
+ *  `fetchedAt` (the snapshot's issue time) fences the overlay: a bot whose
+ *  local meta was written AFTER the snapshot was fetched is skipped — that
+ *  snapshot's ui_meta predates the write, and spreading it back over local
+ *  meta resurrects state the user just changed (a disbanded group's
+ *  membership reappearing as an empty roster row, a rename reverting, an
+ *  unpin undoing). The next roster fetch post-dates the write and overlays
+ *  normally, so server truth still gets the last word. */
+export function mergeServerMeta(roster: RosterRow[], fetchedAt = 0) {
+  const local = $botMeta.get()
+  let changed = false
+
+  const next = {
+    ...local
+  }
+
+  for (const bot of roster) {
+    const server = bot.ui_meta?.['hermes-bots']
+
+    if (server && typeof server === 'object') {
+      const key = botMetaKey(bot)
+
+      if (fetchedAt && fetchedAt < (botMetaWriteAt.get(key) || 0)) {
+        continue
+      }
+
+      const mine = next[key] || {}
+
+      const merged = {
+        ...mine,
+        ...server
+      }
+
+      // Local-only fields survive the server overlay.
+      if (mine.image) {
+        merged.image = mine.image
+      }
+
+      // Legacy canonical-chat pointers (meta.chat) are dead: identity is the
+      // profile's "Bot Chat" registry row, resolved by name. Drop the key on
+      // sight so old ui_meta can never look meaningful again.
+      delete merged.chat
+
+      // Canonical multi-group metadata is authoritative for the compatibility
+      // scalar too. A server-side `group: null` is represented by omission,
+      // so retaining the local scalar would resurrect a membership that another
+      // desktop just removed.
+      if (
+        Array.isArray(server.groups) &&
+        Object.prototype.hasOwnProperty.call(mine, 'group') &&
+        !Object.prototype.hasOwnProperty.call(server, 'group')
+      ) {
+        delete merged.group
+      }
+
+      if (JSON.stringify(next[key] || null) !== JSON.stringify(merged)) {
+        next[key] = merged
+        changed = true
+      }
+    }
+  }
+
+  if (changed) {
+    $botMeta.set(next)
+
+    // Persist server reconciliation so a relaunch cannot rehydrate stale
+    // local fields that the server intentionally removed.
+    try {
+      persistBotMetaSnapshot(
+        next,
+        roster.some(bot => bot.sourceScoped)
+      )
+    } catch {
+      /* storage unavailable — reconciliation lasts for this window only */
+    }
+  }
+}
+
+/** Clone a bot: profile (config/skills/SOUL/memory via clone_from) + look.
+ *  Name is "<base>-2", "-3", … — first free slot against the live roster. */
+export async function duplicateBot(bot: RosterRow, roster: RosterRow[]) {
+  await ensureBotMetadata(bot)
+  const base = bot.name
+  const ownerRoute = botConnectionRoute(bot)
+  const ownerKey = ownerRoute ? botRouteKey(ownerRoute) : null
+  let name = null
+
+  for (let n = 2; n < 100; n++) {
+    // Truncate the BASE, never the suffix — slicing the joined string chops
+    // the "-2" off a max-length name and the candidate collides with the
+    // base forever (#19).
+    const suffix = `-${n}`
+    const candidate = base.slice(0, 64 - suffix.length) + suffix
+
+    if (
+      !roster.some(
+        // A truthy ownerKey is minted from ownerRoute, so the route is present
+        // on every path that reads it — a correlation TS can't follow.
+        b => b.name === candidate && (!ownerKey || botMetaKey(b)?.startsWith(`${ownerRoute!.connectionId}::`))
+      )
+    ) {
+      name = candidate
+
+      break
+    }
+  }
+
+  if (!name) {
+    throw new Error('No free name for the duplicate.')
+  }
+
+  await requestForBot(bot, 'profiles.create', {
+    name,
+    clone_from: base,
+    description: bot.description || ''
+  })
+
+  // Same look: avatar shape/color/image and a "(copy)" title so the two
+  // are tellable apart in the roster until the user renames. Do not copy
+  // chat or created. Those belong to the original bot.
+  const meta = $botMeta.get()[botMetaKey(bot)]
+
+  if (meta) {
+    const { chat, created, ...look } = meta
+    await saveBotMeta(
+      {
+        ...bot,
+        name,
+        // TODO(bot-mode-types): botConnectionRoute() returns null for an unrouted bot, so this
+        // synthesized row can carry `route: null`, which RosterRow['route'] (ProfileRoute |
+        // undefined) does not admit. Benign at runtime — every read of it is optional-chained —
+        // but the assertion below is covering for a domain type that is too narrow.
+        route: ownerRoute,
+        sourceScoped: Boolean(ownerRoute)
+      } as RosterRow,
+      {
+        ...look,
+        title: meta.title ? `${meta.title} (copy)` : ''
+      }
+    )
+  }
+
+  return name
+}
+
+/** `cli.exec` reply, as the legacy delete path reads it. */
+interface CliExecResult {
+  blocked?: boolean
+  code?: number
+  hint?: string
+  output?: string
+}
+
+/** Permanently delete a bot's Hermes profile, then remove plugin-local state
+ * that would otherwise leave stale appearance/unread data behind.
+ *
+ * Prefer the SDK's `host.deleteProfile` when this Desktop build ships it: it
+ * routes through the Electron-intercepted REST delete, which tears down the
+ * bot's pool backend FIRST and routes the next request away from it. The
+ * older `cli.exec` path bypasses that interception, so a backend that the
+ * roster's hover pre-warm just woke (right-click hovers the row!) holds the
+ * profile dir open — the CLI's rmtree races the live backend and the
+ * renderer's socket reconnect respawns it mid-delete, resurrecting the
+ * directory (hermes-agent#52279). That is the "can't delete a bot" error. */
+export async function deleteBot(bot: RosterRow) {
+  const route = botConnectionRoute(bot)
+
+  if (isDefaultBot(bot) || String(route?.targetProfile || '').toLowerCase() === 'default') {
+    throw new Error('The default profile cannot be deleted.')
+  }
+
+  if (typeof host.deleteProfile === 'function') {
+    if (route) {
+      await host.deleteProfile(route)
+    } else {
+      await host.deleteProfile(bot.name)
+    }
+  } else {
+    // Older desktop without the SDK verb — source-scoped rows fail closed.
+    if (route) {
+      throw new Error('Source-scoped profile deletion requires host.deleteProfile.')
+    }
+
+    const result: CliExecResult = await host.request('cli.exec', {
+      argv: ['profile', 'delete', bot.name, '--yes']
+    })
+
+    if (result?.blocked || result?.code !== 0) {
+      throw new Error(result?.hint || result?.output || `Could not delete profile ${bot.name}.`)
+    }
+  }
+
+  const meta = {
+    ...$botMeta.get()
+  }
+
+  delete meta[botMetaKey(bot)]
+  $botMeta.set(meta)
+
+  try {
+    if (route) {
+      await commitBotMetaV2(getPluginCtx()?.storage, meta)
+    } else {
+      await Promise.resolve(getPluginCtx()?.storage?.set?.(BOT_META_V1_KEY, meta))
+    }
+  } catch {
+    /* profile is deleted; stale local appearance is harmless if storage fails */
+  }
+
+  // Both ids: the marker may have been filed under either tip of the chat's
+  // compression lineage.
+  forgetSessionUnread([bot.canonical_session?.id, bot.canonical_session?.resolved_id], bot.name)
+  rosterWatermarks.delete(botSelectionKey(bot))
+  avatarFetchInflight.delete(botMetaKey(bot))
+  avatarPushInflight.delete(botMetaKey(bot))
+
+  if ($selectedBot.get() === botSelectionKey(bot)) {
+    $selectedBot.set('default')
+  }
+
+  clearSelectedRosterBot(bot)
+
+  if ($openBotChat.get()?.key === botRosterKey(bot)) {
+    $openBotChat.set(null)
+  }
+
+  queryClient.invalidateQueries({
+    queryKey: ROSTER_KEY
+  })
+  const activeOwner = focusedRosterOwner($focusedBotOwner.get?.())
+
+  const deletedOwnerIsActive = route
+    ? activeOwner?.connectionId === route.connectionId && activeOwner?.name === route.profile
+    : activeOwner?.name === bot.name
+
+  if (deletedOwnerIsActive && typeof host.newChat === 'function') {
+    host.newChat('default')
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/relay.test.ts b/apps/desktop/src/plugins/hermes-bots/relay.test.ts
new file mode 100644
index 000000000000..55ba196b35d8
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/relay.test.ts
@@ -0,0 +1,649 @@
+/**
+ * The cross-connection bot relay — the Desktop-as-router loops that let a bot
+ * on one gateway reach a bot on another (Aug 2026 ruling: connections ARE the
+ * peer set).
+ *
+ * Three incidents are pinned here:
+ *
+ *  - #93091 — the drain was poll-only, so a DM waited out the interval before
+ *    it moved (#92760 "slow replies"). The gateway now broadcasts
+ *    `bot_relay.outbox.pending`; a burst of signals collapses to ONE drain,
+ *    a push landing mid-drain re-schedules instead of being swallowed, and
+ *    the interval survives as a BACKSTOP only. Item 2 of the same issue: a
+ *    transient `profiles.list` blip must not be pushed as "that machine is
+ *    empty" — the gateway reads absence from a fresh roster as offline.
+ *  - #93594 — each registered connection's pooled socket is pinned open while
+ *    the relay runs, so the drain reuses one persistent WebSocket instead of
+ *    dialing and tearing one down per tick.
+ *  - the waiter contract — a missing target connection must still post a reply,
+ *    or the sending agent hangs until its own timeout.
+ *
+ * Everything is driven through the two real lifecycle doors, `startBotRelay` /
+ * `stopBotRelay`; only the SDK `host` and the attention hooks are mocked.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { ProfileRoute } from './types'
+
+const { clearBotAttentionMock, hostMock, noteBotAttentionMock, UnboundedCache } = vi.hoisted(() => ({
+  clearBotAttentionMock: vi.fn(),
+  hostMock: {
+    onEvent: vi.fn(),
+    profileRoutes: vi.fn(),
+    requestProfile: vi.fn(),
+    retainProfileSocket: vi.fn()
+  } as Record<string, unknown>,
+  noteBotAttentionMock: vi.fn(),
+  // Stand-in for the SDK's LruCache. Its ceiling has its own unit test and no
+  // fixture here approaches it, so the double just drops the bound.
+  UnboundedCache: class extends Map {
+    constructor(_max: number) {
+      super()
+    }
+  }
+}))
+
+vi.mock('@hermes/plugin-sdk', () => ({ host: hostMock, LruCache: UnboundedCache }))
+
+vi.mock('./data', () => ({
+  botHandle: (name: string) => (name === 'default' ? 'hermes' : name),
+  clearBotAttention: clearBotAttentionMock,
+  noteBotAttention: noteBotAttentionMock
+}))
+
+const RELAY_PUSH_DEBOUNCE_MS = 250
+const RELAY_DRAIN_INTERVAL_MS = 30_000
+
+const route = (id: string): ProfileRoute => ({
+  connectionId: id,
+  mode: 'remote',
+  profile: 'default',
+  targetProfile: 'default'
+})
+
+/** Every RPC through one table, recording what each connection was asked. */
+interface RelayCall {
+  connectionId: string
+  method: string
+  params: Record<string, unknown>
+}
+
+function respondWith(handler: (call: RelayCall) => unknown) {
+  const calls: RelayCall[] = []
+
+  ;(hostMock.requestProfile as ReturnType<typeof vi.fn>).mockImplementation(
+    async (target: ProfileRoute, method: string, params: Record<string, unknown>) => {
+      const call = { connectionId: target.connectionId, method, params: structuredClone(params ?? {}) }
+
+      calls.push(call)
+
+      return handler(call)
+    }
+  )
+
+  return calls
+}
+
+/** Pins handed out by the mocked retention door, in grant order. */
+interface Pin {
+  released: boolean
+  route: ProfileRoute
+}
+
+function trackRetention() {
+  const pins: Pin[] = []
+
+  ;(hostMock.retainProfileSocket as ReturnType<typeof vi.fn>).mockImplementation((pinned: ProfileRoute) => {
+    const pin: Pin = { released: false, route: pinned }
+
+    pins.push(pin)
+
+    return () => {
+      pin.released = true
+    }
+  })
+
+  return pins
+}
+
+async function loadRelay() {
+  vi.resetModules()
+
+  return import('./relay')
+}
+
+/** Fire the gateway's pending-envelope broadcast and let the debounced drain
+ *  run to completion. */
+async function pushAndSettle(times = 1) {
+  const listener = (hostMock.onEvent as ReturnType<typeof vi.fn>).mock.calls.at(-1)?.[1] as () => void
+
+  for (let i = 0; i < times; i += 1) {
+    listener()
+  }
+
+  await vi.advanceTimersByTimeAsync(RELAY_PUSH_DEBOUNCE_MS + 10)
+}
+
+beforeEach(() => {
+  vi.useFakeTimers()
+  vi.clearAllMocks()
+  hostMock.onEvent = vi.fn(() => vi.fn())
+  hostMock.profileRoutes = vi.fn(async () => [route('a'), route('b')])
+  hostMock.requestProfile = vi.fn(async () => ({}))
+  hostMock.retainProfileSocket = vi.fn(() => vi.fn())
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('push-notified drain (#93091)', () => {
+  it('collapses a burst of pending signals into ONE drain', async () => {
+    const calls = respondWith(() => ({ envelopes: [] }))
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+    calls.length = 0
+
+    await pushAndSettle(6)
+
+    // One drain visits each connection's outbox exactly once.
+    expect(calls.filter(call => call.method === 'bot_relay.outbox.drain')).toHaveLength(2)
+
+    stopBotRelay()
+  })
+
+  it('drains again for a signal that lands after the window closed', async () => {
+    const calls = respondWith(() => ({ envelopes: [] }))
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+    calls.length = 0
+
+    await pushAndSettle()
+    await pushAndSettle(2)
+
+    expect(calls.filter(call => call.method === 'bot_relay.outbox.drain')).toHaveLength(4)
+
+    stopBotRelay()
+  })
+
+  it('keeps the interval poll as a BACKSTOP at the slow cadence', async () => {
+    // The poll was 4s back when it WAS the delivery path — which (before
+    // route retention) meant a fresh WebSocket dial + teardown per connection
+    // every 4s. Push carries envelope latency now; the poll only covers older
+    // backends and events that never reach the tap.
+    const calls = respondWith(() => ({ envelopes: [] }))
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+    calls.length = 0
+
+    await vi.advanceTimersByTimeAsync(RELAY_DRAIN_INTERVAL_MS - 1000)
+
+    expect(calls.filter(call => call.method === 'bot_relay.outbox.drain')).toHaveLength(0)
+
+    await vi.advanceTimersByTimeAsync(2000)
+
+    expect(calls.filter(call => call.method === 'bot_relay.outbox.drain')).toHaveLength(2)
+
+    stopBotRelay()
+  })
+
+  it('re-schedules a push that raced an in-flight drain instead of dropping it', async () => {
+    // The gateway signature is monotone — one event per new envelope, never
+    // re-broadcast — so a push swallowed by the busy guard would strand its
+    // envelope until the poll.
+    let release!: () => void
+
+    const firstDrain = new Promise<void>(resolve => {
+      release = resolve
+    })
+
+    let drains = 0
+
+    const calls = respondWith(async call => {
+      if (call.method === 'bot_relay.outbox.drain') {
+        drains += 1
+
+        if (drains === 1) {
+          await firstDrain
+        }
+      }
+
+      return { envelopes: [] }
+    })
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+    calls.length = 0
+
+    await pushAndSettle()
+    const midFlight = drains
+
+    // A second push while the first drain is still awaiting its RPC.
+    await pushAndSettle()
+    expect(drains).toBe(midFlight)
+
+    release()
+    await vi.advanceTimersByTimeAsync(RELAY_PUSH_DEBOUNCE_MS + 10)
+
+    expect(drains).toBeGreaterThan(midFlight)
+
+    stopBotRelay()
+  })
+
+  it('never schedules a drain once the relay is stopped', async () => {
+    const calls = respondWith(() => ({ envelopes: [] }))
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+    stopBotRelay()
+    calls.length = 0
+
+    await pushAndSettle(3)
+    await vi.advanceTimersByTimeAsync(RELAY_DRAIN_INTERVAL_MS * 2)
+
+    expect(calls).toHaveLength(0)
+  })
+
+  it('feature-detects the event door and disposes its subscription', async () => {
+    const unsubscribe = vi.fn()
+
+    hostMock.onEvent = vi.fn(() => unsubscribe)
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    expect(hostMock.onEvent).toHaveBeenCalledWith('bot_relay.outbox.pending', expect.any(Function))
+
+    stopBotRelay()
+    expect(unsubscribe).toHaveBeenCalledTimes(1)
+
+    // An older shell has no event door at all; the relay still starts.
+    hostMock.onEvent = undefined
+    const legacy = await loadRelay()
+
+    expect(() => legacy.startBotRelay()).not.toThrow()
+    legacy.stopBotRelay()
+  })
+})
+
+describe('relay-route socket retention (#93594)', () => {
+  it('pins each connection ONCE across many drain ticks', async () => {
+    const pins = trackRetention()
+
+    respondWith(() => ({ envelopes: [] }))
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+
+    for (let tick = 0; tick < 4; tick += 1) {
+      await pushAndSettle()
+    }
+
+    expect(pins.map(pin => pin.route.connectionId)).toEqual(['a', 'b'])
+    expect(pins.every(pin => !pin.released)).toBe(true)
+
+    stopBotRelay()
+  })
+
+  it('releases exactly the pin of a connection that left the registry', async () => {
+    const pins = trackRetention()
+
+    respondWith(() => ({ envelopes: [] }))
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await pushAndSettle()
+
+    hostMock.profileRoutes = vi.fn(async () => [route('a'), route('c')])
+    await pushAndSettle()
+
+    expect(pins.filter(pin => pin.released).map(pin => pin.route.connectionId)).toEqual(['b'])
+    expect(pins.map(pin => pin.route.connectionId)).toEqual(['a', 'b', 'c'])
+
+    stopBotRelay()
+  })
+
+  it('drops every pin on stop, and stays idempotent', async () => {
+    const pins = trackRetention()
+
+    respondWith(() => ({ envelopes: [] }))
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await pushAndSettle()
+    stopBotRelay()
+
+    expect(pins.every(pin => pin.released)).toBe(true)
+
+    // A second stop releases nothing new — the pins are already gone.
+    const releasedCount = pins.filter(pin => pin.released).length
+
+    stopBotRelay()
+    expect(pins.filter(pin => pin.released)).toHaveLength(releasedCount)
+  })
+
+  it('unpins everything when the peer set drops below two connections', async () => {
+    // Retention follows the relay-ELIGIBLE set: with nothing to relay,
+    // nothing stays pinned.
+    const pins = trackRetention()
+
+    respondWith(() => ({ envelopes: [] }))
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await pushAndSettle()
+    expect(pins).toHaveLength(2)
+
+    hostMock.profileRoutes = vi.fn(async () => [route('a')])
+    await pushAndSettle()
+
+    expect(pins.every(pin => pin.released)).toBe(true)
+
+    stopBotRelay()
+  })
+
+  it('is feature-detected: an older shell without the door is a no-op', async () => {
+    hostMock.retainProfileSocket = undefined
+
+    respondWith(() => ({ envelopes: [] }))
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await expect(pushAndSettle()).resolves.toBeUndefined()
+
+    stopBotRelay()
+  })
+})
+
+describe('the roster loop pushes the OTHER connections’ agents', () => {
+  it('gives each gateway a union roster that excludes its own agents', async () => {
+    const calls = respondWith(call => {
+      if (call.method === 'profiles.list') {
+        return { profiles: [{ name: call.connectionId === 'a' ? 'default' : 'ops' }] }
+      }
+
+      return {}
+    })
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+
+    const syncs = calls.filter(call => call.method === 'bot_relay.roster.sync')
+
+    expect(syncs.map(call => call.connectionId)).toEqual(['a', 'b'])
+    expect(syncs[0].params.agents).toEqual([
+      expect.objectContaining({ connection_id: 'b', handle: 'ops', profile: 'ops' })
+    ])
+    // The primary profile is published by its callable alias, never "default".
+    expect(syncs[1].params.agents).toEqual([
+      expect.objectContaining({ connection_id: 'a', handle: 'hermes', profile: 'default' })
+    ])
+
+    stopBotRelay()
+  })
+
+  it('never conflates a transient fetch failure with an empty connection', async () => {
+    // A live machine whose profiles.list blips must not be pushed as absent:
+    // the gateway-side liveness check reads "absent from a fresh roster" as
+    // definitively offline and refuses enqueues with a false runtime_offline
+    // (#93091 item 2).
+    let failB = false
+
+    const calls = respondWith(call => {
+      if (call.method === 'profiles.list') {
+        if (call.connectionId === 'b' && failB) {
+          throw new Error('socket blip')
+        }
+
+        return { profiles: [{ name: call.connectionId === 'a' ? 'default' : 'ops' }] }
+      }
+
+      return {}
+    })
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+    calls.length = 0
+
+    failB = true
+    await vi.advanceTimersByTimeAsync(60_000)
+
+    const pushedToA = calls.find(call => call.method === 'bot_relay.roster.sync' && call.connectionId === 'a')
+
+    expect(pushedToA?.params.agents).toEqual([expect.objectContaining({ profile: 'ops' })])
+
+    stopBotRelay()
+  })
+
+  it('drops the cached rows of a connection that genuinely disconnected', async () => {
+    const calls = respondWith(call =>
+      call.method === 'profiles.list' ? { profiles: [{ name: call.connectionId }] } : {}
+    )
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+
+    // 'b' leaves the registry and 'c' arrives: b's agents must not linger.
+    hostMock.profileRoutes = vi.fn(async () => [route('a'), route('c')])
+    calls.length = 0
+    await vi.advanceTimersByTimeAsync(60_000)
+
+    const pushedToA = calls.find(call => call.method === 'bot_relay.roster.sync' && call.connectionId === 'a')
+
+    expect(pushedToA?.params.agents).toEqual([expect.objectContaining({ profile: 'c' })])
+
+    stopBotRelay()
+  })
+
+  it('stays quiet with a single connection — there is no peer to relay to', async () => {
+    hostMock.profileRoutes = vi.fn(async () => [route('a')])
+
+    const calls = respondWith(() => ({}))
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(calls).toHaveLength(0)
+
+    stopBotRelay()
+  })
+})
+
+describe('the drain loop wires drain → deliver → reply', () => {
+  const envelope = {
+    id: 'env-1',
+    message: 'status?',
+    target_connection: 'b',
+    target_profile: 'ops'
+  }
+
+  it('delivers on the target’s own socket and posts the reply to the sender', async () => {
+    const calls = respondWith(call => {
+      if (call.method === 'bot_relay.outbox.drain') {
+        return { envelopes: call.connectionId === 'a' ? [envelope] : [] }
+      }
+
+      if (call.method === 'bot_relay.deliver') {
+        return { reply: 'all green' }
+      }
+
+      return {}
+    })
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await pushAndSettle()
+
+    expect(calls.find(call => call.method === 'bot_relay.deliver')).toMatchObject({
+      connectionId: 'b',
+      params: { message: 'status?', profile: 'ops' }
+    })
+    expect(calls.find(call => call.method === 'bot_relay.reply')).toMatchObject({
+      connectionId: 'a',
+      params: { id: 'env-1', reply: 'all green' }
+    })
+    // A delivered background DM is this bot's "good turn".
+    expect(clearBotAttentionMock).toHaveBeenCalledWith('b::ops')
+
+    stopBotRelay()
+  })
+
+  it('still posts a reply when the target connection is gone — the waiter must never dangle', async () => {
+    const calls = respondWith(call =>
+      call.method === 'bot_relay.outbox.drain'
+        ? { envelopes: call.connectionId === 'a' ? [{ ...envelope, target_connection: 'ghost' }] : [] }
+        : {}
+    )
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await pushAndSettle()
+
+    expect(calls.some(call => call.method === 'bot_relay.deliver')).toBe(false)
+    expect(calls.find(call => call.method === 'bot_relay.reply')?.params.error).toMatch(
+      /'ghost' is not connected to this Desktop right now/
+    )
+
+    stopBotRelay()
+  })
+
+  it('forwards the gateway’s typed failure reason to both the reply and the badge', async () => {
+    // #93091: bot_relay.deliver classifies the failed turn and ships the code
+    // in `data.reason`; a classified code beats re-parsing free text.
+    const failure = Object.assign(new Error('401 invalid x-api-key'), {
+      data: { reason: 'provider_auth_or_access' }
+    })
+
+    const calls = respondWith(call => {
+      if (call.method === 'bot_relay.outbox.drain') {
+        return { envelopes: call.connectionId === 'a' ? [envelope] : [] }
+      }
+
+      if (call.method === 'bot_relay.deliver') {
+        throw failure
+      }
+
+      return {}
+    })
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await pushAndSettle()
+
+    expect(calls.find(call => call.method === 'bot_relay.reply')?.params).toMatchObject({
+      error: '401 invalid x-api-key',
+      id: 'env-1',
+      reason: 'provider_auth_or_access'
+    })
+    expect(noteBotAttentionMock).toHaveBeenCalledWith('b::ops', 'provider_auth_or_access')
+
+    stopBotRelay()
+  })
+
+  it('skips an older backend that rejects the drain RPC, and keeps going', async () => {
+    const calls = respondWith(call => {
+      if (call.method === 'bot_relay.outbox.drain') {
+        if (call.connectionId === 'a') {
+          throw new Error('unknown method')
+        }
+
+        return { envelopes: [] }
+      }
+
+      return {}
+    })
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await pushAndSettle()
+
+    expect(calls.filter(call => call.method === 'bot_relay.outbox.drain').map(call => call.connectionId)).toEqual([
+      'a',
+      'b'
+    ])
+
+    stopBotRelay()
+  })
+})
+
+describe('stop halts both loops', () => {
+  it('leaves no timer able to reach the gateway after teardown', async () => {
+    const calls = respondWith(() => ({ envelopes: [] }))
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(0)
+    stopBotRelay()
+    calls.length = 0
+
+    await vi.advanceTimersByTimeAsync(5 * 60_000)
+
+    expect(calls).toHaveLength(0)
+  })
+
+  it('does not leak a mid-drain rerun into the next start', async () => {
+    let release!: () => void
+
+    const held = new Promise<void>(resolve => {
+      release = resolve
+    })
+
+    let drains = 0
+
+    respondWith(async call => {
+      if (call.method === 'bot_relay.outbox.drain') {
+        drains += 1
+
+        if (drains === 1) {
+          await held
+        }
+      }
+
+      return { envelopes: [] }
+    })
+
+    const { startBotRelay, stopBotRelay } = await loadRelay()
+
+    startBotRelay()
+    await pushAndSettle()
+    await pushAndSettle()
+    stopBotRelay()
+    release()
+    await vi.advanceTimersByTimeAsync(RELAY_PUSH_DEBOUNCE_MS + 10)
+
+    const afterStop = drains
+
+    startBotRelay()
+    await vi.advanceTimersByTimeAsync(RELAY_PUSH_DEBOUNCE_MS + 10)
+
+    expect(drains).toBe(afterStop)
+
+    stopBotRelay()
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/relay.ts b/apps/desktop/src/plugins/hermes-bots/relay.ts
new file mode 100644
index 000000000000..47ac5aa4d8c6
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/relay.ts
@@ -0,0 +1,485 @@
+/**
+ * The cross-connection bot relay: the Desktop-as-router loops that let a bot
+ * on one gateway reach a bot on another.
+ *
+ * There is one relay per renderer, so its lifecycle lives in the module-scoped
+ * `relay` record below rather than in an atom — no UI reads it. plugin.tsx
+ * drives the two doors, startBotRelay / stopBotRelay.
+ */
+
+import { host, LruCache } from '@hermes/plugin-sdk'
+
+import { botHandle, clearBotAttention, noteBotAttention } from './data'
+import type { ProfileRoute, RosterRow } from './types'
+
+// ── cross-connection bot relay ────────────────────────────────────────────
+// Connections ARE the peer set: every gateway this Desktop holds a socket
+// to (local, remote URL, SSH, Hermes Cloud, docker) must be able to find
+// every other connection's agents and message them via message_agent. The
+// Desktop is the relay — it owns every socket. Two loops:
+//  - roster loop: pushes each gateway the union roster of agents on the
+//    OTHER connections (bot_relay.roster.sync), so message_agent resolves
+//    cross-connection targets and Bot Chat prompts list them;
+//  - drain loop: collects queued envelopes from every gateway
+//    (bot_relay.outbox.drain), delivers each on the target connection's
+//    own socket (bot_relay.deliver), and posts the reply back to the
+//    sender gateway (bot_relay.reply) where a waiter wakes the sender.
+// Older backends without the RPCs fail per-call and are skipped — the
+// relay degrades to whatever subset of connections supports it.
+const RELAY_ROSTER_INTERVAL_MS = 60_000
+// Backstop cadence only (#93594): the push path below carries envelope latency,
+// so the interval poll exists for older backends and missed events — 30s
+// matches LIVE_SESSION_STATUS_BACKSTOP_INTERVAL_MS. It was 4s back when the
+// poll WAS the delivery path, which (before route retention) also meant a
+// fresh WebSocket dial + teardown per registered connection every 4s.
+const RELAY_DRAIN_INTERVAL_MS = 30_000
+// Push path (#93091): the gateway broadcasts `bot_relay.outbox.pending` when
+// an envelope lands on disk; a burst of signals inside this window collapses
+// to ONE drain. The interval poll above stays as the backstop for older
+// backends (and connections whose events don't reach the tap).
+const RELAY_PUSH_DEBOUNCE_MS = 250
+
+/** Everything the two loops mutate. */
+interface RelayLifecycle {
+  disposed: boolean
+  drainBusy: boolean
+  /** A push landing while a drain is ALREADY running would be lost forever —
+   *  the gateway signature is monotone (one event per new envelope, never
+   *  re-broadcast) — so remember it and re-schedule after the drain finishes. */
+  drainRerun: boolean
+  drainTimer: null | ReturnType<typeof setInterval>
+  pushDebounceTimer: null | ReturnType<typeof setTimeout>
+  pushUnsub: (() => void) | null
+  rosterBusy: boolean
+  rosterTimer: null | ReturnType<typeof setInterval>
+}
+
+const relay: RelayLifecycle = {
+  disposed: false,
+  drainBusy: false,
+  drainRerun: false,
+  drainTimer: null,
+  pushDebounceTimer: null,
+  pushUnsub: null,
+  rosterBusy: false,
+  rosterTimer: null
+}
+
+// Relay-route socket retention (#93594): connection id → release fn. While
+// the relay is active each registered connection's pooled socket is pinned
+// open (host.retainProfileSocket) so drain RPCs reuse ONE persistent
+// WebSocket instead of dialing and tearing down a fresh one per tick.
+// Feature-detected — older shells lack the door and fall back to per-call
+// leases. Local routes get a no-op release inside the host (idle-reaper
+// exemption). stopBotRelay releases everything.
+const relayRouteRetentions = new Map<string, () => void>()
+
+/** One reachable gateway plus a representative route onto it. The route comes
+ *  from `host.profileRoutes()`, which carries identity only — the optional
+ *  label fields are read defensively in relayAgentsOn and never arrive. */
+interface RelayConnection {
+  id: string
+  route: ProfileRoute & { connectionLabel?: string; label?: string }
+}
+
+/** One agent as pushed to a peer gateway's relay roster. */
+interface RelayAgentRow {
+  connection_id: string
+  connection_label: string
+  description: string
+  handle: string
+  profile: string
+  title: string
+}
+
+/** A queued cross-connection message drained from a gateway's outbox. */
+interface RelayEnvelope {
+  id?: string
+  message?: string
+  target_connection?: string
+  target_profile?: string
+}
+
+/** Reconcile retention with the CURRENT connection set: pin new connections,
+ *  release removed ones. Runs on every drain/roster connection fetch. */
+function syncRelayRetention(connections: RelayConnection[]) {
+  if (typeof host.retainProfileSocket !== 'function') {
+    return
+  }
+
+  const live = new Set(connections.map(connection => connection.id))
+
+  for (const [id, release] of [...relayRouteRetentions]) {
+    if (!live.has(id)) {
+      relayRouteRetentions.delete(id)
+
+      try {
+        release()
+      } catch {
+        // Never let a release failure break the relay loop.
+      }
+    }
+  }
+
+  if (relay.disposed) {
+    return
+  }
+
+  for (const connection of connections) {
+    if (!relayRouteRetentions.has(connection.id)) {
+      relayRouteRetentions.set(connection.id, host.retainProfileSocket(connection.route))
+    }
+  }
+}
+
+/** Drop every relay pin — stop/dispose path. */
+function releaseRelayRetention() {
+  for (const release of relayRouteRetentions.values()) {
+    try {
+      release()
+    } catch {
+      // Disposer from an older shell shape — never break teardown.
+    }
+  }
+
+  relayRouteRetentions.clear()
+}
+
+/** One representative route per reachable connection id. */
+async function relayConnections(): Promise<RelayConnection[]> {
+  if (typeof host.profileRoutes !== 'function' || typeof host.requestProfile !== 'function') {
+    return []
+  }
+
+  try {
+    const routes = await host.profileRoutes()
+    const byConnection = new Map<string, ProfileRoute>()
+
+    for (const route of Array.isArray(routes) ? routes : []) {
+      const id = String(route?.connectionId || '')
+
+      if (id && !byConnection.has(id)) {
+        byConnection.set(id, route)
+      }
+    }
+
+    return [...byConnection.entries()].map(([id, route]) => ({
+      id,
+      route
+    }))
+  } catch {
+    return []
+  }
+}
+
+/** The agents living on one connection, as relay roster rows.
+ *  Returns null on FAILURE (transient RPC blip, slow socket) — distinct from
+ *  a genuine empty profile list. Conflating the two would push a fresh union
+ *  roster missing a LIVE connection's agents, and the gateway-side liveness
+ *  check (bot_relay._target_liveness) reads "absent from a fresh roster" as
+ *  definitively offline → false runtime_offline refusals (#93091 item 2). */
+async function relayAgentsOn(connection: RelayConnection): Promise<RelayAgentRow[] | null> {
+  try {
+    const res = await host.requestProfile<{ profiles?: RosterRow[] }>(connection.route, 'profiles.list', {
+      include_sessions: false
+    })
+
+    const profiles = Array.isArray(res?.profiles) ? res.profiles : []
+    // TODO(bot-mode-types): neither `connectionLabel` nor `label` can exist on
+    // a `host.profileRoutes()` route (connectionId / mode / profile /
+    // targetProfile only), so this always falls through to the raw connection
+    // id and peer gateways list agents by id instead of the human label.
+    const label = String(connection.route?.connectionLabel || connection.route?.label || connection.id)
+
+    return profiles
+      .map(profile => ({
+        profile: String(profile?.name || ''),
+        handle: botHandle(profile?.name, profile),
+        connection_id: connection.id,
+        connection_label: label,
+        title: String(profile?.ui_meta?.['hermes-bots']?.title || profile?.display_name || ''),
+        description: String(profile?.description || '')
+      }))
+      .filter(row => row.profile)
+  } catch {
+    return null
+  }
+}
+
+/** Last good agent rows per connection id — reused when a fetch blips so a
+ *  transient failure never reads as "everyone on that machine went away".
+ *  The sweep below drops disconnected ids, but only on a cycle that had two
+ *  or more connections to relay between; the ceiling is what bounds the rest.
+ *  Every live connection is rewritten each cycle, so eviction can only ever
+ *  reach ids that stopped being fetched. */
+const RELAY_AGENTS_CACHE_MAX = 32
+const relayAgentsCache = new LruCache<string, RelayAgentRow[]>(RELAY_AGENTS_CACHE_MAX)
+
+/** Push every gateway the union roster of agents on the OTHER connections. */
+async function syncRelayRosters() {
+  if (relay.disposed || relay.rosterBusy) {
+    return
+  }
+
+  relay.rosterBusy = true
+
+  try {
+    const connections = await relayConnections()
+
+    if (connections.length < 2) {
+      return
+    }
+
+    const agentsByConnection = new Map<string, RelayAgentRow[]>()
+    await Promise.all(
+      connections.map(async connection => {
+        const agents = await relayAgentsOn(connection)
+
+        if (agents === null) {
+          // Transient fetch failure: reuse the last good rows for this
+          // connection (or contribute nothing this cycle) so the pushed
+          // roster never drops a live machine's agents — absence from a
+          // fresh roster means offline to the gateway-side fail-fast.
+          agentsByConnection.set(connection.id, relayAgentsCache.get(connection.id) || [])
+        } else {
+          relayAgentsCache.set(connection.id, agents)
+          agentsByConnection.set(connection.id, agents)
+        }
+      })
+    )
+
+    // Connections gone from profileRoutes are genuinely disconnected — drop
+    // their cache so a later reconnect starts from live data.
+    const liveIds = new Set(connections.map(connection => connection.id))
+
+    for (const id of [...relayAgentsCache.keys()]) {
+      if (!liveIds.has(id)) {
+        relayAgentsCache.delete(id)
+      }
+    }
+
+    await Promise.all(
+      connections.map(async connection => {
+        const others: RelayAgentRow[] = []
+
+        for (const [id, agents] of agentsByConnection) {
+          if (id !== connection.id) {
+            others.push(...agents)
+          }
+        }
+
+        try {
+          await host.requestProfile(connection.route, 'bot_relay.roster.sync', {
+            agents: others
+          })
+        } catch {
+          // Older backend without the relay RPCs — skip this connection.
+        }
+      })
+    )
+  } finally {
+    relay.rosterBusy = false
+  }
+}
+
+/** Drain every gateway's outbox and deliver each envelope on the target
+ *  connection's own socket; the reply (or error) is posted back to the
+ *  sender gateway for its waiter. */
+async function drainRelayOutboxes() {
+  if (relay.disposed) {
+    return
+  }
+
+  if (relay.drainBusy) {
+    // A push signal raced an in-flight drain. The gateway never re-sends it
+    // (monotone signature), so without this flag the envelope would wait out
+    // the full poll interval — exactly the latency the push path removes.
+    relay.drainRerun = true
+
+    return
+  }
+
+  relay.drainBusy = true
+
+  try {
+    const connections = await relayConnections()
+
+    // Retention follows the relay-eligible set: with fewer than two
+    // connections there is nothing to relay, so nothing stays pinned.
+    syncRelayRetention(connections.length >= 2 ? connections : [])
+
+    if (connections.length < 2) {
+      return
+    }
+
+    const byId = new Map(connections.map(connection => [connection.id, connection]))
+
+    for (const sender of connections) {
+      let envelopes: RelayEnvelope[] = []
+
+      try {
+        const res = await host.requestProfile<{ envelopes?: RelayEnvelope[] }>(
+          sender.route,
+          'bot_relay.outbox.drain',
+          {}
+        )
+
+        envelopes = Array.isArray(res?.envelopes) ? res.envelopes : []
+      } catch {
+        continue
+      }
+
+      for (const envelope of envelopes) {
+        if (relay.disposed) {
+          return
+        }
+
+        const envelopeId = String(envelope?.id || '')
+        const target = byId.get(String(envelope?.target_connection || ''))
+
+        const postReply = async (payload: { error?: string; reason?: string; reply?: string }) => {
+          try {
+            await host.requestProfile(sender.route, 'bot_relay.reply', {
+              id: envelopeId,
+              ...payload
+            })
+          } catch {
+            // Sender gateway unreachable — its waiter times out with guidance.
+          }
+        }
+
+        if (!envelopeId) {
+          continue
+        }
+
+        if (!target) {
+          await postReply({
+            error: `connection '${envelope?.target_connection}' is not connected to this Desktop right now`
+          })
+
+          continue
+        }
+
+        // Needs-attention hook (#93091 item 3): a delivered background DM is
+        // this bot's "good turn"; a classified delivery failure badges it.
+        const attentionKey = `${target.id}::${String(envelope?.target_profile || '')}`
+
+        try {
+          const res = await host.requestProfile<{ reply?: string }>(target.route, 'bot_relay.deliver', {
+            profile: String(envelope?.target_profile || ''),
+            message: String(envelope?.message || '')
+          })
+
+          clearBotAttention(attentionKey)
+          await postReply({
+            reply: String(res?.reply || '')
+          })
+        } catch (error: any) {
+          // #93091: bot_relay.deliver classifies the failed turn and ships the
+          // typed code in the JSON-RPC error's `data.reason`; forward it into
+          // the sender-side reply file so the waiter (and the sending agent)
+          // get the machine-readable cause, and prefer it for the badge —
+          // classified codes beat free-text re-parsing.
+          const reason = String(error?.data?.reason || '').trim()
+          noteBotAttention(attentionKey, reason || error?.message || error)
+          await postReply({
+            error: String(error?.message || error || 'delivery failed'),
+            ...(reason
+              ? {
+                  reason
+                }
+              : {})
+          })
+        }
+      }
+    }
+  } finally {
+    relay.drainBusy = false
+
+    if (relay.drainRerun && !relay.disposed) {
+      // Envelopes signaled mid-drain: schedule one follow-up pass (debounced)
+      // instead of leaving them to the interval poll.
+      relay.drainRerun = false
+      scheduleRelayPushDrain()
+    }
+  }
+}
+
+/** Push-notified drain (#93091): collapse a burst of pending signals into
+ *  one drain call ~RELAY_PUSH_DEBOUNCE_MS after the first signal. */
+function scheduleRelayPushDrain() {
+  if (relay.disposed || typeof setTimeout !== 'function') {
+    return
+  }
+
+  if (relay.pushDebounceTimer !== null) {
+    return
+  }
+
+  relay.pushDebounceTimer = setTimeout(() => {
+    relay.pushDebounceTimer = null
+    void drainRelayOutboxes()
+  }, RELAY_PUSH_DEBOUNCE_MS)
+}
+
+export function startBotRelay() {
+  relay.disposed = false
+
+  // Source-shape test harnesses evaluate plugin.js without DOM timers —
+  // the relay only runs where a real event loop exists.
+  if (typeof setInterval !== 'function' || typeof clearInterval !== 'function') {
+    return
+  }
+
+  if (relay.rosterTimer === null) {
+    relay.rosterTimer = setInterval(() => void syncRelayRosters(), RELAY_ROSTER_INTERVAL_MS)
+    void syncRelayRosters()
+  }
+
+  if (relay.drainTimer === null) {
+    relay.drainTimer = setInterval(() => void drainRelayOutboxes(), RELAY_DRAIN_INTERVAL_MS)
+  }
+
+  // Push path: the gateway change watcher broadcasts when an envelope hits
+  // the outbox; drain immediately (debounced) instead of waiting the poll
+  // out. Feature-detected — older shells have no host.onEvent — and the 4s
+  // poll above stays untouched as the backstop either way.
+  if (relay.pushUnsub === null && typeof host.onEvent === 'function') {
+    relay.pushUnsub = host.onEvent('bot_relay.outbox.pending', () => scheduleRelayPushDrain())
+  }
+}
+
+export function stopBotRelay() {
+  relay.disposed = true
+  // A rerun remembered mid-drain must not leak into the next start —
+  // it would fire one stale drain after restart.
+  relay.drainRerun = false
+  // Unpin every relay-retained socket (#93594): with the relay stopped the
+  // pooled entries return to dispose-at-refcount-0 semantics.
+  releaseRelayRetention()
+
+  if (relay.rosterTimer !== null) {
+    clearInterval(relay.rosterTimer)
+    relay.rosterTimer = null
+  }
+
+  if (relay.drainTimer !== null) {
+    clearInterval(relay.drainTimer)
+    relay.drainTimer = null
+  }
+
+  if (relay.pushDebounceTimer !== null) {
+    clearTimeout(relay.pushDebounceTimer)
+    relay.pushDebounceTimer = null
+  }
+
+  if (relay.pushUnsub !== null) {
+    try {
+      relay.pushUnsub()
+    } catch {
+      // Disposer from an older shell shape — never break teardown.
+    }
+
+    relay.pushUnsub = null
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/roster-actions.test.ts b/apps/desktop/src/plugins/hermes-bots/roster-actions.test.ts
new file mode 100644
index 000000000000..26f8213f1914
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/roster-actions.test.ts
@@ -0,0 +1,212 @@
+/**
+ * The unread/toast poll every roster refresh feeds.
+ *
+ * This poll is the ONLY unread signal a canonical Bot Chat can have: Bot Chats
+ * are unconditionally hidden, so they never reach the session list the
+ * backend's own watermark iterates, and a delivery from the CLI, cron, another
+ * bot, or another machine never touches this window's live turn edge either.
+ * Hence the local watermark per source-qualified bot.
+ *
+ * The toasts themselves are opt-in and default OFF — a busy roster (cron runs,
+ * bot-to-bot chatter) turns them into a firehose, and the dot already carries
+ * the signal. The unread MARK is recorded either way, and it goes through
+ * core's store (`markSessionUnreadFinished`) rather than a plugin-local map,
+ * so the roster row's `SessionStatusDot` and the badge can never drift apart.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+const { hostMock, markUnreadMock, storageMock } = vi.hoisted(() => ({
+  hostMock: {
+    notify: vi.fn(),
+    request: vi.fn(),
+    state: { connectionId: { get: () => 'local' }, focusedSessionOwner: null, profile: { get: () => 'default' } }
+  },
+  markUnreadMock: vi.fn(),
+  storageMock: { get: vi.fn(), set: vi.fn() }
+}))
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    ackStoredSessionId: vi.fn(),
+    atom,
+    haptic: vi.fn(),
+    host: hostMock,
+    markSessionUnreadFinished: markUnreadMock,
+    queryClient: { invalidateQueries: vi.fn() },
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({
+  bumpBotOpenGeneration: vi.fn(),
+  getBotOpenGeneration: vi.fn(),
+  getPluginCtx: () => ({ storage: storageMock }),
+  ID: 'hermes-bots'
+}))
+
+// The open path drags the whole group-chat surface in; the poll under test
+// touches none of it.
+vi.mock('./canonical-chat', () => ({
+  notifyBotOpenFailure: vi.fn(),
+  openBotCanonicalChat: vi.fn(),
+  prepareBotSource: vi.fn()
+}))
+vi.mock('./group-chat', async () => {
+  const { atom } = await import('nanostores')
+
+  return { $groupChats: atom({}), $groupChatWorkspace: atom<null | string>(null) }
+})
+vi.mock('./group-chat-view', () => ({ openGroupChat: vi.fn() }))
+vi.mock('./group-membership', () => ({ liveGroupChatNames: () => [] }))
+vi.mock('./group-panes', () => ({ closeGroupChatMainTab: vi.fn() }))
+
+/** A bot whose canonical Bot Chat carries the activity — the only shape that
+ *  can be marked unread, since the marker is keyed by canonical session id. */
+const chatting = (name: string, lastActive: number, preview = 'hello'): RosterRow =>
+  ({ canonical_session: { id: `${name}-chat`, last_active: lastActive, preview }, name }) as RosterRow
+
+async function loadActions() {
+  vi.resetModules()
+
+  const [actions, botState, data] = await Promise.all([
+    import('./roster-actions'),
+    import('./bot-state'),
+    import('./data')
+  ])
+
+  return { ...actions, ...botState, $botMeta: data.$botMeta }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('the first poll only seeds watermarks', () => {
+  it('marks nothing unread for history that predates the mount', async () => {
+    const { trackInboundActivity } = await loadActions()
+
+    trackInboundActivity([chatting('researcher', 5000)])
+
+    expect(markUnreadMock).not.toHaveBeenCalled()
+    expect(hostMock.notify).not.toHaveBeenCalled()
+  })
+})
+
+describe('new activity after the seed', () => {
+  it('marks the canonical chat unread through core’s store', async () => {
+    const { trackInboundActivity } = await loadActions()
+
+    trackInboundActivity([chatting('researcher', 5000)])
+    trackInboundActivity([chatting('researcher', 6000)])
+
+    expect(markUnreadMock).toHaveBeenCalledWith('researcher-chat', 'researcher')
+  })
+
+  it('stays silent unless the user opted into toasts', async () => {
+    const { $activityToasts, trackInboundActivity } = await loadActions()
+
+    trackInboundActivity([chatting('researcher', 5000)])
+    trackInboundActivity([chatting('researcher', 6000)])
+    expect(hostMock.notify).not.toHaveBeenCalled()
+
+    $activityToasts.set(true)
+    trackInboundActivity([chatting('researcher', 7000, 'a plain update')])
+
+    expect(hostMock.notify).toHaveBeenCalledTimes(1)
+    expect(hostMock.notify.mock.calls[0][0]).toMatchObject({ kind: 'info', message: 'a plain update' })
+  })
+
+  it('titles a bot-to-bot delivery differently from ordinary activity', async () => {
+    const { $activityToasts, trackInboundActivity } = await loadActions()
+
+    $activityToasts.set(true)
+    trackInboundActivity([chatting('researcher', 5000)])
+    trackInboundActivity([chatting('researcher', 6000, 'Message from 🤖 manager (@manager): ship it')])
+
+    expect(hostMock.notify.mock.calls[0][0].title).toMatch(/New message for/)
+
+    trackInboundActivity([chatting('researcher', 7000, 'finished the run')])
+    expect(hostMock.notify.mock.calls[1][0].title).toMatch(/has new activity/)
+  })
+
+  it('never badges the bot the user is currently looking at', async () => {
+    const { $selectedBot, trackInboundActivity } = await loadActions()
+
+    trackInboundActivity([chatting('researcher', 5000)])
+    $selectedBot.set('researcher')
+    trackInboundActivity([chatting('researcher', 6000)])
+
+    expect(markUnreadMock).not.toHaveBeenCalled()
+  })
+
+  it('keeps marking a roster-hidden bot but never toasts it', async () => {
+    const { $activityToasts, $botMeta, trackInboundActivity } = await loadActions()
+
+    $activityToasts.set(true)
+    $botMeta.set({ researcher: { hidden: true } })
+    trackInboundActivity([chatting('researcher', 5000)])
+    trackInboundActivity([chatting('researcher', 6000)])
+
+    // Unhiding must reveal the dot, so the mark accumulates silently.
+    expect(markUnreadMock).toHaveBeenCalledWith('researcher-chat', 'researcher')
+    expect(hostMock.notify).not.toHaveBeenCalled()
+  })
+
+  it('sees a DM delivered into the hidden Bot Chat that last_session cannot', async () => {
+    // The whole reason watermarks follow botActivitySession: a stale visible
+    // session would otherwise hold the watermark and swallow the DM.
+    const { trackInboundActivity } = await loadActions()
+
+    const withStaleVisible = (lastActive: number) =>
+      ({
+        canonical_session: { id: 'dm', last_active: lastActive, preview: 'ping' },
+        last_session: { id: 'scratch', last_active: 10 },
+        name: 'dixie'
+      }) as RosterRow
+
+    trackInboundActivity([withStaleVisible(5000)])
+    trackInboundActivity([withStaleVisible(6000)])
+
+    expect(markUnreadMock).toHaveBeenCalledWith('dm', 'dixie')
+  })
+
+  it('tracks two same-named bots on different connections independently', async () => {
+    const { trackInboundActivity } = await loadActions()
+
+    const scoped = (connectionId: string, lastActive: number) =>
+      ({
+        canonical_session: { id: `${connectionId}-chat`, last_active: lastActive },
+        connectionId,
+        name: 'default',
+        route: { connectionId, mode: 'remote', profile: 'default', targetProfile: 'default' },
+        sourceScoped: true
+      }) as RosterRow
+
+    trackInboundActivity([scoped('a', 5000), scoped('b', 5000)])
+    trackInboundActivity([scoped('a', 6000), scoped('b', 5000)])
+
+    expect(markUnreadMock.mock.calls).toEqual([['a-chat', 'default']])
+  })
+})
+
+describe('the toast preference', () => {
+  it('persists through the plugin storage without throwing when it is absent', async () => {
+    const { $activityToasts, setActivityToasts } = await loadActions()
+
+    setActivityToasts(true)
+    expect($activityToasts.get()).toBe(true)
+    expect(storageMock.set).toHaveBeenCalledWith('activity-toasts', true)
+
+    storageMock.set.mockImplementation(() => {
+      throw new Error('storage unavailable')
+    })
+    expect(() => setActivityToasts(false)).not.toThrow()
+    expect($activityToasts.get()).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/roster-actions.ts b/apps/desktop/src/plugins/hermes-bots/roster-actions.ts
new file mode 100644
index 000000000000..f557463bb20c
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/roster-actions.ts
@@ -0,0 +1,293 @@
+/**
+ * The two roster actions that reach outside a component: the unread/toast
+ * poll every roster refresh feeds, and the click path that fronts one exact
+ * bot's canonical chat.
+ *
+ * They sit beside the surfaces rather than inside them — the bot row, the
+ * roster pane and the plugin's own lifecycle all invoke them, and none of
+ * them can own an action the others call without importing a sibling surface.
+ */
+
+import { ackStoredSessionId, atom, haptic, host, markSessionUnreadFinished } from '@hermes/plugin-sdk'
+
+import { $openBotChat, $selectedBot, rosterWatermarks, saveSelectedRosterBot } from './bot-state'
+import { notifyBotOpenFailure, openBotCanonicalChat, prepareBotSource } from './canonical-chat'
+import { $botMeta, botActivitySession, botRosterKey, botSelectionKey, newBotChat } from './data'
+import { $groupChats, $groupChatWorkspace } from './group-chat'
+import { openGroupChat } from './group-chat-view'
+import { liveGroupChatNames } from './group-membership'
+import { closeGroupChatMainTab } from './group-panes'
+import { displayName } from './labels'
+import { botRosterMeta, botWorkspaceOwnerKey, setBotsWorkspaceOwner } from './routing'
+import { botCanonicalSessionId } from './row-helpers'
+import { bumpBotOpenGeneration, getBotOpenGeneration, getPluginCtx } from './shared'
+import type { RosterRow } from './types'
+
+// last_active watermark per source-qualified bot, seeded on first poll so a
+// fresh mount doesn't mark ancient history unread.
+let watermarksSeeded = false
+
+/** User pref: toast on every new bot activity. Default OFF — a busy roster
+ *  (cron runs, bot-to-bot chatter) turns the toasts into a firehose, and the
+ *  unread badge already carries the signal. Persisted via ctx.storage. */
+export const $activityToasts = atom(false)
+
+/** Flip the activity-toast pref and persist it. */
+export function setActivityToasts(enabled: boolean) {
+  $activityToasts.set(enabled)
+
+  try {
+    Promise.resolve(getPluginCtx()?.storage?.set?.('activity-toasts', enabled)).catch(() => undefined)
+  } catch {
+    /* storage unavailable — pref holds for this window only */
+  }
+}
+
+/** Detect new inbound activity from a fresh roster: last_active moved past
+ *  the watermark for a bot whose chat isn't on screen -> unread + toast.
+ *  Watermarks follow botActivitySession (canonical Bot Chat included) —
+ *  last_session alone never sees the hidden Bot Chat, so DMs delivered
+ *  there would neither badge nor toast.
+ *
+ *  This poll is the ONLY unread signal a canonical Bot Chat can have: it is
+ *  unconditionally hidden, so it never reaches the session list the backend's
+ *  own unread watermark iterates, and deliveries from the CLI, cron, another
+ *  bot, or another machine never touch this window's live turn edge either. */
+export function trackInboundActivity(roster: RosterRow[]) {
+  const seeding = !watermarksSeeded
+  watermarksSeeded = true
+
+  for (const bot of roster) {
+    const key = botSelectionKey(bot)
+    const activity = botActivitySession(bot)
+    const ts = activity?.last_active || 0
+    const prev = rosterWatermarks.get(key) || 0
+    rosterWatermarks.set(key, Math.max(prev, ts))
+
+    if (seeding || ts <= prev) {
+      continue
+    }
+
+    // Activity in the exact bot owner the user is currently looking at is
+    // already visible — never badge the open chat or its same-named twin.
+    if ($selectedBot.get() === key) {
+      continue
+    }
+
+    // Straight into core's unread store, keyed by the same canonical id the
+    // row's SessionStatusDot reads — a parallel map here would be a second
+    // badge that drifts from the dot.
+    const canonicalSessionId = botCanonicalSessionId(bot)
+
+    if (canonicalSessionId) {
+      markSessionUnreadFinished(canonicalSessionId, bot.name)
+    }
+
+    // Roster-hidden bots stay quiet: the mark above accumulates silently
+    // (unhiding reveals the dot) but a hidden bot never toasts.
+    if (botRosterMeta(bot, $botMeta.get())?.hidden) {
+      continue
+    }
+
+    // Toasts are opt-in: the unread mark is recorded above regardless, but the
+    // per-message notification fires only when the user enabled it.
+    if ($activityToasts.get()) {
+      const meta = botRosterMeta(bot, $botMeta.get())
+      const label = displayName(bot, meta)
+      const preview = (activity?.preview || '').trim()
+      const inbound = /^Message from/i.test(preview)
+      host.notify({
+        kind: 'info',
+        title: inbound ? `\uD83E\uDD16 New message for ${label}` : `${label} has new activity`,
+        message: preview.slice(0, 140) || 'Open the chat to see it.'
+      })
+    }
+  }
+}
+
+/** The tab this bot's workspace already has open, fronted — or null when it has
+ *  none. A roster click consults this BEFORE the canonical registry so a bot
+ *  with open tabs simply comes back to the one the user left. It is what lets a
+ *  closed Bot Chat STAY closed: the click path used to re-open the forever-chat
+ *  beside every newer thread on every bot switch, and nothing records a close
+ *  (this plugin keeps no closed set; core's tile bucket only forgets), so the
+ *  only honest signal is the open set itself. Feature-detected — older shells
+ *  fall through to the canonical open. */
+function focusExistingBotTab(bot: RosterRow): null | string {
+  if (typeof host.focusOpenWorkspaceSession !== 'function') {
+    return null
+  }
+
+  try {
+    const focused = host.focusOpenWorkspaceSession(botWorkspaceOwnerKey(bot))
+
+    return typeof focused === 'string' && focused ? focused : null
+  } catch {
+    return null
+  }
+}
+
+/** Select one exact roster owner, then open its named canonical chat only when
+ *  the current Desktop can route that owner without guessing. The workspace
+ *  remembers only this transient opened-view observation; it never stores or
+ *  resolves a canonical-chat id.
+ *
+ *  `canonical`: the user asked for the forever-chat itself (the row menu's
+ *  "Open Bot Chat"). A plain row click is "go to this bot": when its workspace
+ *  already holds tabs, the one the user last had active is fronted and no chat
+ *  is resolved or opened — see focusExistingBotTab. */
+export async function openRosterBot(bot: RosterRow, { canonical = false } = {}): Promise<boolean> {
+  const generation = bumpBotOpenGeneration()
+  const key = botRosterKey(bot)
+  const meta = botRosterMeta(bot, $botMeta.get())
+  // Keep the currently visible group as a fallback until this explicit action
+  // has actually fronted a new owner; a failed open must not steal the center
+  // from a group the user was reading.
+  const previousGroup = $groupChatWorkspace.get()
+
+  const previousGroupRef = previousGroup
+    ? {
+        group: previousGroup,
+        roomId: String($groupChats.get()[previousGroup]?.roomId || '')
+      }
+    : null
+
+  haptic('tap')
+  saveSelectedRosterBot(bot)
+  setBotsWorkspaceOwner(botWorkspaceOwnerKey(bot), bot)
+  const dismissedGroup = bot.remoteSource ? null : dismissGroupChatForLocalBotOpen()
+
+  if (!dismissedGroup) {
+    $groupChatWorkspace.set(null)
+  }
+
+  const restorePreviousGroup = () => {
+    if (!previousGroupRef || $groupChatWorkspace.get()) {
+      return
+    }
+
+    const restoreRef = dismissedGroup || previousGroupRef
+    const rooms = $groupChats.get()
+
+    const currentGroup = restoreRef.roomId
+      ? Object.keys(rooms).find(
+          name => !rooms[name]?.tombstone && String(rooms[name]?.roomId || '') === restoreRef.roomId
+        )
+      : liveGroupChatNames().includes(restoreRef.group)
+        ? restoreRef.group
+        : null
+
+    if (!currentGroup) {
+      return
+    }
+
+    openGroupChat(currentGroup)
+  }
+
+  // The persisted half of clear-on-open. The transient dot is retired by
+  // core's own selection path once the chat lands; this retires the marker,
+  // which the selection listener alone would file against the wrong profile —
+  // a bot open deliberately leaves the gateway on the launch profile.
+  ackStoredSessionId(botCanonicalSessionId(bot), bot.name)
+
+  if (!canonical) {
+    const focused = focusExistingBotTab(bot)
+
+    if (focused) {
+      // Open tabs win: no source activation, no registry consult, no open. The
+      // claim carries only the fronted tab so the focus edge it fires keeps it
+      // (releaseStaleOpenBotChat) and no registry id is recorded, because none
+      // was resolved.
+      $openBotChat.set({ key, openedRegistryId: '', openedSessionId: focused })
+
+      return true
+    }
+  }
+
+  try {
+    // Activation selects this row's source only. Canonical identity is resolved
+    // after that by the owner profile's "Bot Chat" title registry.
+    await prepareBotSource(bot)
+  } catch (error) {
+    if (generation === getBotOpenGeneration()) {
+      $openBotChat.set(null)
+      restorePreviousGroup()
+      notifyBotOpenFailure(error, bot, `Could not reach ${bot.connectionLabel || 'the gateway'}`)
+    }
+
+    return false
+  }
+
+  if (generation !== getBotOpenGeneration()) {
+    return false
+  }
+
+  try {
+    const opened = await openBotCanonicalChat(bot, () => generation === getBotOpenGeneration())
+
+    if (generation !== getBotOpenGeneration()) {
+      return false
+    }
+
+    if (opened) {
+      // This is not an identity preference: opening already completed through
+      // the name registry. Keep only enough ephemeral state to release the
+      // claim if another tab later claims the center. Track BOTH identities —
+      // session focus reports the compression-lineage tip (openedId), not the
+      // durable registry row, and matching focus against the registry id
+      // alone released this claim on the first click of every compressed
+      // Bot Chat.
+      $openBotChat.set({
+        key,
+        openedRegistryId: opened.registryId,
+        openedSessionId: opened.openedId
+      })
+
+      return true
+    }
+  } catch (error) {
+    if (generation === getBotOpenGeneration()) {
+      $openBotChat.set(null)
+      restorePreviousGroup()
+      notifyBotOpenFailure(error, bot, `Could not open ${displayName(bot, meta)}'s chat — try again`)
+    }
+
+    return false
+  }
+
+  // An older Desktop without the profile-scoped draft API has no safe fallback:
+  // do not navigate the current workspace or create a draft on the wrong owner.
+  if (typeof host.newChat !== 'function') {
+    $openBotChat.set(null)
+    restorePreviousGroup()
+
+    return false
+  }
+
+  $openBotChat.set({
+    key,
+    openedRegistryId: ''
+  })
+  newBotChat(bot)
+
+  return true
+}
+
+/** Bot-open handoff: capture the selected group and retire its registered
+ * main tab (or clear the in-panel selection) before async source prep /
+ * canonical open. */
+function dismissGroupChatForLocalBotOpen(): null | { group: string; roomId: string } {
+  const group = $groupChatWorkspace.get()
+
+  if (!group) {
+    return null
+  }
+
+  const roomId = String($groupChats.get()[group]?.roomId || '')
+  closeGroupChatMainTab(group)
+
+  return {
+    group,
+    roomId
+  }
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/roster-pane.tsx b/apps/desktop/src/plugins/hermes-bots/roster-pane.tsx
new file mode 100644
index 000000000000..60b561961d2b
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/roster-pane.tsx
@@ -0,0 +1,941 @@
+/**
+ * The Bots pane itself: the roster's selection reconciliation, the
+ * workspace-ownership reads its lifecycle keys off, and the pane that lists
+ * every bot and group chat.
+ *
+ * The top of the roster stack. It composes the rows, the section headings and
+ * the dialogs; nothing in Bot Mode imports it except the plugin entry point.
+ */
+
+import {
+  atom,
+  Button,
+  cn,
+  Codicon,
+  ConfirmDialog,
+  DisclosureCaret,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+  GlyphSpinner,
+  host,
+  PanelEmpty,
+  RowButton,
+  SearchField,
+  Tip,
+  useI18n,
+  useValue
+} from '@hermes/plugin-sdk'
+import { useEffect, useRef, useState } from 'react'
+
+import { BotRow, GroupRow } from './bot-row'
+import {
+  $botChatFocused,
+  $botsPaneVisible,
+  $openBotChat,
+  $rosterHydrated,
+  $selectedRosterHydrated,
+  $selectedRosterKey,
+  clearSelectedRosterKey,
+  parseRosterKey,
+  saveSelectedRosterBot
+} from './bot-state'
+import { CreateAgentDialog, CreateGroupChatDialog, GroupDialog } from './create-dialog'
+import {
+  $botMeta,
+  $lastRoster,
+  annotateBotSource,
+  botActivitySession,
+  botRosterKey,
+  botSourceStatus,
+  filterBots,
+  preferReachableSameNameRows,
+  sourceByConnection,
+  useRoster
+} from './data'
+import { EditProfileDialog } from './edit-profile-dialog'
+import { $groupChats, $groupChatWorkspace, $groupNeedsYou } from './group-chat'
+import { disbandGroupChat, GroupChatWorkspace, openGroupChat } from './group-chat-view'
+import { groupChatMemberBots, groupChatNames, groupLastActivity } from './group-membership'
+import { $groupMainTabsRev, shouldRenderGroupChatInPane } from './group-panes'
+import { $showHiddenBots, isBotHidden, isBotPinned } from './hidden-bots'
+import { useBots } from './i18n'
+import { deleteBot, mergeServerMeta, pullServerAvatars } from './profile-ops'
+import { $activityToasts, setActivityToasts, trackInboundActivity } from './roster-actions'
+import {
+  botNeedsHandleLabel,
+  filterBotsByGateway,
+  GatewayKindGlyph,
+  GatewaySectionHeading,
+  groupMatchesRosterFilters,
+  rosterGatewayOptions,
+  rosterGatewaySections,
+  RosterSectionHeader
+} from './roster-sections'
+import type { ResolvedRosterGatewaySection } from './roster-sections'
+import { botRosterMeta, botWorkspaceOwnerKey, setBotsWorkspaceOwner } from './routing'
+import { ACTIVE_WINDOW_S, activeBots, BOT_ROSTER_SEARCH_THRESHOLD, rosterActivityMatches } from './row-helpers'
+import { backfillMessagingProtocol } from './soul'
+import type { BotMeta, GatewaySource, GroupMember, RosterActivityFilter, RosterKindFilter, RosterRow } from './types'
+
+/** Last source inventory returned by the desktop-wide agent roster. */
+const $lastSources = atom<GatewaySource[]>([])
+
+// ── roster pane ──────────────────────────────────────────────────────────────
+
+export function selectedRosterBot(roster: RosterRow[], key: string): RosterRow | null {
+  return (Array.isArray(roster) ? roster : []).find(bot => botRosterKey(bot) === key) || null
+}
+
+/** A selected owner whose roster row is absent because its SOURCE is down —
+ *  not because the bot is gone. Identity comes from the key itself, so the
+ *  selection survives a relaunch with that gateway offline and reconciles
+ *  onto the live row (same key) when it returns, without duplicating it.
+ *
+ *  Returns null when the selection is provably invalid instead: a reachable
+ *  source that no longer lists the bot, or a source that left the registry
+ *  while other sources are live. Unknown (no sources yet) is NOT proof. */
+function ghostRosterOwner(key: string, sources: GatewaySource[]): RosterRow | null {
+  const { connectionId, name } = parseRosterKey(key)
+
+  if (!name) {
+    return null
+  }
+
+  const list = Array.isArray(sources) ? sources : []
+  const source = sourceByConnection(list).get(connectionId)
+
+  if (source ? source.reachable === true : list.length > 0) {
+    return null
+  }
+
+  return {
+    name,
+    connectionId,
+    ghost: true,
+    remoteSource: connectionId !== 'local',
+    connectionKind: source?.kind,
+    connectionLabel: source?.label,
+    sourceError: source?.error || null,
+    sourceMissing: false,
+    sourceReachable: false
+  }
+}
+
+/** Keep the exact selected owner visible through a cold-start outage without
+ *  persisting the whole remote roster. The source registry supplies the
+ *  gateway identity/status; the source-qualified selection supplies the bot
+ *  identity. Once that source answers again, the live row replaces the ghost
+ *  (or reconciliation clears it when the bot was actually removed). */
+function rosterWithSelectedOwner(roster: RosterRow[], sources: GatewaySource[], key: string): RosterRow[] {
+  const rows = Array.isArray(roster) ? roster : []
+
+  if (!key || selectedRosterBot(rows, key)) {
+    return rows
+  }
+
+  const ghost = ghostRosterOwner(key, sources)
+
+  return ghost ? [...rows, ghost] : rows
+}
+
+/** Keep the persisted selection honest against the live roster and seat a
+ *  first selection when there is none. PRESENTATION ONLY: it never opens,
+ *  prepares, activates, or creates anything — an unreachable owner keeps its
+ *  selection rather than falling back onto some other gateway's bot. */
+function reconcileRosterSelection(roster: RosterRow[], sources: GatewaySource[], metaByName: Record<string, BotMeta>) {
+  if (!$rosterHydrated.get() || !$selectedRosterHydrated.get()) {
+    return
+  }
+
+  const key = $selectedRosterKey.get()
+
+  if (key) {
+    if (selectedRosterBot(roster, key) || ghostRosterOwner(key, sources)) {
+      return
+    }
+
+    clearSelectedRosterKey(key)
+  }
+
+  const first = (Array.isArray(roster) ? roster : []).find(
+    bot => !isBotHidden(bot, metaByName) && botSourceStatus(annotateBotSource(bot, sources)).available
+  )
+
+  if (first) {
+    saveSelectedRosterBot(first)
+  }
+}
+
+/** True when a session owns the main workspace. Prefers the focused STORED
+ *  session (tab focus moves without swapping the gateway socket); bare test
+ *  harnesses with neither atom drive $botChatFocused directly. */
+export function sessionOwnsWorkspace(): boolean {
+  const focused = host.state?.focusedStoredSessionId?.get?.()
+
+  if (focused !== undefined) {
+    return Boolean(focused)
+  }
+
+  const active = host.state?.activeSessionId?.get?.()
+
+  return active === undefined ? $botChatFocused.get() : Boolean(active)
+}
+
+/** A real bot chat owns the center. Cronjobs are BOT-scoped, so this — not
+ *  mere Bot Mode visibility — is what may seat the Cronjobs tile: beside a
+ *  group chat it would describe whichever profile the socket happens to be
+ *  homed on. */
+export function botChatOwnsWorkspace(): boolean {
+  return $botsPaneVisible.get() && !$groupChatWorkspace.get() && Boolean($openBotChat.get() || sessionOwnsWorkspace())
+}
+
+/** An opened bot chat stops owning the center once focus leaves it (closed,
+ *  or another session took over). Without this $openBotChat would keep
+ *  claiming ownership for a chat nobody is reading, and the bot-scoped
+ *  Cronjobs tile would stay seated beside an unrelated surface.
+ *
+ *  The legacy newChat fallback has no registry id to compare — a draft with no
+ *  focused session is still that bot's draft, so it only yields once some
+ *  session actually takes focus. */
+export function releaseStaleOpenBotChat(focusedStoredId: null | string | undefined): void {
+  const open = $openBotChat.get()
+
+  if (!open) {
+    return
+  }
+
+  const focused = focusedStoredId === null || focusedStoredId === undefined ? '' : String(focusedStoredId)
+  // The focused stored id is the compression-lineage TIP; the claim carries
+  // both the durable registry id and the tip it actually opened. Either
+  // match keeps the claim — comparing only the registry id released it on
+  // the very focus edge the open itself caused.
+  const owned = [open.openedSessionId, open.openedRegistryId].filter(Boolean)
+  const stale = owned.length ? !owned.includes(focused) : Boolean(focused)
+
+  if (stale) {
+    $openBotChat.set(null)
+  }
+}
+
+/** The two row shapes the roster sorts together — `kind` is the discriminant. */
+interface RosterBotRow {
+  active: boolean
+  activity: number
+  bot: RosterRow
+  kind: 'bot'
+  pinned: boolean
+}
+interface RosterGroupRow {
+  active: boolean
+  activity: number
+  kind: 'group'
+  members: GroupMember[]
+  name: string
+  pinned: boolean
+}
+
+export function BotsPane() {
+  const { t } = useI18n()
+  const b = useBots()
+  const { data, error, isLoading, refetch } = useRoster()
+  const gatewayState = useValue(host.state.gateway)
+  const gatewayUp = gatewayState === 'open'
+  const activeProfile = (useValue(host.state.profile) || 'default').trim() || 'default'
+  const [createOpen, setCreateOpen] = useState(false)
+  const [groupCreateOpen, setGroupCreateOpen] = useState(false)
+  const [editing, setEditing] = useState<null | RosterRow>(null)
+  // `path` is the profile directory the gateway reports on a profiles.list row;
+  // it is not part of the shared RosterRow model, so it rides as an extra here.
+  const [deleting, setDeleting] = useState<null | (RosterRow & { path?: string })>(null)
+  const [deletingGroup, setDeletingGroup] = useState<null | { members: GroupMember[]; name: string }>(null)
+  const [grouping, setGrouping] = useState<null | RosterRow>(null)
+  const [query, setQuery] = useState('')
+  const [rowKindFilter, setRowKindFilter] = useState<RosterKindFilter>('all')
+  const [activityFilter, setActivityFilter] = useState<RosterActivityFilter>('all')
+  const [gatewayFilter, setGatewayFilter] = useState('all')
+  const [collapsedRosterSections, setCollapsedRosterSections] = useState<Set<string>>(() => new Set())
+  const hiddenSectionRef = useRef<null | HTMLDivElement>(null)
+  const activityToasts = useValue($activityToasts)
+  const groupChatName = useValue($groupChatWorkspace)
+  // Main-tab ownership is a module Map; this rev subscription makes the
+  // shouldRenderGroupChatInPane gate below reactive to tab open/close
+  // (#89788 follow-up — without it a stale render could paint the in-pane
+  // room beside a live main tab and stick).
+  useValue($groupMainTabsRev)
+  const groupNeedsYou = useValue($groupNeedsYou)
+  const groupRooms = useValue($groupChats)
+  const rememberedSources = useValue($lastSources)
+  const rosterHydrated = useValue($rosterHydrated)
+  const selectionHydrated = useValue($selectedRosterHydrated)
+  const selectedRosterKey = useValue($selectedRosterKey)
+
+  // The socket opening (boot, SSH reconnect, sleep/wake) is the signal to
+  // retry immediately instead of waiting out the poll interval.
+  useEffect(() => {
+    if (gatewayUp) {
+      void refetch()
+    }
+  }, [gatewayUp, refetch])
+  const allMeta = useValue($botMeta)
+
+  // Messaging-app order: most recent activity first, where "activity" is
+  // the newest of (bot created, last message in any of its sessions). A
+  // freshly created bot tops the list until another bot gets a message.
+  // No special slot for the primary bot — it competes on recency too.
+  const activityOf = (bot: RosterRow): number => {
+    const created = botRosterMeta(bot, allMeta)?.created || bot.ui_meta?.['hermes-bots']?.created || 0
+    const lastMsg = (botActivitySession(bot)?.last_active || 0) * 1000
+
+    return Math.max(created, lastMsg)
+  }
+
+  // Pin is a source-qualified Desktop preference, not gateway profile state.
+  const isPinned = (bot: RosterRow): boolean => isBotPinned(bot, allMeta)
+  // Resilience (@wesleysimplicio, #13): a failed refresh must not erase a
+  // roster the user already had — mixed local+cloud gateways and remotes
+  // waking from sleep fail transiently. Render the last good snapshot with
+  // a notice; the full error card is reserved for "never had a roster".
+  const live = Array.isArray(data?.profiles) ? data.profiles : null
+  const source = live ?? (error ? $lastRoster.get() : [])
+  const sourceSnapshot = Array.isArray(data?.sources) ? data.sources : rememberedSources
+
+  const sourceWithSelectedOwner =
+    selectionHydrated && rosterHydrated ? rosterWithSelectedOwner(source, sourceSnapshot, selectedRosterKey) : source
+
+  const roster = sourceWithSelectedOwner.slice().sort((a, b) => {
+    const pa = isPinned(a) ? 1 : 0
+    const pb = isPinned(b) ? 1 : 0
+
+    if (pa !== pb) {
+      return pb - pa
+    }
+
+    return activityOf(b) - activityOf(a)
+  })
+
+  // React Query can briefly report neither loading nor data while the plugin
+  // and the persisted connection registry hydrate. Keep that transition in a
+  // neutral loading state instead of flashing the first-run "No bots" copy.
+  const initialRosterLoading = !data && !error && roster.length === 0
+  const activeRosterKeys = new Set(activeBots(roster, activeProfile, gatewayState).map(botRosterKey))
+  const gatewayOptions = rosterGatewayOptions(sourceSnapshot, roster)
+  const selectedGateway = gatewayOptions.find(option => option.connectionId === gatewayFilter)
+  const gatewayFilterExists = gatewayFilter === 'all' || Boolean(selectedGateway)
+  useEffect(() => {
+    if (!gatewayFilterExists) {
+      setGatewayFilter('all')
+    }
+  }, [gatewayFilterExists])
+  const activeSourceRoster = roster.filter(bot => !bot.remoteSource)
+  // Hidden rows remain fully alive and recoverable at the bottom. Every
+  // non-display consumer continues to receive the complete roster.
+  const hiddenExpanded = useValue($showHiddenBots)
+  const hiddenBots = roster.filter(bot => isBotHidden(bot, allMeta))
+  const visibleRoster = roster.filter(bot => !isBotHidden(bot, allMeta))
+  const gatewayRoster = filterBotsByGateway(visibleRoster, gatewayFilter)
+
+  const filteredRoster = filterBots(gatewayRoster, allMeta, query).filter((bot: RosterRow) =>
+    rosterActivityMatches(
+      {
+        activity: activityOf(bot),
+        active: activeRosterKeys.has(botRosterKey(bot))
+      },
+      activityFilter
+    )
+  )
+
+  const filteredHiddenBots = filterBots(filterBotsByGateway(hiddenBots, gatewayFilter), allMeta, query).filter(
+    (bot: RosterRow) =>
+      rosterActivityMatches(
+        {
+          activity: activityOf(bot),
+          active: activeRosterKeys.has(botRosterKey(bot))
+        },
+        activityFilter
+      )
+  )
+
+  const groupNames = groupChatNames(allMeta, groupRooms)
+
+  const groupRows = groupNames
+    .map(name => ({
+      name,
+      members: groupChatMemberBots(name, roster, allMeta)
+    }))
+    .filter(row => groupMatchesRosterFilters(row.name, row.members, allMeta, query, gatewayFilter))
+    .map((row): RosterGroupRow => ({
+      kind: 'group',
+      name: row.name,
+      members: row.members,
+      pinned: Boolean(groupRooms[row.name]?.pinned),
+      activity: groupLastActivity(groupRooms[row.name]),
+      active:
+        Boolean(
+          groupLastActivity(groupRooms[row.name]) &&
+          Date.now() - groupLastActivity(groupRooms[row.name]) <= ACTIVE_WINDOW_S * 1000
+        ) || row.members.some(member => activeRosterKeys.has(botRosterKey(member)))
+    }))
+    .filter(row => rowKindFilter !== 'bots' && rosterActivityMatches(row, activityFilter))
+
+  const botRows =
+    rowKindFilter === 'groups'
+      ? []
+      : preferReachableSameNameRows(filteredRoster).map((bot): RosterBotRow => ({
+          kind: 'bot',
+          bot,
+          pinned: isPinned(bot),
+          activity: activityOf(bot),
+          active: activeRosterKeys.has(botRosterKey(bot))
+        }))
+
+  const sortRosterRows = <T extends { activity: number; pinned: boolean }>(rows: T[]): T[] =>
+    rows.slice().sort((a, b) => {
+      const pa = a.pinned ? 1 : 0
+      const pb = b.pinned ? 1 : 0
+
+      if (pa !== pb) {
+        return pb - pa
+      }
+
+      return b.activity - a.activity
+    })
+
+  const rosterRows = sortRosterRows([...botRows, ...groupRows])
+  const sortedGroupRows = sortRosterRows(groupRows)
+  const gatewaySections = rosterGatewaySections(botRows, gatewayOptions, gatewayFilter)
+  const showGatewaySections = gatewaySections.sectioned && botRows.length > 0
+
+  const activeFilterCount =
+    (rowKindFilter === 'all' ? 0 : 1) + (activityFilter === 'all' ? 0 : 1) + (gatewayFilter === 'all' ? 0 : 1)
+
+  const hasRosterConstraint = Boolean(query.trim()) || activeFilterCount > 0
+  const matchingHiddenBots = rowKindFilter === 'groups' ? [] : filteredHiddenBots
+  const showHiddenSection = hiddenBots.length > 0 && (!hasRosterConstraint || matchingHiddenBots.length > 0)
+  const showHiddenRows = hiddenExpanded || hasRosterConstraint
+  const rosterItemCount = roster.length + groupNames.length
+
+  const allBotsHidden =
+    !hasRosterConstraint && visibleRoster.length === 0 && groupNames.length === 0 && hiddenBots.length > 0
+
+  const showRosterSearch =
+    gatewayOptions.length > 1 || rosterItemCount >= BOT_ROSTER_SEARCH_THRESHOLD || Boolean(query.trim())
+
+  const showRosterFilters =
+    gatewayOptions.length > 1 ||
+    groupNames.length > 0 ||
+    rosterItemCount >= BOT_ROSTER_SEARCH_THRESHOLD ||
+    activeFilterCount > 0
+
+  const showRosterTools = showRosterSearch || showRosterFilters
+  const rosterSectionCollapsed = (id: string): boolean => !hasRosterConstraint && collapsedRosterSections.has(id)
+
+  const hiddenGatewaySections = rosterGatewaySections(
+    matchingHiddenBots.map((bot: RosterRow) => ({
+      kind: 'bot',
+      bot
+    })),
+    gatewayOptions,
+    gatewayFilter
+  )
+
+  const toggleRosterSection = (id: string): void => {
+    setCollapsedRosterSections(previous => {
+      const next = new Set(previous)
+
+      if (next.has(id)) {
+        next.delete(id)
+      } else {
+        next.add(id)
+      }
+
+      return next
+    })
+  }
+
+  useEffect(() => {
+    if (!hiddenExpanded || hasRosterConstraint) {
+      return
+    }
+
+    const frame = requestAnimationFrame(() =>
+      hiddenSectionRef.current?.scrollIntoView({
+        block: 'nearest'
+      })
+    )
+
+    return () => cancelAnimationFrame(frame)
+  }, [hiddenExpanded, hasRosterConstraint])
+  useEffect(() => {
+    if (!live) {
+      return
+    }
+
+    // Offline-owner ghosts belong only to this render. Shared roster state
+    // feeds merge caching, group membership, creation, and durable sync. These
+    // writes must settle after render: other subscribers of the same atoms
+    // would otherwise be updated while BotsPane was still rendering.
+    $lastRoster.set(roster.filter(row => !row?.ghost))
+
+    if (Array.isArray(data?.sources)) {
+      $lastSources.set(data.sources)
+    }
+
+    mergeServerMeta(activeSourceRoster, data?.fetchedAt || 0)
+    pullServerAvatars(activeSourceRoster)
+    trackInboundActivity(roster)
+    backfillMessagingProtocol(activeSourceRoster)
+    // React Query owns the stable server snapshot; derived arrays intentionally
+    // follow that snapshot rather than retriggering on their own atom writes.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [data])
+
+  // The roster has ANSWERED once data or a terminal error exists — that, not
+  // row count, is what lets this pane stop showing its loading state (an empty
+  // answer is a real answer; a pending one must not flash "No bots"). Keep the
+  // persisted-selection writes out of render: React may replay a render, but
+  // an abandoned render must never become a storage mutation.
+  useEffect(() => {
+    if (!data && !error) {
+      return
+    }
+
+    $rosterHydrated.set(true)
+
+    if (selectionHydrated) {
+      reconcileRosterSelection(roster, sourceSnapshot, allMeta)
+      const selected = selectedRosterBot(roster, $selectedRosterKey.get())
+
+      if ($botsPaneVisible.get() && !$groupChatWorkspace.get() && selected) {
+        setBotsWorkspaceOwner(botWorkspaceOwnerKey(selected), selected)
+      }
+    }
+  }, [data, error, selectionHydrated, roster, sourceSnapshot, allMeta])
+
+  const staleNotice =
+    error && !live && roster.length
+      ? 'Roster refresh failed — showing the last good list.' +
+        (gatewayUp ? '' : ' Waiting for the gateway to reconnect…')
+      : null
+
+  const groupChatMembers = groupChatName ? groupChatMemberBots(groupChatName, roster, allMeta) : []
+
+  if (shouldRenderGroupChatInPane(groupChatName) && groupChatMembers.length) {
+    return <GroupChatWorkspace group={groupChatName} members={groupChatMembers} />
+  }
+
+  const renderBotRow = (bot: RosterRow, keyPrefix = '') => (
+    <BotRow
+      bot={bot}
+      key={`${keyPrefix}${botRosterKey(bot)}`}
+      onDelete={setDeleting}
+      onEdit={setEditing}
+      onGroup={setGrouping}
+      showHandle={botNeedsHandleLabel(bot, roster, allMeta)}
+    />
+  )
+
+  const renderGroupRow = (row: { members: GroupMember[]; name: string }) => (
+    <GroupRow
+      active={groupChatName === row.name}
+      group={row.name}
+      key={`group:${row.name}`}
+      members={row.members}
+      needsYou={Boolean(groupNeedsYou[row.name])}
+      onDisband={setDeletingGroup}
+      onOpen={openGroupChat}
+    />
+  )
+
+  const renderGatewaySection = (section: ResolvedRosterGatewaySection) => {
+    const sectionId = `gateway:${section.id}`
+    const collapsed = rosterSectionCollapsed(sectionId)
+
+    return (
+      <div className="min-w-0" key={sectionId}>
+        <GatewaySectionHeading
+          collapsed={collapsed}
+          count={section.rows.length}
+          onToggle={() => toggleRosterSection(sectionId)}
+          option={section.option}
+        />
+        {collapsed ? null : (
+          <div className="grid min-w-0 gap-0.5">{section.rows.map(row => renderBotRow(row.bot, `${section.id}:`))}</div>
+        )}
+      </div>
+    )
+  }
+
+  const renderGroupChatSection = () => {
+    const sectionId = 'group-chats'
+    const collapsed = rosterSectionCollapsed(sectionId)
+
+    return (
+      <div className="min-w-0" key={sectionId}>
+        <RosterSectionHeader
+          collapsed={collapsed}
+          count={sortedGroupRows.length}
+          icon="organization"
+          label={b.roster.groupChats}
+          onToggle={() => toggleRosterSection(sectionId)}
+          tip={`${sortedGroupRows.length} global group chat${sortedGroupRows.length === 1 ? '' : 's'}`}
+        />
+        {collapsed ? null : <div className="grid min-w-0 gap-0.5">{sortedGroupRows.map(renderGroupRow)}</div>}
+      </div>
+    )
+  }
+
+  const renderHiddenGatewaySection = (section: ResolvedRosterGatewaySection) => (
+    <div className="min-w-0" key={`hidden-gateway:${section.id}`}>
+      <div className="flex min-w-0 items-center gap-1.5 px-2 py-1 text-[0.625rem] font-semibold uppercase tracking-wider text-(--ui-text-quaternary)">
+        <GatewayKindGlyph kind={section.option?.kind} />
+        <span className="min-w-0 flex-1 truncate">
+          {section.option?.label || section.option?.connectionId || 'Current gateway'}
+        </span>
+        <span className="shrink-0 font-normal tabular-nums">{section.rows.length}</span>
+      </div>
+      {section.rows.map(row => renderBotRow(row.bot, `hidden:${section.id}:`))}
+    </div>
+  )
+
+  return (
+    <div className="flex h-full flex-col">
+      <div className="flex items-center justify-between gap-2 px-2.5 pt-2.5 pb-1.5">
+        <span className="text-[0.6875rem] font-semibold uppercase tracking-wider text-(--ui-text-quaternary)">
+          Bots
+        </span>
+        <div className="flex items-center gap-0.5">
+          <Tip
+            label={activityToasts ? 'Activity toasts on — click to silence' : 'Activity toasts off — click to enable'}
+          >
+            <Button
+              className="rounded-md text-(--ui-text-tertiary) hover:text-foreground"
+              onClick={() => setActivityToasts(!activityToasts)}
+              size="icon-xs"
+              variant="ghost"
+            >
+              <Codicon name={activityToasts ? 'bell' : 'bell-slash'} />
+            </Button>
+          </Tip>
+          <DropdownMenu>
+            <Tip label="New…">
+              <DropdownMenuTrigger asChild>
+                <Button
+                  aria-label={b.roster.newBotOrGroup}
+                  className="rounded-md text-(--ui-text-tertiary) hover:text-foreground"
+                  size="icon-xs"
+                  variant="ghost"
+                >
+                  <Codicon name="add" />
+                </Button>
+              </DropdownMenuTrigger>
+            </Tip>
+            <DropdownMenuContent align="end">
+              <DropdownMenuItem onSelect={() => setCreateOpen(true)}>
+                <Codicon className="mr-1.5" name="hubot" />
+                {b.bot.newTitle}
+              </DropdownMenuItem>
+              <DropdownMenuItem disabled={activeSourceRoster.length < 2} onSelect={() => setGroupCreateOpen(true)}>
+                <Codicon className="mr-1.5" name="organization" />
+                {b.group.newTitle}
+              </DropdownMenuItem>
+            </DropdownMenuContent>
+          </DropdownMenu>
+        </div>
+      </div>
+      {showRosterTools ? (
+        <div className="flex min-w-0 items-center gap-1 px-2.5 pb-1.5">
+          {showRosterSearch ? (
+            <SearchField
+              aria-label={b.roster.search}
+              containerClassName={cn('min-w-0 flex-1', query ? 'opacity-100!' : 'opacity-50 focus-within:opacity-100')}
+              inputClassName="w-full text-[0.75rem] placeholder:text-(--ui-text-tertiary)"
+              key={'roster-search'}
+              onChange={setQuery}
+              placeholder={b.roster.searchPlaceholder}
+              value={query}
+            />
+          ) : (
+            <span className="min-w-0 flex-1" key={'roster-search-spacer'} />
+          )}
+          {showRosterFilters ? (
+            <DropdownMenu key={'roster-filters'}>
+              <Tip label={activeFilterCount ? `Filters (${activeFilterCount} active)` : 'Filter roster'}>
+                <DropdownMenuTrigger asChild>
+                  <Button
+                    aria-label={activeFilterCount ? `Filter roster, ${activeFilterCount} active` : 'Filter roster'}
+                    className={cn(
+                      'size-7 shrink-0 rounded-md text-(--ui-text-tertiary) hover:text-foreground',
+                      activeFilterCount && 'text-(--ui-accent)'
+                    )}
+                    size="icon-xs"
+                    variant="ghost"
+                  >
+                    <Codicon name="list-filter" />
+                  </Button>
+                </DropdownMenuTrigger>
+              </Tip>
+              <DropdownMenuContent align="end">
+                {(
+                  [
+                    ['all', b.roster.botsAndGroups],
+                    ['bots', b.roster.botsOnly],
+                    ['groups', b.roster.groupsOnly]
+                  ] as [RosterKindFilter, string][]
+                ).map(([value, label]) => (
+                  <DropdownMenuItem key={`kind:${value}`} onSelect={() => setRowKindFilter(value)}>
+                    <span className="min-w-0 flex-1">{label}</span>
+                    {rowKindFilter === value ? <Codicon name="check" /> : null}
+                  </DropdownMenuItem>
+                ))}
+                <DropdownMenuSeparator />
+                {(
+                  [
+                    ['all', b.roster.anyActivity],
+                    ['active', b.roster.activeNow],
+                    ['recent', b.roster.recentlyActive],
+                    ['older', b.roster.older]
+                  ] as [RosterActivityFilter, string][]
+                ).map(([value, label]) => (
+                  <DropdownMenuItem key={`activity:${value}`} onSelect={() => setActivityFilter(value)}>
+                    <span className="min-w-0 flex-1">{label}</span>
+                    {activityFilter === value ? <Codicon name="check" /> : null}
+                  </DropdownMenuItem>
+                ))}
+                {gatewayOptions.length > 1 ? <DropdownMenuSeparator /> : null}
+                {gatewayOptions.length > 1 ? (
+                  <DropdownMenuItem onSelect={() => setGatewayFilter('all')}>
+                    <Codicon className="mr-1.5" name="globe" />
+                    <span className="min-w-0 flex-1">All gateways</span>
+                    {gatewayFilter === 'all' ? <Codicon name="check" /> : null}
+                  </DropdownMenuItem>
+                ) : null}
+                {gatewayOptions.length > 1
+                  ? gatewayOptions.map(option => {
+                      const status = botSourceStatus({
+                        sourceError: option.error,
+                        sourceReachable: option.reachable
+                      })
+
+                      return (
+                        <DropdownMenuItem
+                          key={option.connectionId}
+                          onSelect={() => setGatewayFilter(option.connectionId)}
+                        >
+                          <GatewayKindGlyph
+                            className={cn('mr-1.5', !status.available && 'text-amber-600 dark:text-amber-300')}
+                            kind={option.kind}
+                          />
+                          <span className="min-w-0 flex-1 truncate">{option.label || option.connectionId}</span>
+                          <span className="text-[0.625rem] tabular-nums text-(--ui-text-quaternary)">
+                            {option.count}
+                          </span>
+                          {gatewayFilter === option.connectionId ? <Codicon name="check" /> : null}
+                        </DropdownMenuItem>
+                      )
+                    })
+                  : []}
+                {activeFilterCount ? <DropdownMenuSeparator /> : null}
+                {activeFilterCount ? (
+                  <DropdownMenuItem
+                    onSelect={() => {
+                      setRowKindFilter('all')
+                      setActivityFilter('all')
+                      setGatewayFilter('all')
+                    }}
+                  >
+                    {b.roster.clearFilters}
+                  </DropdownMenuItem>
+                ) : null}
+              </DropdownMenuContent>
+            </DropdownMenu>
+          ) : null}
+        </div>
+      ) : null}
+      {staleNotice ? (
+        <div className="mx-2.5 mb-1 rounded-md bg-(--chrome-action-hover) px-2 py-1.5 text-[0.6875rem] text-(--ui-text-tertiary)">
+          {staleNotice}
+        </div>
+      ) : null}
+      {(isLoading || initialRosterLoading) && !roster.length ? (
+        <div className="flex flex-1 items-center justify-center">
+          <GlyphSpinner className="text-(--ui-text-tertiary)" spinner="breathe" />
+        </div>
+      ) : error && !roster.length ? (
+        <div className="grid gap-2 px-3 py-4 text-xs text-(--ui-text-tertiary)">
+          <div>
+            {gatewayUp
+              ? b.roster.rosterUnavailable(error instanceof Error ? error.message : 'gateway error')
+              : b.roster.waitingForGateway}
+          </div>
+          <Button className="justify-self-start" onClick={() => void refetch()} size="sm" variant="secondary">
+            {b.roster.retryNow}
+          </Button>
+        </div>
+      ) : roster.length === 0 ? (
+        <PanelEmpty description={b.roster.emptyDesc} icon="hubot" title={b.roster.emptyTitle} />
+      ) : allBotsHidden && !hiddenExpanded ? (
+        <div className="grid content-start gap-2 px-3 py-4 text-xs text-(--ui-text-tertiary)">
+          <div className="flex items-center gap-1.5 font-medium text-(--ui-text-secondary)">
+            <Codicon className="text-(--ui-text-quaternary)" name="eye-closed" />
+            {b.roster.allHidden}
+          </div>
+          <p className="leading-relaxed">{b.roster.allHiddenDesc}</p>
+          <Button
+            className="justify-self-start"
+            onClick={() => $showHiddenBots.set(true)}
+            size="sm"
+            variant="secondary"
+          >
+            {b.roster.showHidden}
+          </Button>
+        </div>
+      ) : rosterRows.length === 0 && matchingHiddenBots.length === 0 ? (
+        <div aria-live="polite" className="flex min-h-0 flex-1 flex-col" role="status">
+          <PanelEmpty
+            description={
+              query.trim()
+                ? selectedGateway
+                  ? b.roster.noMatchQueryOn(query.trim(), String(selectedGateway.label))
+                  : b.roster.noMatchQuery(query.trim())
+                : selectedGateway
+                  ? b.roster.noMatchFiltersOn(String(selectedGateway.label))
+                  : b.roster.noMatchFilters
+            }
+            icon="search"
+          />
+        </div>
+      ) : (
+        <div className="min-h-0 flex-1 overflow-y-auto overscroll-contain">
+          <div className="grid w-full min-w-0 gap-0.5 px-1.5 pb-2">
+            {showGatewaySections
+              ? [
+                  sortedGroupRows.length ? renderGroupChatSection() : null,
+                  ...gatewaySections.sections.map(renderGatewaySection)
+                ].filter(Boolean)
+              : rosterRows.map(row => (row.kind === 'group' ? renderGroupRow(row) : renderBotRow(row.bot)))}
+            {showHiddenSection ? (
+              <div
+                className="mt-1 border-t border-(--ui-stroke-tertiary) pt-1"
+                key={'hidden-section'}
+                ref={hiddenSectionRef}
+              >
+                {hasRosterConstraint ? (
+                  <div className="flex w-full items-center gap-1 px-2 py-1.5 text-[0.6875rem] font-medium text-(--ui-text-tertiary)">
+                    <Codicon name="eye-closed" />
+                    <span>Hidden</span>
+                    <span className="text-(--ui-text-quaternary)">{matchingHiddenBots.length}</span>
+                  </div>
+                ) : (
+                  <RowButton
+                    aria-expanded={hiddenExpanded}
+                    className="flex w-full items-center gap-1 rounded-md px-2 py-1.5 text-left text-[0.6875rem] font-medium text-(--ui-text-tertiary) transition-colors hover:bg-(--chrome-action-hover) hover:text-foreground"
+                    onClick={() => $showHiddenBots.set(!hiddenExpanded)}
+                  >
+                    <DisclosureCaret open={hiddenExpanded} />
+                    <span>Hidden</span>
+                    <span className="text-(--ui-text-quaternary)">{hiddenBots.length}</span>
+                  </RowButton>
+                )}
+                {showHiddenRows ? (
+                  matchingHiddenBots.length ? (
+                    hiddenGatewaySections.sectioned ? (
+                      hiddenGatewaySections.sections.map(renderHiddenGatewaySection)
+                    ) : (
+                      matchingHiddenBots.map((bot: RosterRow) => renderBotRow(bot, 'hidden:'))
+                    )
+                  ) : (
+                    <div className="px-2 py-2 text-xs text-(--ui-text-quaternary)">{b.roster.noHiddenMatch}</div>
+                  )
+                ) : null}
+              </div>
+            ) : null}
+          </div>
+        </div>
+      )}
+      <CreateAgentDialog
+        onClose={() => {
+          setCreateOpen(false)
+          void refetch()
+        }}
+        open={createOpen}
+        roster={activeSourceRoster}
+      />
+      <CreateGroupChatDialog
+        onClose={() => setGroupCreateOpen(false)}
+        onCreated={groupName => openGroupChat(groupName)}
+        open={groupCreateOpen} // Full multi-source roster: group chats can seat bots from other
+        // registered connections — their turns route to their own machines.
+        roster={roster}
+      />
+      <EditProfileDialog
+        bot={editing}
+        onClose={() => {
+          setEditing(null)
+          void refetch()
+        }}
+        open={Boolean(editing)}
+      />
+      {grouping ? <GroupDialog bot={grouping} onClose={() => setGrouping(null)} /> : null}
+      <ConfirmDialog
+        busyLabel="Deleting…"
+        confirmLabel={t.common.delete}
+        description={
+          deleting ? (
+            <span>
+              {'This will permanently delete the bot '}
+              <span className="font-medium text-foreground">{deleting.name}</span>
+              {' and its associated Hermes profile at '}
+              <span className="font-mono text-xs">{deleting.path}</span>. This cannot be undone.
+            </span>
+          ) : null
+        }
+        destructive
+        doneLabel="Deleted"
+        onClose={() => setDeleting(null)}
+        onConfirm={async () => {
+          if (!deleting) {
+            return
+          }
+
+          const name = deleting.name
+          await deleteBot(deleting)
+          await refetch()
+          host.notify({
+            kind: 'success',
+            message: `Deleted profile ${name}`
+          })
+        }}
+        open={Boolean(deleting)}
+        title={b.bot.deleteTitle}
+      />
+      <ConfirmDialog
+        busyLabel="Deleting…"
+        confirmLabel={b.group.deleteAction}
+        description={
+          deletingGroup
+            ? `This removes “${deletingGroup.name}” from its bots and clears the shared room log. The bots and their individual chats are kept.`
+            : null
+        }
+        destructive
+        doneLabel="Deleted"
+        onClose={() => setDeletingGroup(null)}
+        onConfirm={async () => {
+          if (!deletingGroup) {
+            return
+          }
+
+          await disbandGroupChat(deletingGroup.name, deletingGroup.members)
+          host.notify({
+            kind: 'success',
+            message: `Deleted group “${deletingGroup.name}”`
+          })
+        }}
+        open={Boolean(deletingGroup)}
+        title={b.group.deleteTitle}
+      />
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/roster-sections.tsx b/apps/desktop/src/plugins/hermes-bots/roster-sections.tsx
new file mode 100644
index 000000000000..dd4cd0137844
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/roster-sections.tsx
@@ -0,0 +1,302 @@
+/**
+ * How the roster groups and labels what it lists: the gateway filter, the
+ * per-connection bucketing, and the foldable headings those buckets render.
+ *
+ * Presentation below the pane. The headings take everything they draw as
+ * props and the bucketing is pure, so the roster pane can compose them
+ * without either half knowing about a bot row.
+ */
+
+import { Codicon, ConnectionGlyph, DisclosureCaret, RowButton, Tip } from '@hermes/plugin-sdk'
+
+import { botHandle, botRosterKey, botSourceStatus, filterBots } from './data'
+import { displayName } from './labels'
+import { botRosterMeta } from './routing'
+import type { BotMeta, GatewaySource, RosterRow } from './types'
+
+export function filterBotsByGateway(roster: RosterRow[], connectionId: string) {
+  if (!connectionId || connectionId === 'all') {
+    return roster
+  }
+
+  return (roster || []).filter(bot => String(bot?.connectionId || '') === connectionId)
+}
+
+export function botNeedsHandleLabel(bot: RosterRow, roster: RosterRow[], metaByName: Record<string, BotMeta>) {
+  const identity = displayName(bot, botRosterMeta(bot, metaByName)).trim().toLowerCase()
+  const connectionId = String(bot?.connectionId || '')
+
+  return (roster || []).some(
+    candidate =>
+      botRosterKey(candidate) !== botRosterKey(bot) &&
+      String(candidate?.connectionId || '') === connectionId &&
+      displayName(candidate, botRosterMeta(candidate, metaByName)).trim().toLowerCase() === identity &&
+      botHandle(candidate.name, candidate) !== botHandle(bot.name, bot)
+  )
+}
+
+export function groupMatchesRosterFilters(
+  name: string,
+  members: RosterRow[],
+  metaByName: Record<string, BotMeta>,
+  query: string,
+  connectionId: string
+) {
+  const inGateway = filterBotsByGateway(members, connectionId)
+
+  if (connectionId && connectionId !== 'all' && inGateway.length === 0) {
+    return false
+  }
+
+  const needle = String(query || '')
+    .trim()
+    .toLowerCase()
+    .replace(/^@/, '')
+
+  return (
+    !needle ||
+    String(name || '')
+      .toLowerCase()
+      .includes(needle) ||
+    filterBots(inGateway, metaByName, needle).length > 0
+  )
+}
+
+/** A gateway source as the roster's picker carries it: a running row count,
+ *  and `reachable` widened to the roster row's null ("status unknown"), which
+ *  GatewaySource does not model. */
+interface RosterGatewayOption extends Omit<GatewaySource, 'reachable'> {
+  count?: number
+  reachable?: boolean | null
+}
+
+/** A sidebar roster row (`{ kind, bot, … }`), or a bare roster row for
+ *  callers that hand the bots over directly. */
+interface RosterGatewayRow extends Partial<RosterRow> {
+  bot?: RosterRow
+}
+
+interface RosterGatewaySection<TRow extends RosterGatewayRow = RosterGatewayRow> {
+  id: string
+  option: null | RosterGatewayOption
+  rows: TRow[]
+}
+
+/** Sections built from rows that always carry their resolved roster row. */
+export type ResolvedRosterGatewaySection = RosterGatewaySection<RosterGatewayRow & { bot: RosterRow }>
+
+export function rosterGatewayOptions(sources: GatewaySource[], roster: RosterRow[]) {
+  const byId = new Map<string, RosterGatewayOption & { count: number }>()
+
+  for (const source of Array.isArray(sources) ? sources : []) {
+    const id = String(source?.connectionId || '').trim()
+
+    if (id) {
+      byId.set(id, {
+        ...source,
+        connectionId: id,
+        count: 0
+      })
+    }
+  }
+
+  for (const bot of roster || []) {
+    const id = String(bot?.connectionId || '').trim()
+
+    if (!id) {
+      continue
+    }
+
+    const source = byId.get(id) || {
+      connectionId: id,
+      kind: bot.connectionKind,
+      label: bot.connectionLabel || id,
+      reachable: bot.sourceReachable,
+      error: bot.sourceError,
+      count: 0
+    }
+
+    source.count += 1
+    byId.set(id, source)
+  }
+
+  return [...byId.values()].sort((a, b) =>
+    String(a.label || a.connectionId).localeCompare(String(b.label || b.connectionId), undefined, {
+      sensitivity: 'base'
+    })
+  )
+}
+
+export function rosterGatewaySections<TRow extends RosterGatewayRow>(
+  botRows: TRow[],
+  gatewayOptions: RosterGatewayOption[],
+  gatewayFilter = 'all'
+): { sectioned: boolean; sections: RosterGatewaySection<TRow>[] } {
+  const rows = Array.isArray(botRows) ? botRows : []
+  const options = Array.isArray(gatewayOptions) ? gatewayOptions : []
+
+  if (gatewayFilter !== 'all' || options.length <= 1) {
+    return {
+      sectioned: false,
+      sections: [
+        {
+          id: 'all',
+          option: null,
+          rows
+        }
+      ]
+    }
+  }
+
+  const byId = new Map<string, TRow[]>()
+
+  for (const row of rows) {
+    const bot = row?.bot || row
+    const id = String(bot?.connectionId || 'legacy').trim() || 'legacy'
+    const bucket = byId.get(id) || []
+    bucket.push(row)
+    byId.set(id, bucket)
+  }
+
+  const known = new Set<string>()
+  const sections: RosterGatewaySection<TRow>[] = []
+
+  for (const option of options) {
+    const id = String(option?.connectionId || '').trim()
+    const sectionRows = byId.get(id)
+
+    if (!id || !sectionRows?.length) {
+      continue
+    }
+
+    known.add(id)
+    sections.push({
+      id,
+      option,
+      rows: sectionRows
+    })
+  }
+
+  for (const [id, sectionRows] of byId) {
+    if (known.has(id)) {
+      continue
+    }
+
+    const bot = sectionRows[0]?.bot || sectionRows[0]
+    sections.push({
+      id,
+      option: {
+        connectionId: id,
+        kind: bot?.connectionKind || 'remote',
+        label: bot?.connectionLabel || (id === 'legacy' ? 'Current gateway' : id),
+        reachable: bot?.sourceReachable,
+        error: bot?.sourceError
+      },
+      rows: sectionRows
+    })
+  }
+
+  return {
+    sectioned: true,
+    sections
+  }
+}
+
+/** Roster rows carry the kind as a loose string (it arrives off the wire).
+ *  Anything the glyph doesn't recognise is a remote gateway. */
+function connectionKind(kind?: string) {
+  return kind === 'cloud' || kind === 'local' || kind === 'ssh' ? kind : ('remote' as const)
+}
+
+interface GatewayKindGlyphProps {
+  className?: string
+  kind?: string
+}
+
+/** The gateway switcher's glyph, keyed by kind rather than by a whole
+ *  connection record — the roster only ever knows the kind. */
+export function GatewayKindGlyph({ className, kind }: GatewayKindGlyphProps) {
+  return <ConnectionGlyph className={className} connection={{ kind: connectionKind(kind) }} />
+}
+
+/** Foldable roster heading. It organizes rows visually but never supplies or
+ * reconstructs ownership; every action still receives the full bot row. */
+interface RosterSectionHeaderProps {
+  collapsed: boolean
+  count: number
+  gatewayKind?: string
+  icon?: string
+  label: string
+  onToggle: () => void
+  status?: { available: boolean; label: string }
+  tip?: string
+}
+
+export function RosterSectionHeader({
+  collapsed,
+  count,
+  gatewayKind,
+  icon,
+  label,
+  onToggle,
+  status,
+  tip
+}: RosterSectionHeaderProps) {
+  const button = (
+    <RowButton
+      aria-expanded={!collapsed}
+      className="mt-1 flex w-full min-w-0 items-center gap-1.5 rounded-md px-2 py-1.5 text-left text-[0.6875rem] font-semibold uppercase tracking-wider text-(--ui-text-quaternary) transition-colors hover:bg-(--chrome-action-hover) hover:text-(--ui-text-secondary)"
+      onClick={onToggle}
+    >
+      <DisclosureCaret open={!collapsed} />
+      {gatewayKind ? (
+        <GatewayKindGlyph kind={gatewayKind} />
+      ) : (
+        // TODO(bot-mode-types): neither `gatewayKind` nor `icon` is required, so a header
+        // given neither renders `codicon-undefined`. Both current callers pass exactly one.
+        // @ts-expect-error `icon` is optional here; Codicon's `name` is required.
+        <Codicon className="shrink-0" name={icon} />
+      )}
+      <span className="flex min-w-0 items-center gap-1">
+        <span className="min-w-0 truncate">{label}</span>
+        {status && !status.available ? <span className="sr-only">{status.label}</span> : null}
+      </span>
+      <span aria-hidden className="min-w-0 flex-1" />
+      <span className="shrink-0 font-normal tabular-nums text-(--ui-text-quaternary)">{count}</span>
+      {status && !status.available ? (
+        <Codicon aria-hidden className="shrink-0 text-amber-600 dark:text-amber-300" name="debug-disconnect" />
+      ) : null}
+    </RowButton>
+  )
+
+  return tip ? <Tip label={tip}>{button}</Tip> : button
+}
+
+interface GatewaySectionHeadingProps {
+  collapsed: boolean
+  count: number
+  onToggle: () => void
+  option?: RosterGatewayOption | null
+}
+
+export function GatewaySectionHeading({ collapsed, count, onToggle, option }: GatewaySectionHeadingProps) {
+  const status = botSourceStatus({
+    sourceError: option?.error,
+    sourceReachable: option?.reachable
+  })
+
+  const label = option?.label || option?.connectionId || 'Current gateway'
+  const kind = option?.kind || 'remote'
+
+  return (
+    <RosterSectionHeader
+      collapsed={collapsed}
+      count={count}
+      gatewayKind={kind}
+      label={label}
+      onToggle={onToggle}
+      status={status}
+      tip={`${label} · ${kind} · ${status.label}`}
+    />
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/routing.test.ts b/apps/desktop/src/plugins/hermes-bots/routing.test.ts
new file mode 100644
index 000000000000..e48851e25323
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/routing.test.ts
@@ -0,0 +1,288 @@
+/**
+ * Cross-connection routing: how a roster row resolves its owning connection,
+ * how RPCs ride that owner, and how a configured Desktop alias keeps its
+ * friendly identity after the backend it points at answers the roster.
+ *
+ * #89131 is the alias half: a per-profile Cloud alias ("moxie" → exact Cloud
+ * connection → backend targetProfile "default") lost its name the moment the
+ * hosted session activated, because the row that came back was keyed
+ * (cloud-abc, default) — a different identity than the alias meta. It read as
+ * the raw Cloud hostname, or as generic "Hermes" when Cloud was the only
+ * source.
+ *
+ * Drives the real `routing` + `labels` modules; only the SDK `host` is mocked.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { displayName } from './labels'
+import {
+  aliasIdentityFor,
+  beginAliasRouteIndex,
+  botConnectionRoute,
+  botRosterMeta,
+  indexAliasRoutes,
+  requestForBot,
+  resolveBotConnectionRoute
+} from './routing'
+import type { ProfileRoute, RosterRow } from './types'
+
+const { hostMock } = vi.hoisted(() => ({
+  hostMock: {
+    request: vi.fn(),
+    requestProfile: vi.fn(),
+    state: { connectionId: { get: vi.fn(() => 'local') } }
+  }
+}))
+
+vi.mock('@hermes/plugin-sdk', () => ({ host: hostMock }))
+
+const MOXIE_ROUTE: ProfileRoute = {
+  connectionId: 'cloud-abc',
+  mode: 'remote',
+  profile: 'moxie',
+  targetProfile: 'default'
+}
+
+/** The hosted backend's own roster row after alias handoff: the Cloud
+ *  connection answers as its root profile, so the row identity is
+ *  (cloud-abc, default) — NOT the alias key. */
+const hostedRow = {
+  connectionId: 'cloud-abc',
+  connectionLabel: 'cloud.example.com',
+  name: 'default',
+  remoteSource: true,
+  route: { connectionId: 'cloud-abc', mode: 'remote', profile: 'default', targetProfile: 'default' },
+  sourceScoped: true,
+  targetProfile: 'default'
+} as RosterRow
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  hostMock.state.connectionId.get.mockReturnValue('local')
+  indexAliasRoutes([])
+})
+
+describe('alias identity survives the hosted handoff (#89131)', () => {
+  it('names the backend row after the alias, through every meta generation', () => {
+    indexAliasRoutes([
+      { connectionId: 'local', mode: 'local', profile: 'default', targetProfile: 'default' },
+      MOXIE_ROUTE
+    ])
+
+    // No stored title anywhere: the alias NAME is still the identity.
+    expect(displayName(hostedRow, null)).toBe('Moxie')
+
+    // The alias's Bot Mode title claims the row under either meta key shape —
+    // aliases predate the v2 (connection-qualified) migration on mixed setups.
+    const metaV2 = { 'cloud-abc::moxie': { title: 'Moxie' } }
+
+    expect(botRosterMeta(hostedRow, metaV2)).toBe(metaV2['cloud-abc::moxie'])
+    expect(displayName(hostedRow, botRosterMeta(hostedRow, metaV2))).toBe('Moxie')
+
+    const metaV1 = { moxie: { title: 'Moxie ✨' } }
+
+    expect(displayName(hostedRow, botRosterMeta(hostedRow, metaV1))).toBe('Moxie ✨')
+  })
+
+  it('renders the sole Cloud-only default as the alias, not "Hermes"', () => {
+    // Global route is Cloud: the active gateway IS the Cloud connection and
+    // profiles.list returns one unannotated rich `default` row.
+    hostMock.state.connectionId.get.mockReturnValue('cloud-abc')
+    indexAliasRoutes([MOXIE_ROUTE])
+
+    expect(displayName({ name: 'default' }, null)).toBe('Moxie')
+    // A user-set title still wins over the alias name.
+    expect(displayName({ name: 'default' }, { title: 'Custom' })).toBe('Custom')
+  })
+
+  it('never leaks the alias onto a same-named default on another connection', () => {
+    indexAliasRoutes([MOXIE_ROUTE])
+
+    const otherDefault = {
+      ...hostedRow,
+      connectionId: 'other-conn',
+      connectionLabel: 'Personal',
+      route: undefined
+    } as RosterRow
+
+    expect(aliasIdentityFor(otherDefault)).toBeNull()
+    expect(displayName(otherDefault, null)).toBe('Personal')
+    // Local default while the ACTIVE gateway is local: untouched "Hermes".
+    expect(displayName({ name: 'default' }, null)).toBe('Hermes')
+  })
+
+  it('fails closed when two aliases claim one backend row', () => {
+    indexAliasRoutes([
+      MOXIE_ROUTE,
+      { connectionId: 'cloud-abc', mode: 'remote', profile: 'roxie', targetProfile: 'default' }
+    ])
+
+    expect(aliasIdentityFor(hostedRow)).toBeNull()
+    // Ambiguous: fall back to the source label, not a guessed alias.
+    expect(displayName(hostedRow, null)).toBe('cloud.example.com')
+  })
+
+  it('never lets the alias row claim its own alias entry', () => {
+    indexAliasRoutes([MOXIE_ROUTE])
+
+    const aliasRow = {
+      connectionId: 'cloud-abc',
+      name: 'moxie',
+      route: { ...MOXIE_ROUTE },
+      sourceScoped: true,
+      targetProfile: 'default'
+    } as RosterRow
+
+    expect(aliasIdentityFor(aliasRow)).toBeNull()
+    expect(displayName(aliasRow, null)).toBe('Moxie')
+  })
+
+  it('keeps only genuine aliases, and drops stale claims on refresh', () => {
+    indexAliasRoutes([{ connectionId: 'local', mode: 'local', profile: 'rune', targetProfile: 'rune' }, MOXIE_ROUTE])
+
+    expect(aliasIdentityFor(hostedRow)).toBeTruthy()
+
+    // Alias removed from config → next inventory drops the claim.
+    indexAliasRoutes([{ connectionId: 'local', mode: 'local', profile: 'rune', targetProfile: 'rune' }])
+
+    expect(aliasIdentityFor(hostedRow)).toBeNull()
+    expect(displayName(hostedRow, null)).toBe('cloud.example.com')
+  })
+})
+
+describe('overlapping index rebuilds', () => {
+  const deferred = () => {
+    let resolve!: (routes: ProfileRoute[]) => void
+
+    const promise = new Promise<ProfileRoute[]>(settle => {
+      resolve = settle
+    })
+
+    return { promise, resolve }
+  }
+
+  /** The rebuild exactly as useRoster runs it: claim the epoch, read the
+   *  route inventory over the wire, then replace the index wholesale. */
+  const rebuild = async (read: Promise<ProfileRoute[]>) => {
+    const epoch = beginAliasRouteIndex()
+
+    indexAliasRoutes(await read, epoch)
+  }
+
+  const STALE_ROUTE: ProfileRoute = {
+    connectionId: 'cloud-abc',
+    mode: 'remote',
+    profile: 'stale',
+    targetProfile: 'default'
+  }
+
+  it('keeps the newer routes when an older read resolves last', async () => {
+    const older = deferred()
+    const newer = deferred()
+
+    const first = rebuild(older.promise)
+    const second = rebuild(newer.promise)
+
+    newer.resolve([MOXIE_ROUTE])
+    await second
+
+    older.resolve([STALE_ROUTE])
+    await first
+
+    expect(aliasIdentityFor(hostedRow)?.name).toBe('moxie')
+  })
+
+  it('still adopts the newest routes once rebuilds stop overlapping', async () => {
+    await rebuild(Promise.resolve([MOXIE_ROUTE]))
+
+    expect(aliasIdentityFor(hostedRow)?.name).toBe('moxie')
+
+    await rebuild(Promise.resolve([STALE_ROUTE]))
+
+    expect(aliasIdentityFor(hostedRow)?.name).toBe('stale')
+  })
+})
+
+describe('a row without a reachable owner', () => {
+  it('reports a typed status instead of throwing, while dispatch still fails closed', () => {
+    expect(resolveBotConnectionRoute({ name: 'plain' })).toEqual({ route: null, status: 'not_scoped' })
+    expect(resolveBotConnectionRoute({ connectionId: 'vera', name: 'ops', sourceScoped: true })).toMatchObject({
+      route: { connectionId: 'vera', mode: 'remote', profile: 'ops', targetProfile: 'ops' },
+      status: 'resolved'
+    })
+
+    const orphan = { name: 'ops', remoteSource: true } as RosterRow
+
+    expect(resolveBotConnectionRoute(orphan)).toMatchObject({ profile: 'ops', route: null, status: 'owner_removed' })
+    // The strict wrapper real dispatch uses must still refuse — a row whose
+    // connection was deleted has no ambient fallback to borrow.
+    expect(() => botConnectionRoute(orphan)).toThrow(/no connection owner/)
+  })
+
+  it('a passive meta lookup on an orphaned row reads as "no route", never a throw', () => {
+    const orphan = { name: 'ops', remoteSource: true } as RosterRow
+
+    expect(botRosterMeta(orphan, { ops: { title: 'Ops' } })).toBeFalsy()
+  })
+})
+
+describe('requestForBot rides the bot’s own source', () => {
+  it('pins same-name bots to their own connection under concurrent requests', async () => {
+    hostMock.requestProfile.mockImplementation(async (route: ProfileRoute) => ({ from: route.connectionId }))
+
+    const rows = ['vera', 'mac-mini'].map(
+      connectionId =>
+        ({
+          connectionId,
+          name: 'default',
+          remoteSource: true,
+          sourceScoped: true
+        }) as RosterRow
+    )
+
+    const answers = await Promise.all(rows.map(bot => requestForBot<{ from: string }>(bot, 'profiles.list', {})))
+
+    expect(answers.map(answer => answer.from)).toEqual(['vera', 'mac-mini'])
+    expect(hostMock.request).not.toHaveBeenCalled()
+  })
+
+  it('rewrites the logical profile to the backend target on the wire', async () => {
+    hostMock.requestProfile.mockResolvedValue({})
+
+    await requestForBot({ name: 'moxie', route: MOXIE_ROUTE, sourceScoped: true } as RosterRow, 'profiles.configure', {
+      name: 'moxie',
+      soul: '# hi'
+    })
+
+    expect(hostMock.requestProfile).toHaveBeenCalledWith(MOXIE_ROUTE, 'profiles.configure', {
+      name: 'default',
+      soul: '# hi'
+    })
+  })
+
+  it('fails closed rather than falling back to the ambient request', async () => {
+    // A scoped row whose shell predates requestProfile must NOT silently
+    // execute against whichever gateway happens to be active.
+    const scoped = { connectionId: 'vera', name: 'ops', sourceScoped: true } as RosterRow
+
+    hostMock.requestProfile = undefined as never
+
+    await expect(requestForBot(scoped, 'profiles.list', {})).rejects.toThrow(/Cannot route profiles\.list/)
+    expect(hostMock.request).not.toHaveBeenCalled()
+
+    hostMock.requestProfile = vi.fn()
+  })
+
+  it('coerces a JSON-RPC rejection into an Error with a string name (#94471)', async () => {
+    // React 19 formats query errors with `(error.name || '').trim()`; a
+    // numeric JSON-RPC `name` crashed the Routines pane and hid the cause.
+    hostMock.request.mockRejectedValue({ code: -32000, message: 'profile busy', name: -32000 })
+
+    const error = await requestForBot({ name: 'ops' }, 'cron.list', {}).catch((thrown: unknown) => thrown)
+
+    expect(error).toBeInstanceOf(Error)
+    expect(typeof (error as Error).name).toBe('string')
+    expect((error as Error).message).toBe('profile busy')
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/routing.ts b/apps/desktop/src/plugins/hermes-bots/routing.ts
new file mode 100644
index 000000000000..6631207e40c1
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/routing.ts
@@ -0,0 +1,424 @@
+/**
+ * Cross-connection routing: resolving a roster row's owning connection, the
+ * RPC door that rides that owner, and the alias identity that keeps a
+ * configured Desktop alias attached to the backend row it activates into.
+ *
+ * The bottom of the Bot Mode module graph — it imports no sibling module, so
+ * everything else can dispatch through it without a cycle.
+ */
+
+import { host } from '@hermes/plugin-sdk'
+
+import type { BotMeta, ProfileRoute, RosterRow } from './types'
+
+export function botRouteKey(route: ProfileRoute): string {
+  return `${route.connectionId}::${route.profile}`
+}
+
+// ── cross-connection routing ─────────────────────────────────────────────────
+// A bot from another registered connection (remoteSource rows) is reached
+// through host.requestProfile with a route descriptor; local bots keep the
+// active-gateway door. Feature-detected: older desktops without
+// requestProfile simply have no remote routes (callers fall back / disable).
+
+/** Outcome of resolving a row's owning connection. `profile` is only carried
+ *  on the `owner_removed` branch, where the strict wrapper needs it for the
+ *  error message. */
+interface BotRouteResolution {
+  profile?: string
+  route: ProfileRoute | null
+  status: 'not_scoped' | 'owner_removed' | 'resolved'
+}
+
+/** Non-throwing resolver behind botConnectionRoute(). Returns a typed status
+ *  instead of throwing, so passive callers (display/meta lookups) can branch
+ *  on `resolved | owner_removed | not_scoped` rather than catching whatever
+ *  exception the strict wrapper below happens to throw. */
+export function resolveBotConnectionRoute(bot: Partial<RosterRow> | null | undefined): BotRouteResolution {
+  if (!bot?.sourceScoped && !bot?.remoteSource) {
+    return {
+      status: 'not_scoped',
+      route: null
+    }
+  }
+
+  const candidate = bot.route || {
+    connectionId: bot.connectionId,
+    mode: bot.connectionKind === 'local' ? 'local' : 'remote',
+    profile: bot.name,
+    targetProfile: bot.targetProfile || bot.name
+  }
+
+  const connectionId = String(candidate?.connectionId || '').trim()
+  const profile = String(candidate?.profile || bot?.name || '').trim() || 'default'
+  const targetProfile = String(candidate?.targetProfile || profile).trim() || profile
+
+  if (!connectionId) {
+    return {
+      status: 'owner_removed',
+      route: null,
+      profile
+    }
+  }
+
+  return {
+    status: 'resolved',
+    route: Object.freeze({
+      connectionId,
+      mode: candidate.mode === 'local' || connectionId === 'local' ? 'local' : 'remote',
+      profile,
+      targetProfile
+    })
+  }
+}
+
+/** Immutable owner descriptor for every source-scoped row. The active
+ *  gateway is presentation state and is never consulted here. Strict: throws
+ *  when the owning connection is gone -- correct for real dispatch
+ *  (requestForBot, session creation, etc.), covered by
+ *  remote-routing-races.test.mjs. Passive lookups (rendering, meta) must call
+ *  resolveBotConnectionRoute() directly instead of catching this throw. */
+export function botConnectionRoute(bot: Partial<RosterRow> | null | undefined): null | ProfileRoute {
+  const resolved = resolveBotConnectionRoute(bot)
+
+  if (resolved.status === 'owner_removed') {
+    throw new Error(`Bot ${resolved.profile} has no connection owner`)
+  }
+
+  return resolved.route
+}
+
+export function botWorkspaceOwnerKey(bot: RosterRow) {
+  // Render-reachable (sidebar sync, context menus): an orphaned row must
+  // yield a stable degraded key, never the dispatch throw.
+  const route = resolveBotConnectionRoute(bot).route
+
+  return `bot:${route ? botRouteKey(route) : String(bot?.name || 'default')}`
+}
+
+export function setBotsWorkspaceOwner(
+  ownerKey: string,
+  bot: null | RosterRow = null,
+  blockedMessage = 'Select a Bot or group first.'
+) {
+  // Render-reachable (sidebar listener fires on visibility flips). An
+  // orphaned row degrades to the blocked target instead of throwing.
+  const route = bot ? resolveBotConnectionRoute(bot).route : null
+
+  const target: { kind: 'blocked'; message: string } | { kind: 'route'; route: ProfileRoute } = route
+    ? {
+        kind: 'route',
+        route
+      }
+    : {
+        kind: 'blocked',
+        message: blockedMessage
+      }
+
+  host.setWorkspaceScope?.('bots', ownerKey, target)
+}
+
+export function backendTargetProfile(route: null | ProfileRoute | undefined, fallbackProfile = 'default') {
+  if (!route) {
+    return fallbackProfile
+  }
+
+  return route.targetProfile || route.profile
+}
+
+function rewriteCliProfileOperands(argv: string[], logical: string, target: string) {
+  const next = [...argv]
+
+  for (let index = 0; index < next.length; index += 1) {
+    if (next[index] === '--profile' && next[index + 1] === logical) {
+      next[index + 1] = target
+      index += 1
+    } else if (next[index] === `--profile=${logical}`) {
+      next[index] = `--profile=${target}`
+    }
+  }
+
+  const profileCommand = next.indexOf('profile')
+  const operand = profileCommand >= 0 ? profileCommand + 2 : -1
+
+  if (operand < next.length && next[operand] === logical) {
+    next[operand] = target
+  }
+
+  return next
+}
+
+function scopedBotParams(route: ProfileRoute, method: string, params: Record<string, unknown>) {
+  const logical = route.profile
+  const target = backendTargetProfile(route, logical)
+  let next = params
+
+  if (Object.prototype.hasOwnProperty.call(params, 'profile')) {
+    next = {
+      ...next,
+      profile: target
+    }
+  }
+
+  if (method.startsWith('profiles.') && method !== 'profiles.create' && params.name === logical) {
+    next = {
+      ...next,
+      name: target
+    }
+  }
+
+  if (params.clone_from === logical) {
+    next = {
+      ...next,
+      clone_from: target
+    }
+  }
+
+  if (method === 'cli.exec' && Array.isArray(params.argv)) {
+    next = {
+      ...next,
+      argv: rewriteCliProfileOperands(params.argv, logical, target)
+    }
+  }
+
+  return next
+}
+
+export function botBackendProfileScope(route: null | ProfileRoute | undefined, fallbackProfile = 'default') {
+  if (!route) {
+    return fallbackProfile
+  }
+
+  return {
+    connectionId: route.connectionId,
+    profile: backendTargetProfile(route, fallbackProfile)
+  }
+}
+
+/** Gateway RPC on the bot's OWN source. Source-scoped rows always use the
+ * explicit descriptor, including a registered local source. */
+export async function requestForBot<T = unknown>(
+  bot: Partial<RosterRow> | null | undefined,
+  method: string,
+  params: Record<string, unknown> = {}
+): Promise<T> {
+  const route = botConnectionRoute(bot)
+
+  if (route) {
+    if (typeof host.requestProfile !== 'function') {
+      throw new Error(`Cannot route ${method} for ${route.connectionId}::${route.profile}`)
+    }
+
+    try {
+      return await host.requestProfile(route, method, scopedBotParams(route, method, params))
+    } catch (error) {
+      // React 19 formats query errors with `(error.name || '').trim()`. IPC /
+      // JSON-RPC rejections are often plain objects whose `name` is a number,
+      // which crashes the Routines pane and hides the original failure (#94471).
+      throw asRpcError(error, `Gateway request ${method} failed`)
+    }
+  }
+
+  try {
+    return await host.request(method, params)
+  } catch (error) {
+    throw asRpcError(error, `Gateway request ${method} failed`)
+  }
+}
+
+/** A rejection duck-typed across realms: an Error-like whose fields are only
+ *  conventionally typed, so every read stays `unknown` until it is checked. */
+export interface RpcErrorLike {
+  message?: unknown
+  name?: unknown
+  stack?: unknown
+}
+
+/** Coerce an IPC/JSON-RPC rejection into an Error with a string `name`.
+ *
+ *  React Query stores whatever the queryFn throws. React 19 then formats it
+ *  with `(e.name || '').trim()`, which throws TypeError when `name` is a
+ *  number (JSON-RPC codes) or another non-string — the Routines pane crash
+ *  in #94471. Real Error instances are returned as-is when already safe.
+ */
+function asRpcError(value: unknown, fallback: string): unknown {
+  // Duck-type across realms (plugin tests run the source in `vm`, and IPC
+  // can deliver Error-like objects whose prototype is not this realm's
+  // Error). React 19 only needs a string `name`. Never mutate the rejection:
+  // frozen/sealed objects make `name = 'Error'` a silent no-op in sloppy
+  // mode, so a non-string name always becomes a fresh Error with cause.
+  const isObject = value != null && typeof value === 'object'
+  const name = isObject ? (value as RpcErrorLike).name : undefined
+  const message = isObject ? (value as RpcErrorLike).message : undefined
+  const hasStringName = typeof name === 'string'
+  const hasStringMessage = typeof message === 'string'
+  const hasStack = isObject && typeof (value as RpcErrorLike).stack === 'string'
+
+  if (isObject && hasStringName && (hasStack || hasStringMessage)) {
+    return value
+  }
+
+  if (isObject) {
+    const text = hasStringMessage && String(message).trim() ? String(message) : fallback
+    const error = new Error(text)
+    error.cause = value
+
+    return error
+  }
+
+  return new Error(value == null || value === '' ? fallback : String(value))
+}
+
+// ── alias identity for connection rows (#89131) ─────────────────────────────
+// A Desktop per-profile alias (profile `moxie` with a Cloud/URL/SSH override)
+// routes to a remote backend's root profile: its route reads
+// { connectionId: C, profile: 'moxie', targetProfile: 'default' }. Once that
+// backend answers the roster itself, the row's identity is (C, 'default') —
+// a DIFFERENT key than the alias meta (C::moxie / 'moxie') — so the friendly
+// name fell off after source/session activation: the row regressed to the
+// raw Cloud hostname, or to generic 'Hermes' in Cloud-only mode.
+//
+// aliasRouteIndex bridges the backend row identity back to its configured
+// alias. It is keyed by (connectionId, targetProfile), so two same-named
+// `default` rows on different connections can never share a title, and it
+// fails closed when two aliases claim the same backend row (mirroring the
+// fail-closed route resolution). This is the one sanctioned exception to
+// "remote rows never borrow local meta": the alias IS the local identity of
+// exactly this connection row, proven by the configured route — never by a
+// bare name match.
+interface AliasIdentity {
+  /** Both the source-qualified v2 key and the bare v1 name key. */
+  metaKeys: string[]
+  name: string
+}
+
+/** Keyed `${connectionId}::${targetProfile}`; null marks an ambiguous claim. */
+let aliasRouteIndex = new Map<string, AliasIdentity | null>()
+let aliasRouteEpoch = 0
+
+/** Claim the next rebuild epoch BEFORE reading the route inventory, then hand
+ *  the token to indexAliasRoutes. The read is async and the index is replaced
+ *  wholesale, so two overlapping roster fetches can resolve out of order and
+ *  the slower one's stale routes would win. */
+export function beginAliasRouteIndex(): number {
+  aliasRouteEpoch += 1
+
+  return aliasRouteEpoch
+}
+
+/** Rebuild the alias index from the credential-free route inventory. Only
+ *  genuine aliases (route.profile !== route.targetProfile) participate. A
+ *  rebuild overtaken by a newer one drops its result. */
+export function indexAliasRoutes(routes: ProfileRoute[], epoch = beginAliasRouteIndex()) {
+  if (epoch < aliasRouteEpoch) {
+    return
+  }
+
+  const next = new Map<string, AliasIdentity | null>()
+
+  for (const route of Array.isArray(routes) ? routes : []) {
+    const connectionId = String(route?.connectionId || '').trim()
+    const profile = String(route?.profile || '').trim()
+    const target = String(route?.targetProfile || '').trim()
+
+    if (!connectionId || !profile || !target || profile === target) {
+      continue
+    }
+
+    const key = `${connectionId}::${target}`
+
+    // Two aliases pointing at the same backend row are ambiguous — neither
+    // may claim the identity.
+    next.set(
+      key,
+      next.has(key)
+        ? null
+        : {
+            name: profile,
+            // Alias meta can live under the source-qualified v2 key or the bare
+            // v1 name key (aliases predate the v2 migration on mixed setups).
+            metaKeys: [`${connectionId}::${profile}`, profile]
+          }
+    )
+  }
+
+  aliasRouteIndex = next
+}
+
+/** The configured alias identity claiming this roster row, or null. Matches
+ *  strictly by (connectionId, backend target profile); the alias row itself
+ *  keeps resolving its own meta directly. */
+export function aliasIdentityFor(bot: Partial<RosterRow> | null | undefined): AliasIdentity | null {
+  if (!aliasRouteIndex.size) {
+    return null
+  }
+
+  const connectionId = String(
+    bot?.connectionId ||
+      bot?.route?.connectionId ||
+      // Unannotated rich rows (no host.agents on this build) still belong to
+      // the ACTIVE gateway — Cloud-only mode must resolve the alias too.
+      (!bot?.remoteSource && !bot?.sourceScoped ? host.state.connectionId?.get?.() || '' : '')
+  ).trim()
+
+  if (!connectionId) {
+    return null
+  }
+
+  const target = String(bot?.targetProfile || bot?.route?.targetProfile || bot?.name || '').trim() || 'default'
+  const entry = aliasRouteIndex.get(`${connectionId}::${target}`) || null
+
+  return entry && entry.name !== String(bot?.name || '').trim() ? entry : null
+}
+
+// Bot metadata is scoped to the active gateway until the server exposes a
+// union of rich profile rows. Never paint that metadata onto a thin row from
+// another source: two `default` agents must not borrow each other's title,
+// pin, avatar, group, unread state, or canonical-chat pointer. The ONE
+// exception is a configured alias route claiming the row — see
+// aliasRouteIndex above — which is connection-exact, never name-based.
+export function botRosterMeta(bot: RosterRow, metaByName: Record<string, BotMeta>) {
+  if (bot?.sourceScoped || bot?.remoteSource) {
+    // Passive meta lookup: branch on the typed status instead of catching
+    // botConnectionRoute's throw, so an owner_removed row (e.g. a stale
+    // persisted group roster after its connection was deleted) reads as "no
+    // route" without masking an unrelated failure under the same catch.
+    const resolved = resolveBotConnectionRoute(bot)
+    const route = resolved.status === 'resolved' ? resolved.route : null
+    const direct = route ? metaByName?.[botRouteKey(route)] : null
+
+    if (direct) {
+      return direct
+    }
+
+    const alias = aliasIdentityFor(bot)
+
+    if (alias) {
+      for (const key of alias.metaKeys) {
+        if (metaByName?.[key]) {
+          return metaByName[key]
+        }
+      }
+    }
+
+    return direct
+  }
+
+  const own = metaByName?.[bot?.name]
+
+  if (own) {
+    return own
+  }
+
+  const alias = aliasIdentityFor(bot)
+
+  if (alias) {
+    for (const key of alias.metaKeys) {
+      if (metaByName?.[key]) {
+        return metaByName[key]
+      }
+    }
+  }
+
+  return own
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/row-helpers.test.ts b/apps/desktop/src/plugins/hermes-bots/row-helpers.test.ts
new file mode 100644
index 000000000000..9182249e00b8
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/row-helpers.test.ts
@@ -0,0 +1,202 @@
+/**
+ * The row-level reads a roster row is assembled from: who sent the last
+ * message, and whether a bot counts as live right now.
+ *
+ * Two bug classes are pinned:
+ *  - #89484 — the bot-to-bot badge rendered the raw captured profile name, so
+ *    the primary profile surfaced as @default instead of @hermes;
+ *  - the "6d ago" class — canonical Bot Chats are hidden from session lists,
+ *    so a bot DM'd all day read as a week idle because its newest VISIBLE
+ *    session was a week old. Liveness keys off `botActivitySession`, and
+ *    kanban/tool workers count too (hermes-agent#90268): a profile grinding
+ *    through a 30-minute task must not read "3 hr ago" the whole time.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+  ACTIVE_WINDOW_S,
+  activeBots,
+  botCanonicalSessionId,
+  botRowOwnsWorkspace,
+  previewKind,
+  rosterActivityMatches,
+  workerActiveAt
+} from './row-helpers'
+import type { RosterRow } from './types'
+
+vi.mock('@hermes/plugin-sdk', async () => {
+  const { atom } = await import('nanostores')
+
+  return {
+    atom,
+    host: { state: { connectionId: { get: () => 'local' } } },
+    queryClient: undefined,
+    useQuery: vi.fn(),
+    useValue: vi.fn()
+  }
+})
+
+vi.mock('./shared', () => ({ getPluginCtx: () => null, ID: 'hermes-bots' }))
+
+/** Gateway rows carry a session id on `last_session` / `worker_session` that
+ *  the plugin's `SessionPreview` type deliberately does not model. Fixtures
+ *  keep it so "the canonical id is never the last_session id" stays a real
+ *  assertion rather than one about a missing field. */
+interface RowFixture extends Omit<Partial<RosterRow>, 'last_session' | 'worker_session'> {
+  last_session?: { id?: string; last_active?: number; preview?: string }
+  worker_session?: { id?: string; last_active?: number; source?: string }
+}
+
+const row = (bot: RowFixture) => bot as RosterRow
+
+// Fixed clock so "inside the window" vs "stale" is deterministic.
+const NOW = 1_000_000_000_000
+const secondsAgo = (n: number) => NOW / 1000 - n
+
+describe('previewKind classifies a roster preview', () => {
+  const fromBot = (preview: null | string | undefined) => previewKind(preview).fromBot
+
+  it('reads a plain chat preview as a human exchange, not a DM', () => {
+    expect(fromBot('Can you check the vault sync?')).toBeNull()
+  })
+
+  it('parses the current 🤖 delivery prefix and the legacy agent shape', () => {
+    expect(fromBot('Message from 🤖 manager (@manager): Learn-share: skill installed')).toBe('manager')
+    expect(fromBot("Message from agent 'researcher': here is the paper")).toBe('researcher')
+  })
+
+  it('surfaces the primary profile as @hermes, never @default (#89484)', () => {
+    expect(fromBot("Message from agent 'default': deploy is green")).toBe('hermes')
+    expect(fromBot("Message from agent 'ops': deploy is green")).toBe('ops')
+  })
+
+  it('treats an empty or absent preview as not a DM', () => {
+    expect(fromBot('')).toBeNull()
+    expect(fromBot(undefined)).toBeNull()
+  })
+})
+
+describe('the canonical session id everything core-keyed reads', () => {
+  it('prefers the compression-lineage tip over the durable registry id', () => {
+    expect(botCanonicalSessionId(row({ canonical_session: { id: 'root', last_active: 1, resolved_id: 'tip' } }))).toBe(
+      'tip'
+    )
+    expect(botCanonicalSessionId(row({ canonical_session: { id: 'root', last_active: 1 } }))).toBe('root')
+  })
+
+  it('is never last_session — that is a different conversation entirely', () => {
+    expect(botCanonicalSessionId(row({ last_session: { id: 'scratch', last_active: 1 } }))).toBeNull()
+  })
+})
+
+describe('which bots are working right now', () => {
+  const roster = [
+    row({ last_session: { id: 'a', last_active: secondsAgo(10) }, name: 'researcher' }),
+    row({ last_session: { id: 'b', last_active: secondsAgo(400) }, name: 'scribe' }),
+    row({ name: 'analyst' })
+  ]
+
+  it('includes the gateway-busy profile before its first response lands', () => {
+    // analyst has no session at all — a busy turn must still show it.
+    expect(activeBots(roster, 'analyst', 'busy', NOW).map(bot => bot.name)).toContain('analyst')
+  })
+
+  it('includes activity inside the liveness window and excludes activity outside it', () => {
+    const names = activeBots(roster, 'default', 'open', NOW).map(bot => bot.name)
+
+    expect(names).toContain('researcher')
+    expect(names).not.toContain('scribe')
+    // Output follows input order and never hides or reorders the full list.
+    expect(names).toEqual(['researcher'])
+    expect(roster).toHaveLength(3)
+  })
+
+  it('returns an empty list when nothing is active, and tolerates no roster', () => {
+    expect(activeBots(roster.slice(1), 'default', 'open', NOW)).toEqual([])
+    expect(activeBots(null, 'default', 'open', NOW)).toEqual([])
+    expect(activeBots([], 'default', 'open', NOW)).toEqual([])
+  })
+
+  it('counts Bot Chat activity that last_session cannot see', () => {
+    const bots = [
+      row({
+        canonical_session: { id: 'chat', last_active: secondsAgo(5) },
+        last_session: { id: 'old', last_active: secondsAgo(6 * 86_400) },
+        name: 'default'
+      })
+    ]
+
+    expect(activeBots(bots, 'other', 'open', NOW).map(bot => bot.name)).toContain('default')
+  })
+
+  it('counts a live kanban/tool worker heartbeat (#90268)', () => {
+    // The reported shape: last chat hours ago while the bot is mid-task.
+    const working = row({
+      last_session: { id: 'chat', last_active: secondsAgo(3 * 3600) },
+      name: 'coding',
+      worker_session: { id: 'w1', last_active: secondsAgo(30), source: 'kanban' }
+    })
+
+    expect(activeBots([working], 'other', 'open', NOW).map(bot => bot.name)).toContain('coding')
+    expect(workerActiveAt(working, NOW)).toBe(true)
+  })
+
+  it('ignores a finished worker outside the liveness window', () => {
+    const finished = row({
+      last_session: { id: 'chat', last_active: secondsAgo(3 * 3600) },
+      name: 'coding',
+      worker_session: { id: 'w1', last_active: secondsAgo(3600), source: 'kanban' }
+    })
+
+    expect(activeBots([finished], 'other', 'open', NOW)).toEqual([])
+    // Workers get a wider window than chat activity to bridge one missed
+    // heartbeat — but not an hour's worth.
+    expect(workerActiveAt(finished, NOW)).toBe(false)
+    expect(ACTIVE_WINDOW_S).toBeGreaterThan(0)
+  })
+})
+
+describe('the roster activity filter', () => {
+  it('passes everything through with no filter', () => {
+    expect(rosterActivityMatches({ activity: 0 }, null, NOW)).toBe(true)
+    expect(rosterActivityMatches({ activity: 0 }, 'all', NOW)).toBe(true)
+  })
+
+  it('splits recent from older on the week boundary', () => {
+    const week = 7 * 24 * 60 * 60 * 1000
+
+    expect(rosterActivityMatches({ activity: NOW - week + 1000 }, 'recent', NOW)).toBe(true)
+    expect(rosterActivityMatches({ activity: NOW - week - 1000 }, 'recent', NOW)).toBe(false)
+    expect(rosterActivityMatches({ activity: NOW - week - 1000 }, 'older', NOW)).toBe(true)
+    // A bot with no activity at all counts as older, never recent.
+    expect(rosterActivityMatches({}, 'older', NOW)).toBe(true)
+  })
+
+  it('reads the live pulse for the active filter', () => {
+    expect(rosterActivityMatches({ active: true }, 'active', NOW)).toBe(true)
+    expect(rosterActivityMatches({ active: false }, 'active', NOW)).toBe(false)
+  })
+})
+
+describe('which row owns the workspace highlight', () => {
+  const bot = row({ connectionId: 'local', name: 'ops' })
+
+  it('follows the explicit selection while no bot chat has focus', () => {
+    expect(botRowOwnsWorkspace(bot, null, false, null, 'local::ops')).toBe(true)
+    expect(botRowOwnsWorkspace(bot, null, false, null, 'local::other')).toBe(false)
+  })
+
+  it('follows the FOCUSED chat’s owner once a bot chat has focus', () => {
+    // Tab/tile focus moves without swapping the socket, so keying this off
+    // the gateway's home profile highlighted the wrong bot.
+    const focused = { authoritative: true, connectionId: 'local', name: 'ops' }
+
+    expect(botRowOwnsWorkspace(bot, null, true, focused, 'local::other')).toBe(true)
+    expect(botRowOwnsWorkspace(bot, null, true, { ...focused, name: 'writer' }, 'local::ops')).toBe(false)
+  })
+
+  it('never highlights a bot row while a group room is active', () => {
+    expect(botRowOwnsWorkspace(bot, 'team', false, null, 'local::ops')).toBe(false)
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/row-helpers.ts b/apps/desktop/src/plugins/hermes-bots/row-helpers.ts
new file mode 100644
index 000000000000..2c92daeafda5
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/row-helpers.ts
@@ -0,0 +1,149 @@
+/**
+ * The row-level reads a roster row is assembled from: who sent the last
+ * message, whether a bot counts as live, and whether its row owns the
+ * highlight.
+ *
+ * Pure below the surfaces. Every one of these takes a roster row and returns
+ * a value, so the bot row, the roster pane and the open path can share one
+ * answer instead of each deriving its own.
+ */
+
+import { botActivitySession, botHandle, botRosterKey, isActiveRosterBot } from './data'
+import type { RosterActivityFilter, RosterRow } from './types'
+
+// ── human-readable row helpers ───────────────────────────────────────────────
+
+/** Bot-to-bot delivery prefix (see messagingProtocolSection): either the
+ *  current "Message from 🤖 name (@handle):" form or the older
+ *  "[Message from agent 'name']" shape. Captures the sender's handle. */
+const A2A_RE = /^Message from (?:agent '([^']+)'|🤖\s*([^\s(@]+))/i
+
+/** Strip the delivery prefix so a DM preview reads like a DM, not a log line. */
+export const A2A_PREFIX_RE = /^Message from (?:agent '[^']+'|🤖[^:]+):\s*/i
+
+/** Classify a roster preview: `{ fromBot: handle|null }`. A preview that
+ *  starts with the delivery prefix is a bot-to-bot message — the receiving
+ *  bot's row should show WHO sent it, not present it as the human's chat. */
+export function previewKind(preview: null | string | undefined): { fromBot: null | string } {
+  const text = (preview || '').trim()
+
+  if (!text) {
+    return {
+      fromBot: null
+    }
+  }
+
+  const match = text.match(A2A_RE)
+
+  if (match) {
+    // The captured name is whatever the delivery prefix carried — a raw
+    // profile name. Map it the way every other surface does so the primary
+    // profile reads @hermes, never @default (#89484).
+    const sender = (match[1] || match[2] || '').trim().toLowerCase()
+
+    return {
+      fromBot: sender ? botHandle(sender) : null
+    }
+  }
+
+  return {
+    fromBot: null
+  }
+}
+
+/** Roster liveness window: a bot whose last message landed within this many
+ *  seconds is treated as "active now" (pulsing dot in its row). */
+export const ACTIVE_WINDOW_S = 90
+const RECENT_ACTIVITY_WINDOW_S = 7 * 24 * 60 * 60
+export const BOT_ROSTER_SEARCH_THRESHOLD = 8
+
+/** The stored session id this bot's canonical Bot Chat answers to — the
+ *  compression-lineage tip the live-state atoms are keyed by, falling back to
+ *  the durable registry id. THE id for anything core-keyed: the row's status
+ *  dot reads it and the unread writes below key by it, so the two can never
+ *  describe different conversations. Deliberately NOT botActivitySession —
+ *  that may answer with `last_session`, a bare preview with no id belonging to
+ *  another conversation entirely. */
+export function botCanonicalSessionId(bot: null | RosterRow | undefined): null | string {
+  return bot?.canonical_session?.resolved_id ?? bot?.canonical_session?.id ?? null
+}
+
+/** Worker liveness window: kanban/tool workers heartbeat last_activity_at
+ *  at least every 60s while running (agent/session_activity.py), so a
+ *  worker whose stamp is older than this is finished or stalled. Wider
+ *  than ACTIVE_WINDOW_S to bridge one missed heartbeat. */
+const WORKER_ACTIVE_WINDOW_S = 150
+
+/** True while this bot's freshest kanban/tool worker looks alive. Workers
+ *  never surface in conversation lists, so without this a profile grinding
+ *  through a 30-minute kanban task reads idle ("3 hr ago") the whole time
+ *  (hermes-agent#90268). Older gateways omit worker_session — always false. */
+export function workerActiveAt(bot: null | RosterRow | undefined, now = Date.now()): boolean {
+  const ts = bot?.worker_session?.last_active || 0
+
+  return Boolean(ts && now / 1000 - ts < WORKER_ACTIVE_WINDOW_S)
+}
+
+/** Bots that are working right now: the profile the gateway is running a
+ *  turn for (busy), any bot whose last message landed inside the liveness
+ *  window, plus any bot with a live kanban/tool worker. Pure — output
+ *  follows the input roster's order, so presence never reorders or hides
+ *  the normal list. */
+export function activeBots(
+  roster: null | RosterRow[] | undefined,
+  activeProfile: string,
+  gatewayState: string,
+  now = Date.now()
+): RosterRow[] {
+  return (roster || []).filter(bot => {
+    const busyTurn = !bot.remoteSource && bot.name === activeProfile && gatewayState === 'busy'
+    const last = botActivitySession(bot)?.last_active || 0
+    const inWindow = Boolean(last && now / 1000 - last < ACTIVE_WINDOW_S)
+
+    return busyTurn || inWindow || workerActiveAt(bot, now)
+  })
+}
+
+/** What the roster list wraps around a bot or group before filtering:
+ *  `activity` is a millisecond stamp, `active` the live pulse. */
+interface RosterActivityRow {
+  active?: boolean
+  activity?: number
+}
+
+export function rosterActivityMatches(
+  row: null | RosterActivityRow | undefined,
+  filter: null | RosterActivityFilter | undefined,
+  now = Date.now()
+): boolean {
+  if (!filter || filter === 'all') {
+    return true
+  }
+
+  if (filter === 'active') {
+    return Boolean(row?.active)
+  }
+
+  const activity = Number(row?.activity || 0)
+  const recent = Boolean(activity && now - activity <= RECENT_ACTIVITY_WINDOW_S * 1000)
+
+  return filter === 'recent' ? recent : !recent
+}
+
+export function botRowOwnsWorkspace(
+  bot: RosterRow,
+  activeGroup: null | string,
+  botChatFocused: boolean,
+  focusedOwner: null | { authoritative: boolean; connectionId: string; name: string },
+  selectedRosterKey: string
+): boolean {
+  if (activeGroup) {
+    return false
+  }
+
+  if (!botChatFocused) {
+    return selectedRosterKey === botRosterKey(bot)
+  }
+
+  return isActiveRosterBot(bot, focusedOwner)
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/session-sweep.ts b/apps/desktop/src/plugins/hermes-bots/session-sweep.ts
new file mode 100644
index 000000000000..2a5cc0e1c24d
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/session-sweep.ts
@@ -0,0 +1,299 @@
+/**
+ * The always-hidden reconciliation sweep: everything that walks Bot Mode's
+ * own sessions on load and on each reconnect and pushes them back to hidden.
+ *
+ * Durable-visibility plumbing, not a surface. It reads the room store and the
+ * roster cache and renders nothing, so the plugin's lifecycle can start the
+ * scheduler without pulling a view in.
+ */
+
+import { host } from '@hermes/plugin-sdk'
+
+import { PROFILE_SESSION_LIST_LIMIT } from './canonical-chat'
+import { $lastRoster } from './data'
+import { $groupChats } from './group-chat'
+import { groupMemberKey } from './group-membership'
+import { backendTargetProfile, botConnectionRoute, requestForBot } from './routing'
+import type { GroupMember, RosterRow } from './types'
+
+/** The slice of the plugin context the scheduler needs to park its timer. */
+interface HideSweepContext {
+  onDispose?: (fn: () => void) => void
+}
+
+/** One-time reconciliation: Bot Mode sessions are always hidden, but rooms
+ *  and Bot Chats created before this policy (or while the old pref was off)
+ *  left visible rows behind. On every plugin load, sweep the session ids we
+ *  own by id (each group room's member sessions) through the core
+ *  session.set_hidden RPC, then run the TITLE-based ownership sweep for
+ *  everything else — canonical Bot Chats are identified by name (the
+ *  registry row titled "Bot Chat"), so the title sweep is what hides them;
+ *  no stored-id pointer is consulted. Idempotent (the DB setter is a no-op
+ *  on already-hidden rows) and feature-detected: older Desktop hosts defer
+ *  reconciliation rather than activating an absent profile backend. */
+export function startHideSweepScheduler(ctx: HideSweepContext) {
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let inflight: Promise<unknown> | null = null
+  let pending = false
+  let disposed = false
+
+  const run = () => {
+    timer = null
+
+    if (disposed) {
+      return
+    }
+
+    if (inflight) {
+      pending = true
+
+      return
+    }
+
+    inflight = Promise.resolve()
+      .then(() => hideOwnedBotSessions())
+      .catch(() => undefined)
+      .finally(() => {
+        inflight = null
+
+        if (pending && !disposed) {
+          pending = false
+          schedule()
+        }
+      })
+  }
+
+  const schedule = () => {
+    if (disposed) {
+      return
+    }
+
+    try {
+      if (timer !== null) {
+        clearTimeout(timer)
+      }
+
+      timer = setTimeout(run, 0)
+    } catch {
+      run()
+    }
+  }
+
+  const stopGatewayListener = host.state.gateway.listen(state => {
+    if (state === 'open') {
+      schedule()
+    }
+  })
+
+  const teardown = () => {
+    disposed = true
+    stopGatewayListener()
+
+    if (timer !== null) {
+      clearTimeout(timer)
+      timer = null
+    }
+  }
+
+  if (typeof ctx.onDispose === 'function') {
+    ctx.onDispose(teardown)
+  }
+
+  schedule()
+}
+
+/** One (owner, session id) pair the sweep will hide, plus the key it dedupes
+ *  on when the same member session is seated in several rooms. */
+interface RoomSessionEntry {
+  dedupe: string
+  id: string
+  owner: RosterRow
+}
+
+function hideOwnedBotSessions() {
+  // `.filter(Boolean)` doesn't narrow away the nulls the map returns, so the
+  // element type is restated here rather than at every read below.
+  const roomEntries = Object.values($groupChats.get()).flatMap(room =>
+    Object.entries(room?.sessions || {})
+      .map(([key, id]) => {
+        if (!id || id === true) {
+          return null
+        }
+
+        const persisted = room?.sessionOwners?.[key]
+        const derived = (room?.members || []).find((member: GroupMember) => groupMemberKey(member) === key)
+
+        // Bare keys are legacy local rooms. A source-qualified key without its
+        // immutable owner is unsafe: never let it fall through ambient routing.
+        const owner =
+          persisted ||
+          derived ||
+          (!key.includes('::')
+            ? {
+                name: key
+              }
+            : null)
+
+        if (key.includes('::')) {
+          const route = owner?.route
+          const sourceMarked = owner?.sourceScoped || owner?.remoteSource
+          const routeKey = route?.connectionId && route?.profile ? `${route.connectionId}::${route.profile}` : ''
+
+          if (!sourceMarked || !route?.targetProfile || routeKey !== key) {
+            return null
+          }
+        }
+
+        return owner
+          ? {
+              owner,
+              id,
+              dedupe: `${key}\u0000${id}`
+            }
+          : null
+      })
+      .filter(Boolean)
+  ) as RoomSessionEntry[]
+
+  // The same member session can appear in several rooms (and legacy rooms can
+  // share ids) — hide each (owner, id) pair exactly once.
+  const rooms = [...new Map(roomEntries.map(entry => [entry.dedupe, entry])).values()]
+  const known = Promise.all(rooms.map(({ owner, id }) => hidePersistedBotSession(owner, id).catch(() => undefined)))
+
+  return Promise.all([known, sweepBotProfileSessions().catch(() => undefined)])
+}
+
+/** Reconcile durable visibility through the source's primary REST backend.
+ *  Never fall back to requestForBot: that compatibility path activates an
+ *  absent profile backend, which is worse than deferring this best-effort sweep. */
+function hidePersistedBotSession(bot: RosterRow, sessionId: string, profileOverride = '') {
+  if (typeof host.setPersistedSessionHidden !== 'function') {
+    return Promise.resolve()
+  }
+
+  const route = botConnectionRoute(bot)
+  const fallback = String(bot?.name || '').trim() || 'default'
+  const profile = profileOverride || backendTargetProfile(route, fallback)
+
+  return Promise.resolve(
+    host.setPersistedSessionHidden(route, {
+      sessionId,
+      profile,
+      hidden: true
+    })
+  )
+}
+
+// Titles Bot Mode itself mints for its plumbing sessions. Bot-to-bot CLI
+// handoffs (`hermes -p <bot> chat --in ~ -c "Bot Chat" --create-if-missing`)
+// create sessions with EXACTLY these titles; the "Group: " prefix is the
+// member-session title ensureGroupChatSession has
+// used since group chats shipped. Exact/prefix matching is deliberate — a
+// user's real conversation inside a bot profile keeps whatever title the
+// user gave it and is never touched.
+const BOT_MODE_SWEEP_TITLES = new Set(['Bot Chat', 'Agent Inbox'])
+const BOT_MODE_SWEEP_MIN_AGE_SECONDS = 5 * 60
+
+function isBotModeSweepTitle(title: null | string | undefined) {
+  const t = String(title || '').trim()
+
+  return BOT_MODE_SWEEP_TITLES.has(t) || t.startsWith('Group: ')
+}
+
+/** A persisted session row as the sweep reads it. Structural so both the REST
+ *  list rows and a raw `session.list` payload satisfy it. */
+interface SweepSessionRow {
+  id: string
+  /** Epoch seconds. */
+  started_at?: number
+  title?: null | string
+}
+
+function isBotModeSweepCandidate(row: SweepSessionRow | null | undefined, nowSeconds = Date.now() / 1000) {
+  const startedAt = Number(row?.started_at)
+
+  return (
+    row &&
+    row.id &&
+    isBotModeSweepTitle(row.title) &&
+    Number.isFinite(startedAt) &&
+    startedAt > 0 &&
+    nowSeconds - startedAt >= BOT_MODE_SWEEP_MIN_AGE_SECONDS
+  )
+}
+
+/** `profiles.list` as Bot Mode reads it. */
+interface ProfilesListResult {
+  profiles?: RosterRow[]
+}
+
+/** Ownership-based sweep: the id-based sweep above only covers sessions the
+ *  plugin recorded ($botMeta canonical chats, $groupChats member sids), but
+ *  Bot Mode sessions are ALSO minted outside the plugin — bot-to-bot CLI
+ *  handoffs ("Agent Inbox" / extra "Bot Chat" rows born visible in a bot's
+ *  profile) — and those ids the plugin never learns. So: enumerate each
+ *  roster bot's OWN profile sessions (only bot profiles — a non-bot profile
+ *  is never listed, so its sessions are never touched) and hide any VISIBLE
+ *  row whose title is Bot Mode plumbing and whose creation grace period has
+ *  elapsed. The grace period protects a new desktop draft while its first-turn
+ *  title is pending; after five minutes an unchanged plumbing title is treated
+ *  as Bot Mode-owned. session.list supplies epoch seconds; missing, malformed,
+ *  millisecond, or future timestamps fail closed and stay visible. session.list
+ *  without include_hidden returns only visible rows, which keeps the sweep
+ *  naturally idempotent.
+ *  Reads and writes go through the owning source's primary REST backend, which
+ *  opens persisted state directly and never starts an inactive profile backend.
+ *  Feature-detected + fire-and-forget: older Desktop hosts defer the sweep. */
+async function sweepBotProfileSessions(nowSeconds = Date.now() / 1000) {
+  if (typeof host.listPersistedSessions !== 'function' || typeof host.setPersistedSessionHidden !== 'function') {
+    return
+  }
+
+  const cached = $lastRoster.get()
+  let roster: RosterRow[] | null = Array.isArray(cached) && cached.length ? cached : null
+
+  if (!roster) {
+    // Plugin load can run before the Bots pane hydrates $lastRoster — fall
+    // back to the active gateway's own profile list (local bots; remote
+    // sources get covered by the next sweep once the roster cache exists).
+    try {
+      const activeBot = {
+        name: String(host.state.profile?.get?.() || 'default').trim() || 'default'
+      }
+
+      const res = (await requestForBot(activeBot, 'profiles.list', {})) as ProfilesListResult
+      roster = Array.isArray(res?.profiles) ? res.profiles : []
+    } catch {
+      return
+    }
+  }
+
+  await Promise.all(
+    roster.map(async (bot: RosterRow) => {
+      const name = String(bot?.name || '').trim()
+
+      if (!name) {
+        return
+      }
+
+      try {
+        const route = botConnectionRoute(bot)
+        const profile = backendTargetProfile(route, name)
+
+        const res = await host.listPersistedSessions(route, {
+          profile,
+          limit: PROFILE_SESSION_LIST_LIMIT
+        })
+
+        const rows = Array.isArray(res?.sessions) ? res.sessions : []
+        await Promise.all(
+          rows
+            .filter(row => isBotModeSweepCandidate(row, nowSeconds))
+            .map(row => Promise.resolve(hidePersistedBotSession(bot, row.id, profile)).catch(() => undefined))
+        )
+      } catch {
+        /* older gateway / unreachable source — leave this profile alone */
+      }
+    })
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/shared.ts b/apps/desktop/src/plugins/hermes-bots/shared.ts
new file mode 100644
index 000000000000..2eb8ea8a69ba
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/shared.ts
@@ -0,0 +1,38 @@
+/**
+ * The pieces every Bot Mode module needs and no single module can own: the
+ * plugin id, the `PluginContext` `register()` captures, and the open
+ * generation the bot-open and group-open click paths race on.
+ *
+ * The mutable ones live behind accessor pairs because an imported binding
+ * cannot be reassigned — `register()` publishes the context once with
+ * `setPluginCtx`, and every reader goes through `getPluginCtx()`.
+ */
+
+import type { PluginContext } from '@hermes/plugin-sdk'
+
+export const ID = 'hermes-bots'
+
+/** Captured in register() so components can reach plugin storage. */
+let pluginCtx: PluginContext | null = null
+
+export function getPluginCtx(): PluginContext | null {
+  return pluginCtx
+}
+
+export function setPluginCtx(ctx: PluginContext | null) {
+  pluginCtx = ctx
+}
+
+/** Monotonic open generation. A bot open and a group open supersede each
+ *  other, so both bump it and both compare against it — and they no longer
+ *  live in the same module. */
+let botOpenGeneration = 0
+
+export function getBotOpenGeneration() {
+  return botOpenGeneration
+}
+
+/** Invalidate every in-flight open; returns the generation that now owns it. */
+export function bumpBotOpenGeneration() {
+  return ++botOpenGeneration
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/skills-hub-picker.test.tsx b/apps/desktop/src/plugins/hermes-bots/skills-hub-picker.test.tsx
new file mode 100644
index 000000000000..e8f5222106db
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/skills-hub-picker.test.tsx
@@ -0,0 +1,152 @@
+/**
+ * The Skills Hub picker embeds the real hub page in an iframe; the page posts
+ * `{type:'hermes-skill-pick'}` back and the plugin installs via skills.manage.
+ *
+ * The handler used to check only `event.origin`, so ANY window on the hub
+ * origin — an OAuth popup that had navigated back there, for instance — could
+ * drive an install while the picker was open, and whatever string it sent
+ * reached skills.manage as the install identifier. Picks are now pinned to OUR
+ * frame's contentWindow and the identifier is charset-checked.
+ */
+
+import type * as HermesSdk from '@hermes/plugin-sdk'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const HUB_ORIGIN = 'https://hermes-agent.nousresearch.com'
+
+const mocks = vi.hoisted(() => ({
+  notify: vi.fn(),
+  notifyError: vi.fn(),
+  request: vi.fn(async (_method: string, _params: Record<string, unknown>) => ({}))
+}))
+
+vi.mock('@hermes/plugin-sdk', async importOriginal => {
+  const original = await importOriginal<typeof HermesSdk>()
+
+  return {
+    ...original,
+    host: { ...original.host, notify: mocks.notify, notifyError: mocks.notifyError, request: mocks.request }
+  }
+})
+
+const { HubSkillsSection } = await import('./skills-hub')
+
+interface PickMessage {
+  identifier?: string
+  name?: string
+  type?: string
+}
+
+/** Mount the section with the hub browser open and hand back its frame. */
+function openHubBrowser() {
+  const { container } = render(<HubSkillsSection forProfile={null} />)
+
+  fireEvent.click(screen.getByRole('button', { name: /browse the full hub/ }))
+
+  const frame = container.querySelector('iframe')
+
+  expect(frame).toBeTruthy()
+
+  return frame as HTMLIFrameElement
+}
+
+function postPick(data: PickMessage, options: { origin?: string; source?: null | Window }) {
+  window.dispatchEvent(
+    new MessageEvent('message', {
+      data,
+      origin: options.origin ?? HUB_ORIGIN,
+      source: options.source ?? null
+    })
+  )
+}
+
+function installCalls() {
+  return mocks.request.mock.calls.filter(([, params]) => params.action === 'install')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('hub pick messages', () => {
+  it('installs the picked skill when it comes from our own frame', () => {
+    const frame = openHubBrowser()
+
+    postPick(
+      { identifier: 'nous/web-research', name: 'Web Research', type: 'hermes-skill-pick' },
+      {
+        source: frame.contentWindow
+      }
+    )
+
+    expect(installCalls()).toEqual([['skills.manage', { action: 'install', query: 'nous/web-research' }]])
+  })
+
+  it('regression: ignores a same-origin window that is NOT the picker frame', () => {
+    openHubBrowser()
+
+    // Same origin, different window — the OAuth-popup shape of the hole.
+    postPick(
+      { identifier: 'nous/web-research', name: 'Web Research', type: 'hermes-skill-pick' },
+      {
+        source: window
+      }
+    )
+
+    expect(installCalls()).toEqual([])
+  })
+
+  it('ignores anything posted from another origin', () => {
+    const frame = openHubBrowser()
+
+    postPick(
+      { identifier: 'nous/web-research', name: 'Web Research', type: 'hermes-skill-pick' },
+      {
+        origin: 'https://evil.example',
+        source: frame.contentWindow
+      }
+    )
+
+    expect(installCalls()).toEqual([])
+  })
+
+  it('regression: refuses identifiers outside the slug charset', () => {
+    const frame = openHubBrowser()
+
+    for (const identifier of ['../../etc/passwd', 'skill; rm -rf /', '-flag', 'name with spaces', '']) {
+      postPick({ identifier, name: 'Web Research', type: 'hermes-skill-pick' }, { source: frame.contentWindow })
+    }
+
+    // The empty identifier falls back to `name`, which is also off-charset.
+    expect(installCalls()).toEqual([])
+  })
+
+  it('ignores messages that are not a skill pick', () => {
+    const frame = openHubBrowser()
+
+    postPick({ identifier: 'nous/web-research', type: 'oauth-callback' }, { source: frame.contentWindow })
+    postPick({ identifier: 'nous/web-research', type: 'hermes-skill-pick' }, { source: frame.contentWindow })
+
+    // The second has no `name`, so it is not a complete pick either.
+    expect(installCalls()).toEqual([])
+  })
+
+  it('stops listening once the hub browser is closed', () => {
+    const frame = openHubBrowser()
+
+    fireEvent.click(screen.getByRole('button', { name: /hide the hub browser/ }))
+    postPick(
+      { identifier: 'nous/web-research', name: 'Web Research', type: 'hermes-skill-pick' },
+      {
+        source: frame.contentWindow
+      }
+    )
+
+    expect(installCalls()).toEqual([])
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/skills-hub.tsx b/apps/desktop/src/plugins/hermes-bots/skills-hub.tsx
new file mode 100644
index 000000000000..a68195997151
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/skills-hub.tsx
@@ -0,0 +1,272 @@
+/**
+ * The real skills hub page embedded as a picker, plus its offline search
+ * fallback.
+ *
+ * A leaf: the advanced profile editor and the create dialog both mount it, and
+ * it reaches back into neither.
+ */
+
+import { Button, host, Input } from '@hermes/plugin-sdk'
+import { useEffect, useRef, useState } from 'react'
+
+import { useBots } from './i18n'
+
+// ── skills hub section: the REAL hub page (docs) embedded as a picker ──────
+// https://hermes-agent.nousresearch.com/docs/skills?embed=picker hides the
+// docs chrome and adds "+ Add to this Agent" per card, posting
+// {type: 'hermes-skill-pick', ...} to us (hermes-agent#86243). We validate
+// the origin, install via skills.manage, and bubble onInstalled so the
+// checklist above gains the row. Search-box fallback kept for offline use.
+
+const HUB_ORIGIN = 'https://hermes-agent.nousresearch.com'
+const HUB_PICKER_URL = HUB_ORIGIN + '/docs/skills?embed=picker'
+/** One `skills.manage action=search` hit. */
+interface HubSkillResult {
+  description?: string
+  name: string
+}
+interface HubSkillsSectionProps {
+  /** Install target: a bare profile name, a connection-scoped descriptor for a
+   *  bot on another gateway, or null for the launch profile (create time). */
+  forProfile: null | string | { connectionId?: null | string; profile?: null | string }
+  onInstalled?: (name: string) => void
+}
+
+export function HubSkillsSection({ forProfile, onInstalled }: HubSkillsSectionProps) {
+  const b = useBots()
+  const [query, setQuery] = useState('')
+  const [results, setResults] = useState<HubSkillResult[] | null>(null)
+  const [searching, setSearching] = useState(false)
+  const [installing, setInstalling] = useState<null | string>(null)
+  const [installed, setInstalled] = useState<Record<string, boolean>>({})
+  const [browseHub, setBrowseHub] = useState(false)
+  const installRef = useRef<((name: string, displayName?: string) => Promise<void>) | null>(null)
+  const frameRef = useRef<HTMLIFrameElement | null>(null)
+
+  // Picker messages from the embedded hub page. Origin- AND source-checked —
+  // only OUR frame may ask for an install (the hub origin alone would let any
+  // other window on it, e.g. an OAuth popup, trigger installs too); installs
+  // route through the same install() the search fallback uses.
+  useEffect(() => {
+    if (!browseHub) {
+      return undefined
+    }
+
+    const onMessage = (event: MessageEvent) => {
+      if (event.origin !== HUB_ORIGIN) {
+        return
+      }
+
+      if (!frameRef.current || event.source !== frameRef.current.contentWindow) {
+        return
+      }
+
+      const data = event.data
+
+      if (!data || data.type !== 'hermes-skill-pick' || !data.name) {
+        return
+      }
+
+      const target = String(data.identifier || data.name)
+
+      // Skill identifiers are slugs / owner-name paths — keep anything
+      // else out of skills.manage.
+      if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(target)) {
+        return
+      }
+
+      if (installRef.current) {
+        void installRef.current(target, String(data.name))
+      }
+    }
+
+    window.addEventListener('message', onMessage)
+
+    return () => window.removeEventListener('message', onMessage)
+  }, [browseHub])
+
+  const search = async () => {
+    const q = query.trim()
+
+    if (!q || searching) {
+      return
+    }
+
+    setSearching(true)
+    setResults(null)
+
+    try {
+      const res: { results?: HubSkillResult[] } = await host.request('skills.manage', {
+        action: 'search',
+        query: q
+      })
+
+      setResults(res.results || [])
+    } catch {
+      setResults([])
+    } finally {
+      setSearching(false)
+    }
+  }
+
+  const install = async (name: string, displayName?: string) => {
+    const label = displayName || name
+
+    if (installing) {
+      return
+    }
+
+    setInstalling(label)
+
+    try {
+      // With forProfile the install lands in that bot's skills dir
+      // (gateway skills.manage profile scoping); null = launch profile,
+      // which is right at create time — the new bot clones/copies from it.
+      await host.request('skills.manage', {
+        action: 'install',
+        query: name,
+        ...(forProfile
+          ? {
+              profile: forProfile
+            }
+          : {})
+      })
+      setInstalled(prev => ({
+        ...prev,
+        [label]: true
+      }))
+      host.notify({
+        kind: 'success',
+        message: `Skill "${label}" installed`
+      })
+
+      if (typeof onInstalled === 'function') {
+        onInstalled(label)
+      }
+    } catch (err) {
+      host.notifyError(err, `Installing "${label}" failed`)
+    } finally {
+      setInstalling(null)
+    }
+  }
+
+  installRef.current = install
+
+  return (
+    <div className="grid gap-1.5 border-t border-(--ui-stroke-secondary) pt-2">
+      <div className="flex items-baseline justify-between gap-2">
+        <div className="text-[0.7rem] font-medium text-(--ui-text-secondary)">Skills Hub</div>
+        <Button
+          className="text-[0.65rem] text-(--ui-text-quaternary) hover:text-(--ui-text-secondary)"
+          onClick={() => setBrowseHub(v => !v)}
+          size="inline"
+          variant="text"
+        >
+          {browseHub ? 'hide the hub browser' : 'browse the full hub ▾'}
+        </Button>
+      </div>
+      {browseHub ? (
+        <div className="grid gap-1">
+          {/* Resizable viewport: native CSS resize handle (bottom-right */
+          /* corner) lets the user drag it larger/smaller. The iframe */
+          /* inside is rendered oversized and scaled DOWN (133% × 0.75) */
+          /* so the hub page starts zoomed out — we can't style the */
+          /* cross-origin page itself, but scaling the frame is ours. */}
+          <div
+            className="relative w-full max-w-full resize overflow-hidden border border-(--ui-stroke-secondary)"
+            style={{
+              height: 560,
+              minHeight: 240,
+              minWidth: 320,
+              borderRadius: 8
+            }}
+          >
+            <iframe
+              ref={frameRef}
+              sandbox="allow-scripts allow-same-origin"
+              src={HUB_PICKER_URL}
+              style={{
+                width: '133.34%',
+                height: '133.34%',
+                border: 'none',
+                background: 'transparent',
+                transform: 'scale(0.75)',
+                transformOrigin: 'top left'
+              }}
+              title={b.tools.skillsHub}
+            />
+          </div>
+          <div className="px-1 text-[0.65rem] leading-4 text-(--ui-text-quaternary)">
+            {installing
+              ? `Installing "${installing}"…`
+              : 'Hit "+ Add to this Agent" on any skill — it installs and appears in the list above. Drag the corner to resize.'}
+          </div>
+        </div>
+      ) : null}
+      <div className="flex gap-1.5">
+        <Input
+          className="h-7 flex-1 text-xs"
+          onChange={event => setQuery(event.target.value)}
+          onKeyDown={event => {
+            // IME guard: Enter confirming a composed word must not search.
+            if (event.nativeEvent?.isComposing || event.keyCode === 229) {
+              return
+            }
+
+            if (event.key === 'Enter') {
+              event.preventDefault()
+              void search()
+            }
+          }}
+          placeholder={b.tools.searchHub}
+          value={query}
+        />
+        <Button disabled={searching || !query.trim()} onClick={() => void search()} size="sm" variant="secondary">
+          {searching ? 'Searching…' : 'Search'}
+        </Button>
+      </div>
+      {searching ? (
+        <div className="px-1 text-[0.65rem] text-(--ui-text-quaternary)">
+          Searching community + well-known sources — can take ~10s…
+        </div>
+      ) : null}
+      {results === null ? null : results.length === 0 ? (
+        <div className="px-1 py-1.5 text-[0.7rem] text-(--ui-text-quaternary)">No hub skills matched.</div>
+      ) : (
+        <div
+          className="overflow-y-auto overscroll-contain"
+          style={{
+            maxHeight: 150
+          }}
+        >
+          <div className="grid gap-1">
+            {results.map(r => (
+              <div className="flex items-center gap-2 text-xs" key={r.name}>
+                <div className="min-w-0 flex-1">
+                  <div className="truncate font-medium">{r.name}</div>
+                  {r.description ? (
+                    <div className="truncate text-[0.65rem] text-(--ui-text-quaternary)">{r.description}</div>
+                  ) : null}
+                </div>
+                {installed[r.name] ? (
+                  <span className="shrink-0 text-[0.65rem] text-(--ui-text-tertiary)">✓ added</span>
+                ) : (
+                  <Button
+                    className="shrink-0 px-2 font-semibold"
+                    disabled={installing !== null}
+                    onClick={() => void install(r.name)}
+                    size="sm"
+                    title={`Install "${r.name}" and add it to the list above`}
+                    variant="ghost"
+                  >
+                    {installing === r.name ? '…' : '+'}
+                  </Button>
+                )}
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/soul.test.ts b/apps/desktop/src/plugins/hermes-bots/soul.test.ts
new file mode 100644
index 000000000000..813111ce3abe
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/soul.test.ts
@@ -0,0 +1,192 @@
+/**
+ * The agent-to-agent messaging protocol section every SOUL has to keep.
+ *
+ * #16: a CUSTOM SOUL silently dropped the handoff protocol, which broke
+ * @mentions for every customized bot. The protocol is therefore appended
+ * idempotently — at create time, on save, and as a one-shot backfill for the
+ * pre-Bot-Mode personas (`default` above all) that never went through
+ * `composeSoul`.
+ *
+ * The escape hatch is the backend capability: once `profiles.list` reports
+ * `bot_mode_protocol`, the gateway injects the protocol into every session's
+ * system prompt and Bot Mode must stop writing to user SOUL files entirely —
+ * a second copy in SOUL.md is duplicated prompt the user did not ask for.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { RosterRow } from './types'
+
+const { hostMock, serverInjects } = vi.hoisted(() => ({
+  hostMock: { request: vi.fn() },
+  serverInjects: { value: false }
+}))
+
+vi.mock('@hermes/plugin-sdk', () => ({ host: hostMock }))
+
+vi.mock('./data', () => ({
+  botHandle: (name: string) => (String(name).toLowerCase() === 'default' ? 'hermes' : name),
+  // A live binding in the real module — useRoster flips it from the roster
+  // response, so the mock has to be a getter too.
+  get serverInjectsProtocol() {
+    return serverInjects.value
+  }
+}))
+
+const EXISTING_SOUL = `# Main agent
+
+I am the default profile on this machine.
+
+## Notes
+- Execute directly.
+`
+
+const roster = [
+  { description: 'main agent', name: 'default' },
+  { description: 'research specialist', name: 'researcher' }
+] as RosterRow[]
+
+const sectionCount = (soul: string) => soul.split('## Messaging other agents').length - 1
+
+async function loadSoul() {
+  vi.resetModules()
+
+  return import('./soul')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  serverInjects.value = false
+})
+
+describe('appending the protocol to an existing SOUL', () => {
+  it('appends once and never duplicates', async () => {
+    const { ensureMessagingProtocol } = await loadSoul()
+    const once = ensureMessagingProtocol(EXISTING_SOUL, 'default', roster)
+
+    expect(sectionCount(once)).toBe(1)
+    // Identity text is never overwritten.
+    expect(once).toMatch(/I am the default profile on this machine/)
+    expect(once).toMatch(/`researcher` — research specialist/)
+    // The primary profile addresses itself by its callable alias.
+    expect(once).toMatch(/@hermes/)
+    expect(once).not.toMatch(/@default/)
+
+    const twice = ensureMessagingProtocol(once, 'default', roster)
+
+    expect(twice).toBe(once.trim())
+    expect(sectionCount(twice)).toBe(1)
+  })
+
+  it('points at the real CLI verb, not the plural that does not exist', async () => {
+    const { ensureMessagingProtocol } = await loadSoul()
+    const soul = ensureMessagingProtocol('', 'default', roster)
+
+    expect(soul).toMatch(/run `hermes profile list` for the LIVE/)
+    expect(soul).not.toMatch(/hermes profiles list/)
+  })
+
+  it('seeds an empty SOUL with the section alone', async () => {
+    const { ensureMessagingProtocol } = await loadSoul()
+
+    expect(ensureMessagingProtocol('', 'ops', [])).toMatch(/^## Messaging other agents/)
+    expect(ensureMessagingProtocol('', 'ops', [])).toMatch(/- \(none yet\)/)
+  })
+})
+
+describe('composeSoul', () => {
+  it('does not double-append when the custom SOUL already carries the protocol', async () => {
+    const { composeSoul } = await loadSoul()
+
+    const withProtocol = composeSoul({
+      customSoul: '',
+      description: 'literature review',
+      name: 'researcher',
+      roster,
+      title: 'Researcher'
+    })
+
+    const cloned = composeSoul({ customSoul: withProtocol, name: 'researcher', roster })
+
+    expect(sectionCount(cloned)).toBe(1)
+  })
+})
+
+describe('one-shot backfill for profiles that predate the protocol', () => {
+  it('describes every bot but only configures the ones missing the section', async () => {
+    const calls: Array<{ method: string; payload: Record<string, string> }> = []
+
+    hostMock.request.mockImplementation(async (method: string, payload: Record<string, string>) => {
+      calls.push({ method, payload })
+
+      if (method === 'profiles.describe') {
+        return payload.name === 'researcher'
+          ? { soul: '# Researcher\n\n## Messaging other agents\n' }
+          : { soul: EXISTING_SOUL }
+      }
+
+      return { ok: true }
+    })
+
+    const { backfillMessagingProtocol } = await loadSoul()
+
+    backfillMessagingProtocol(roster)
+    await vi.waitFor(() => expect(calls.some(call => call.method === 'profiles.configure')).toBe(true))
+
+    expect(
+      calls
+        .filter(call => call.method === 'profiles.describe')
+        .map(call => call.payload.name)
+        .sort()
+    ).toEqual(['default', 'researcher'])
+
+    const configures = calls.filter(call => call.method === 'profiles.configure')
+
+    expect(configures).toHaveLength(1)
+    expect(configures[0].payload.name).toBe('default')
+    expect(configures[0].payload.soul).toMatch(/## Messaging other agents/)
+  })
+
+  it('does not hammer a gateway that fails the describe', async () => {
+    hostMock.request.mockRejectedValue(new Error('older gateway'))
+
+    const { backfillMessagingProtocol } = await loadSoul()
+
+    backfillMessagingProtocol(roster)
+    await vi.waitFor(() => expect(hostMock.request).toHaveBeenCalledTimes(2))
+
+    backfillMessagingProtocol(roster)
+    await vi.waitFor(() => expect(hostMock.request).toHaveBeenCalledTimes(2))
+  })
+})
+
+describe('the bot_mode_protocol backend capability suppresses every SOUL write', () => {
+  it('turns ensureMessagingProtocol into identity', async () => {
+    serverInjects.value = true
+
+    const { ensureMessagingProtocol } = await loadSoul()
+
+    expect(ensureMessagingProtocol(EXISTING_SOUL, 'default', [])).toBe(EXISTING_SOUL.trim())
+  })
+
+  it('issues no RPC at all from the backfill', async () => {
+    serverInjects.value = true
+
+    const { backfillMessagingProtocol } = await loadSoul()
+
+    backfillMessagingProtocol(roster)
+    await Promise.resolve()
+
+    expect(hostMock.request).not.toHaveBeenCalled()
+  })
+
+  it('leaves the section out of a generated identity SOUL', async () => {
+    serverInjects.value = true
+
+    const { composeSoul } = await loadSoul()
+
+    expect(composeSoul({ customSoul: '', description: 'D', name: 'newbot', roster: [], title: 'T' })).not.toMatch(
+      /## Messaging other agents/
+    )
+  })
+})
diff --git a/apps/desktop/src/plugins/hermes-bots/soul.ts b/apps/desktop/src/plugins/hermes-bots/soul.ts
new file mode 100644
index 000000000000..5050a89bbc12
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/soul.ts
@@ -0,0 +1,184 @@
+/**
+ * The SOUL a bot is born with, and the agent-to-agent messaging protocol
+ * section every SOUL has to keep.
+ *
+ * Three surfaces need a piece of this and none of them can own it: the create
+ * dialog composes a new SOUL, the advanced editor re-appends the protocol when
+ * a custom SOUL is saved, and the roster backfills profiles that predate it.
+ */
+
+import { host } from '@hermes/plugin-sdk'
+
+import { botHandle, serverInjectsProtocol } from './data'
+import { displayName } from './labels'
+import type { RosterRow } from './types'
+
+/** The agent-to-agent messaging protocol, reusable so a CUSTOM SOUL keeps
+ *  the handoff protocol too — a custom SOUL used to silently drop it,
+ *  breaking @mentions for customized bots (@wesleysimplicio, #16). */
+function messagingProtocolSection(name: string, roster: RosterRow[] | null | undefined): string {
+  const teammates = (roster || []).filter(b => b.name !== name)
+  const handle = botHandle(name)
+
+  return [
+    '## Messaging other agents',
+    '',
+    'You work alongside other named agents. Every agent (including you) has',
+    'ONE canonical conversation titled "Bot Chat" — created with the agent,',
+    'so it always exists. Agent-to-agent messages are delivered straight',
+    'into it, like a DM. To message a teammate, run:',
+    '',
+    '```',
+    'hermes -p <agent-name> chat --in ~ -c "Bot Chat" --create-if-missing -Q -q "Message from \uD83E\uDD16 ' +
+      handle +
+      ' (@' +
+      handle +
+      '): your message"',
+    '',
+    'Run the send with background=true and notify_on_complete=true on the',
+    'terminal tool, then finish your turn — the reply arrives later as a',
+    'background process notification. Never block waiting for it.',
+    '```',
+    '',
+    '(`--in ~ -c "Bot Chat" --create-if-missing` resumes their canonical',
+    'conversation in the home workspace, creating it if the target has no',
+    '"Bot Chat" yet. `-Q` keeps output clean. Always open with the',
+    '"Message from \uD83E\uDD16 ' + handle + ' (@' + handle + '):" prefix so they know',
+    'who is talking (the @handle lets the app show your avatar to them).',
+    'Their reply prints to stdout — relay the relevant part back to the',
+    'user, and say which agent it came from.)',
+    '',
+    'If a message in YOUR chat starts with "Message from \uD83E\uDD16 <name>", it is',
+    'a teammate messaging you, not the user. Answer it directly — your reply',
+    'reaches them via their own delivery — and use the same command if you',
+    'need to start a conversation yourself.',
+    '',
+    'When the user writes @<agent-name> or says "ask <name> to ..." /',
+    '"tell <name> ...", that is a handoff: message that agent, wait for the',
+    'reply, and report back.',
+    '',
+    'The roster grows over time — run `hermes profile list` for the LIVE',
+    'teammate list before a handoff. Teammates when you were created:',
+    ...(teammates.length
+      ? teammates.map(b => `- \`${b.name}\`${b.description ? ` — ${b.description}` : ''}`)
+      : ['- (none yet)'])
+  ].join('\n')
+}
+
+/** True when SOUL.md already carries the Bot Mode handoff section.
+ *  #16 appends this at create-time; pre-existing profiles (especially
+ *  `default`) never went through composeSoul and silently lack it. */
+function hasMessagingProtocol(soul: null | string | undefined): boolean {
+  return /(^|\n)## Messaging other agents(\s|$)/.test(soul || '')
+}
+
+/** Idempotent: append the protocol once, never duplicate a custom SOUL
+ *  that already has it (clone-from-default after a backfill, Edit save).
+ *  No-op when the backend injects the protocol into the system prompt
+ *  itself (bot_mode_protocol) — SOUL.md stays the user's identity text. */
+export function ensureMessagingProtocol(
+  soul: null | string | undefined,
+  name: string,
+  roster: RosterRow[] | null | undefined
+) {
+  const text = (soul || '').trim()
+
+  if (serverInjectsProtocol || hasMessagingProtocol(text)) {
+    return text
+  }
+
+  const section = messagingProtocolSection(name, roster)
+
+  return text ? text + '\n\n' + section : section
+}
+
+const soulProtocolChecked = new Set<string>()
+const soulProtocolInflight = new Set<string>()
+
+/** One-shot per profile per session: if an existing SOUL has no protocol,
+ *  append it. This is the install-time fix for default / pre-Bot-Mode
+ *  personas that #16 never touched. Never overwrites identity text. */
+export function backfillMessagingProtocol(roster: RosterRow[] | null | undefined) {
+  // Newer backends teach the protocol via the system prompt — never touch
+  // user SOUL files when the server already covers every session.
+  if (serverInjectsProtocol) {
+    return
+  }
+
+  for (const bot of roster || []) {
+    const name = bot && bot.name
+
+    if (!name || soulProtocolChecked.has(name) || soulProtocolInflight.has(name)) {
+      continue
+    }
+
+    soulProtocolInflight.add(name)
+    host
+      .request<{ soul?: string }>('profiles.describe', {
+        name
+      })
+      .then(res => {
+        const soul = (res && res.soul) || ''
+
+        if (hasMessagingProtocol(soul)) {
+          soulProtocolChecked.add(name)
+
+          return null
+        }
+
+        return host
+          .request('profiles.configure', {
+            name,
+            soul: ensureMessagingProtocol(soul, name, roster)
+          })
+          .then(() => {
+            soulProtocolChecked.add(name)
+          })
+      })
+      .catch(() => {
+        // Older gateway or a one-off describe/configure miss — do not hammer.
+        soulProtocolChecked.add(name)
+      })
+      .finally(() => {
+        soulProtocolInflight.delete(name)
+      })
+  }
+}
+
+/** SOUL.md for a new bot: identity (or the user's custom SOUL) + the
+ *  messaging protocol — which ships UNLESS the backend injects it into the
+ *  system prompt itself (bot_mode_protocol capability). */
+interface ComposeSoulOptions {
+  /** The user's own SOUL text, when the create form supplied one. */
+  customSoul?: null | string
+  description?: null | string
+  name: string
+  roster?: RosterRow[] | null
+  title?: null | string
+}
+
+export function composeSoul({ name, title, description, roster, customSoul }: ComposeSoulOptions): string {
+  if (customSoul && customSoul.trim()) {
+    return ensureMessagingProtocol(customSoul, name, roster)
+  }
+
+  const lines = [
+    `# ${displayName({
+      name,
+      title
+    })}`,
+    '',
+    title ? `**Role:** ${title}` : null,
+    description ? `**Mission:** ${description}` : null,
+    '',
+    `You are ${displayName({
+      name,
+      title
+    })}, a persistent named agent (profile \`${name}\`) on this machine.`,
+    'You keep your own memory, skills, and conversation history across sessions.'
+  ]
+
+  const identity = lines.filter(line => line !== null).join('\n')
+
+  return serverInjectsProtocol ? identity : identity + '\n\n' + messagingProtocolSection(name, roster)
+}
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/94478-mention-settle.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/94478-mention-settle.test.mjs
deleted file mode 100644
index 827a2d6c04ef..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/94478-mention-settle.test.mjs
+++ /dev/null
@@ -1,126 +0,0 @@
-/**
- * Regression tests for #94478 — a bot's @mention of a teammate inside its own
- * reply never drives the cited bot; the room records "settled" instead.
- *
- * Mechanism (traced on 6ce7ab8-era main, apps/desktop/src/plugins/hermes-bots/plugin.js):
- *
- * `resolveGroupResponders` (L6441) scopes responder selection to entries
- * SINCE THE LAST USER ENTRY. A member reply that @mentions a teammate lands
- * AFTER that user entry, so the mention IS visible to the next round's
- * selection — but only if the loop runs another round at all.
- *
- * The hole is the early exit at L7821: `if (spokeThisRound === 0) return`.
- * That guard exists for the everyone-passed case, but it also fires when the
- * round's responders had no NEW delta to read — e.g. every member already
- * spoke and the only new log entry is the citing member's reply. The cited
- * bot is in `mentioned`, but the loop exits before any further round can
- * select it: the room settles with an unresolved handoff. The same happens
- * when a cap (`GROUP_CHAT_MAX_ROUNDS` / `GROUP_CHAT_MAX_MESSAGES`) lands
- * between the mention and the next round.
- *
- * Fix contract:
- *  1. When a round produces zero spoken turns but the thread's tail contains
- *     an @mention of a member who has NOT yet answered it, drive one
- *     continuation round for exactly those cited members (still bounded by
- *     the GROUP_CHAT_MAX_* caps) instead of settling silently.
- *  2. If settling must happen anyway (cap exhausted), record an activity
- *     entry naming the unaddressed handoff so the room does not LOOK
- *     finished while a called bot never answered.
- */
-import assert from 'node:assert/strict'
-import test from 'node:test'
-
-// Mirror of resolveGroupResponders' scoping rule (plugin.js L6441): mentions
-// are collected from entries after the last user entry.
-function mentionedSinceLastUser(log, parseMentions) {
-  let sinceLastUser = []
-
-  for (let i = log.length - 1; i >= 0; i--) {
-    if (log[i].from.kind === 'user') {
-      sinceLastUser = log.slice(i)
-      break
-    }
-  }
-
-  const mentioned = new Set()
-
-  for (const entry of sinceLastUser) {
-    for (const name of parseMentions(entry.text)) {
-      mentioned.add(name)
-    }
-  }
-
-  return mentioned
-}
-
-test('#94478: detects an unanswered member mention in the post-user tail', () => {
-  // Room state from the issue: user asks, member radar replies citing @hermes.
-  const log = [
-    { id: 1, from: { kind: 'user' }, text: 'kick this off' },
-    { id: 2, from: { kind: 'member', name: 'radar' }, text: 'done — @hermes please review' }
-  ]
-
-  const mentioned = mentionedSinceLastUser(log, text => (text.includes('@hermes') ? ['hermes'] : []))
-
-  // Pre-fix, the loop exits via `spokeThisRound === 0` / cap exhaustion before
-  // any round can act on this mention. The fix's detector must find it so a
-  // continuation round can be driven for exactly [hermes].
-  assert.ok(mentioned.has('hermes'), 'cited member must be detected as pending')
-})
-
-test('#94478: does not flag a handoff the cited member already answered', () => {
-  const log = [
-    { id: 1, from: { kind: 'user' }, text: 'kick this off' },
-    { id: 2, from: { kind: 'member', name: 'radar' }, text: 'done — @hermes please review' },
-    { id: 3, from: { kind: 'member', name: 'hermes' }, text: 'reviewed, all good' }
-  ]
-
-  // hermes has a member entry AFTER the mentioning one — handoff resolved.
-  // The fix's detector must not re-drive an answered mention (that would loop).
-  const mentionIdx = log.findIndex(e => e.id === 2)
-  const answer = [...log].reverse().find(e => e.from.kind === 'member' && e.from.name === 'hermes')
-  const answerIdx = log.findIndex(e => answer && e.id === answer.id)
-
-  assert.ok(answerIdx > mentionIdx, 'answer must postdate the mention')
-})
-
-// --- exit-path wiring contracts (salvage follow-up) -------------------------
-// The two tests above pin the detector's semantics in isolation; these pin the
-// WIRING — the quiet-round exit must consult the detector before settling, and
-// a cap-forced exit must be labelled distinctly from consensus settle.
-import { readFileSync } from 'node:fs'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('#94478: the quiet-round exit consults unaddressedGroupMentions before settling', () => {
-  const loopStart = pluginSource.indexOf('async function runGroupChatRounds')
-  assert.ok(loopStart >= 0, 'runGroupChatRounds must exist')
-
-  const loop = pluginSource.slice(loopStart, pluginSource.indexOf('\n}', loopStart) + 2)
-
-  // The spokeThisRound === 0 path may no longer settle unconditionally: it
-  // must call the detector and drive a bounded continuation round first.
-  assert.ok(
-    loop.includes('unaddressedGroupMentions(group, members, thread)'),
-    'quiet-round exit must check for unanswered @mention handoffs before settling'
-  )
-  assert.ok(
-    loop.includes('GROUP_CHAT_MAX_CONTINUATIONS'),
-    'continuation rounds must be bounded by GROUP_CHAT_MAX_CONTINUATIONS'
-  )
-})
-
-test('#94478: a cap-forced exit is labelled distinctly from consensus settle', () => {
-  const loopStart = pluginSource.indexOf('async function runGroupChatRounds')
-  const loop = pluginSource.slice(loopStart, pluginSource.indexOf('\n}', loopStart) + 2)
-
-  // The finally must record the tracked exit kind, not a hardcoded 'settled'.
-  assert.ok(
-    /recordGroupActivity\(group, \{ kind: exitKind, member: null, thread \}\)/.test(loop),
-    'the drive-end activity entry must use the tracked exit kind'
-  )
-  assert.ok(/exitKind = 'capped'/.test(loop), 'cap exits must set the capped exit kind')
-
-  // And the activity vocabulary must know the new kind.
-  assert.ok(/\bcapped:\s*'/.test(pluginSource), "GROUP_ACTIVITY_LABELS must define 'capped'")
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/active-now-strip.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/active-now-strip.test.mjs
deleted file mode 100644
index d99b00755e1f..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/active-now-strip.test.mjs
+++ /dev/null
@@ -1,193 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// The activeBots helper must stay a self-contained slice between the
-// liveness-window constant and the BotRow section so tests can extract it.
-function loadActiveBotsSlice() {
-  const start = source.indexOf('const ACTIVE_WINDOW_S')
-  const end = source.indexOf('// ── bot row ─')
-
-  assert.ok(start >= 0 && end > start, 'activeBots block must remain extractable')
-
-  const context = {}
-  vm.runInNewContext(
-    `${source.slice(start, end)}\nglobalThis.__activeBots = activeBots;\nglobalThis.__botActivitySession = botActivitySession;`,
-    context
-  )
-
-  return context
-}
-
-function loadActiveBots() {
-  return loadActiveBotsSlice().__activeBots
-}
-
-function loadBotActivitySession() {
-  return loadActiveBotsSlice().__botActivitySession
-}
-
-// Fixed clock so "inside the window" vs "stale" is deterministic.
-const NOW = 1_000_000_000_000
-
-const roster = [
-  { name: 'researcher', last_session: { last_active: (NOW / 1000) - 10 } },
-  { name: 'scribe', last_session: { last_active: (NOW / 1000) - 400 } },
-  { name: 'analyst', last_session: null }
-]
-
-test('activeBots includes the gateway-busy selected profile before its first response lands', () => {
-  const activeBots = loadActiveBots()
-  // analyst has no last_session at all — a busy turn must still show it.
-  const names = activeBots(roster, 'analyst', 'busy', NOW).map(bot => bot.name)
-  assert.ok(names.includes('analyst'))
-})
-
-test('activeBots includes bots whose last message is inside the liveness window', () => {
-  const activeBots = loadActiveBots()
-  const names = activeBots(roster, 'default', 'open', NOW).map(bot => bot.name)
-  assert.ok(names.includes('researcher'))
-})
-
-test('activeBots excludes stale activity outside the window', () => {
-  const activeBots = loadActiveBots()
-  const names = activeBots(roster, 'default', 'open', NOW).map(bot => bot.name)
-  assert.ok(!names.includes('scribe'))
-})
-
-test('activeBots preserves roster order and never hides other bots', () => {
-  const activeBots = loadActiveBots()
-  // Mixed window: only researcher qualifies, but the output stays in input
-  // order and the full roster object is untouched.
-  const active = activeBots(roster, 'default', 'open', NOW)
-  assert.deepEqual(active.map(bot => bot.name), ['researcher'])
-  assert.equal(roster.length, 3)
-})
-
-test('activeBots returns an empty list when nothing is active', () => {
-  const activeBots = loadActiveBots()
-  const quiet = [
-    { name: 'scribe', last_session: { last_active: (NOW / 1000) - 400 } },
-    { name: 'analyst', last_session: null }
-  ]
-  assert.deepEqual(activeBots(quiet, 'default', 'open', NOW), [])
-})
-
-test('roster without profiles never throws', () => {
-  const activeBots = loadActiveBots()
-  assert.equal(activeBots(null, 'default', 'open', NOW).length, 0)
-  assert.equal(activeBots([], 'default', 'open', NOW).length, 0)
-})
-
-// ── botActivitySession: canonical Bot Chat activity counts (hermes-agent "6d ago" bug) ──
-
-test('botActivitySession picks the fresher canonical_session over a stale last_session', () => {
-  const botActivitySession = loadBotActivitySession()
-  const bot = {
-    // Canonical Bot Chat (hidden from session lists): messaged seconds ago.
-    canonical_session: { id: 'bot-chat', last_active: NOW / 1000 - 5, preview: 'fresh DM' },
-    // Newest VISIBLE session: 6 days old — what last_session alone reports.
-    last_session: { id: 'old-scratch', last_active: NOW / 1000 - 6 * 86400, preview: 'ancient' }
-  }
-  assert.equal(botActivitySession(bot).id, 'bot-chat')
-})
-
-test('botActivitySession keeps last_session when it is the fresher one', () => {
-  const botActivitySession = loadBotActivitySession()
-  const bot = {
-    canonical_session: { id: 'bot-chat', last_active: NOW / 1000 - 3600 },
-    last_session: { id: 'scratch', last_active: NOW / 1000 - 10 }
-  }
-  assert.equal(botActivitySession(bot).id, 'scratch')
-})
-
-test('botActivitySession degrades to whichever session summary exists on an older gateway', () => {
-  const botActivitySession = loadBotActivitySession()
-  assert.equal(botActivitySession({ last_session: { id: 'only', last_active: 1 } }).id, 'only')
-  assert.equal(botActivitySession({ canonical_session: { id: 'canonical', last_active: 1 } }).id, 'canonical')
-  assert.equal(botActivitySession({}), null)
-  assert.equal(botActivitySession(null), null)
-})
-
-test('activeBots counts Bot Chat activity that last_session cannot see', () => {
-  const activeBots = loadActiveBots()
-  const bots = [
-    {
-      name: 'default',
-      canonical_session: { last_active: NOW / 1000 - 5 },
-      last_session: { last_active: NOW / 1000 - 6 * 86400 }
-    }
-  ]
-  const names = activeBots(bots, 'other', 'open', NOW).map(bot => bot.name)
-  assert.ok(names.includes('default'), 'fresh canonical-chat activity must light the pulse dot')
-})
-
-test('row age label and recency sort key off botActivitySession, not last_session', () => {
-  // The "6d ago" regression: the timestamp/sort sites must not read
-  // bot.last_session directly anymore.
-  assert.match(source, /relativeTime\(rowAgeTs \* 1000\)/)
-  assert.match(source, /const lastMsg = \(botActivitySession\(bot\)\?\.last_active \|\| 0\) \* 1000/)
-  assert.doesNotMatch(source, /relativeTime\(last\.last_active \* 1000\)/)
-})
-
-// ── worker liveness: kanban/tool workers count as activity (#90268) ─────────
-
-test('activeBots includes a bot whose kanban worker heartbeat is fresh', () => {
-  const activeBots = loadActiveBots()
-  const bots = [
-    {
-      name: 'coding',
-      // Last chat hours ago — the reported "3 hr ago while working" shape.
-      last_session: { last_active: NOW / 1000 - 3 * 3600 },
-      worker_session: { id: 'w1', source: 'kanban', last_active: NOW / 1000 - 30 }
-    }
-  ]
-  const names = activeBots(bots, 'other', 'open', NOW).map(bot => bot.name)
-  assert.ok(names.includes('coding'), 'live worker heartbeat must light ACTIVE NOW')
-})
-
-test('activeBots ignores a finished worker outside the liveness window', () => {
-  const activeBots = loadActiveBots()
-  const bots = [
-    {
-      name: 'coding',
-      last_session: { last_active: NOW / 1000 - 3 * 3600 },
-      worker_session: { id: 'w1', source: 'kanban', last_active: NOW / 1000 - 3600 }
-    }
-  ]
-  assert.deepEqual(activeBots(bots, 'other', 'open', NOW), [])
-})
-
-test('ActiveNowStrip renders above the roster, is a live region, and is click-accessible', () => {
-  // Strip is placed between the pane header and the search field.
-  const headerEnd = source.indexOf("children: 'Bots'")
-  const searchField = source.indexOf("placeholder: 'Search bots and group chats…'")
-  assert.ok(headerEnd >= 0 && searchField > headerEnd)
-
-  const stripStart = source.indexOf('jsx(ActiveNowStrip')
-  assert.ok(stripStart > headerEnd && stripStart < searchField, 'strip sits between header and search')
-
-  // Live region announces membership changes politely.
-  assert.match(source, /'aria-live': 'polite'/)
-  // Chips use the shared Tip component, remain keyboard/click accessible,
-  // and open the canonical chat via the same path as roster rows.
-  assert.match(source, /label: `Open \$\{label\}'s chat`/)
-  assert.match(source, /'aria-label': `Open \$\{label\}'s chat`/)
-  // The key rides as jsx()'s third argument so React keeps chip identity.
-  assert.match(source, /botRosterKey\(bot\)\s*\)\s*\}\)\s*\]\s*\}\)\s*\}\s*\/\*\* Assign a bot to a group/s)
-  assert.match(source, /jsx\(BotFace,\s*\{[\s\S]*?mood: 'work'/)
-  // Chips share the exact-owner route with roster rows. That route activates the
-  // owner source, then resolves the profile's canonical name registry; no
-  // renderer pointer or preview-derived session id participates.
-  assert.match(source, /onOpen: bot => void openRosterBot\(bot\)/)
-
-  const openStart = source.indexOf('async function openRosterBot(')
-  assert.ok(openStart >= 0)
-  const open = source.slice(openStart, openStart + 3200)
-
-  assert.match(open, /await prepareBotSource\(bot\)/)
-  assert.match(open, /await openBotCanonicalChat\(bot, \(\) => generation === botOpenGeneration\)/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/activity-toasts.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/activity-toasts.test.mjs
deleted file mode 100644
index f085cba93932..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/activity-toasts.test.mjs
+++ /dev/null
@@ -1,99 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Activity toasts are OPT-IN: by default new bot activity only sets the
-// unread badge — host.notify fires only when the 'activity-toasts' pref is
-// enabled. A busy roster (cron runs, bot-to-bot chatter) must not firehose
-// the user with notifications out of the box.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadTracker(toastsEnabled) {
-  const start = source.indexOf('const rosterWatermarks = new Map()')
-  const end = source.indexOf('/** Last good cron list', start)
-  // The tracker keys watermarks off the REAL botActivitySession helper
-  // (defined later in plugin.js) — extract it so the harness can't drift.
-  const helperStart = source.indexOf('function botActivitySession(')
-  const helperEnd = source.indexOf('/** Bots that are working', helperStart)
-  assert.ok(helperStart >= 0 && helperEnd > helperStart, 'botActivitySession must remain extractable')
-  const notifications = []
-  const context = {
-    pluginCtx: null,
-    atom: initial => {
-      let value = initial
-      return { get: () => value, set: next => { value = next } }
-    },
-    host: { notify: params => notifications.push(params) },
-    $selectedBot: { get: () => 'default' },
-    $botMeta: { get: () => ({}) },
-    $botUnread: (() => {
-      let value = {}
-      return { get: () => value, set: next => { value = next } }
-    })(),
-    botRosterMeta: (bot, meta) => meta?.[bot.name] || null,
-    botSelectionKey: bot => bot.name,
-    displayName: bot => bot.name
-  }
-  const section = source
-    .slice(helperStart, helperEnd)
-    .concat('\n', source.slice(start, end))
-    .concat('\nglobalThis.__t = { trackInboundActivity, $activityToasts, setActivityToasts };\n')
-  vm.runInNewContext(section, context, { filename: 't.js' })
-  if (toastsEnabled) {
-    context.__t.$activityToasts.set(true)
-  }
-  return { ...context.__t, notifications, $botUnread: context.$botUnread }
-}
-
-function rosterAt(ts) {
-  return [{ name: 'researcher', last_session: { last_active: ts, preview: 'Message from writer: hi' } }]
-}
-
-test('default: new activity sets unread badge but never toasts', () => {
-  const t = loadTracker(false)
-  t.trackInboundActivity(rosterAt(100)) // seeding poll
-  t.trackInboundActivity(rosterAt(200)) // activity moved past watermark
-  assert.equal(t.$botUnread.get().researcher, true, 'unread badge must still be set')
-  assert.equal(t.notifications.length, 0, 'no toast by default')
-})
-
-test('opt-in: enabling the pref restores per-activity toasts', () => {
-  const t = loadTracker(true)
-  t.trackInboundActivity(rosterAt(100))
-  t.trackInboundActivity(rosterAt(200))
-  assert.equal(t.notifications.length, 1)
-  assert.match(t.notifications[0].title, /New message for researcher/)
-})
-
-test('pref defaults OFF and persists via ctx.storage under activity-toasts', () => {
-  const t = loadTracker(false)
-  assert.equal(t.$activityToasts.get(), false, 'default must be off')
-  assert.match(
-    source.slice(source.indexOf('function setActivityToasts('), source.indexOf('/** Detect new inbound activity')),
-    /storage\?\.set\?\.\('activity-toasts', enabled\)/
-  )
-  assert.match(source, /storage\?\.get\?\.\('activity-toasts'\)/)
-})
-
-test('Bot Chat opens pass the exported 60-second hydration budget', () => {
-  assert.match(source, /sdk\.BOT_CHAT_SESSION_HYDRATION_TIMEOUT_MS/)
-  assert.match(source, /hydrationTimeoutMs,/)
-})
-
-test('activity in the hidden canonical Bot Chat still badges (the "6d ago" class)', () => {
-  // The canonical Bot Chat is hidden from session lists, so last_session
-  // never advances when a DM lands there — only canonical_session does.
-  const t = loadTracker(false)
-  const at = ts => [
-    {
-      name: 'researcher',
-      last_session: { last_active: 100, preview: 'ancient scratch chat' },
-      canonical_session: { last_active: ts, preview: 'Message from writer: hi' }
-    }
-  ]
-  t.trackInboundActivity(at(150)) // seeding poll
-  t.trackInboundActivity(at(250)) // Bot Chat got a DM; last_session unchanged
-  assert.equal(t.$botUnread.get().researcher, true, 'hidden Bot Chat activity must set unread')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/blobatar-shapes.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/blobatar-shapes.test.mjs
deleted file mode 100644
index cf15fcc4b485..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/blobatar-shapes.test.mjs
+++ /dev/null
@@ -1,110 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load({ blobatarSvg } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const sdkStub = new Proxy(
-    { blobatarSvg },
-    { get: (target, key) => (key in target ? target[key] : undefined) }
-  )
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: { state: { profile: { listen: () => undefined }, gateway: { listen: () => undefined } } },
-    sdk: sdkStub
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-globalThis.__blob = { isBlobShape, parseBlobShape, blobShapeString, blobMarkup, BLOB_KINDS, BLOB_KIND_TRAIT };
-`)
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context.__blob
-}
-
-test('blob shape strings round-trip through parse/build', () => {
-  const b = load()
-
-  assert.equal(b.isBlobShape('blobatar'), true)
-  assert.equal(b.isBlobShape('blobatar:seed123'), true)
-  assert.equal(b.isBlobShape('blobatar::sun'), true)
-  assert.equal(b.isBlobShape('circle'), false)
-  assert.equal(b.isBlobShape(undefined), false)
-
-  // Unlocked: seed follows the name.
-  assert.equal(JSON.stringify(b.parseBlobShape('blobatar', 'inbox-triage')), JSON.stringify({ seed: 'inbox-triage', seedPart: '', kind: '' }))
-  // Locked seed.
-  assert.equal(JSON.stringify(b.parseBlobShape('blobatar:abc123', 'inbox-triage')), JSON.stringify({ seed: 'abc123', seedPart: 'abc123', kind: '' }))
-  // Pinned silhouette, unlocked seed.
-  assert.equal(JSON.stringify(b.parseBlobShape('blobatar::cloud', 'inbox-triage')), JSON.stringify({ seed: 'inbox-triage', seedPart: '', kind: 'cloud' }))
-  // Unknown silhouette is ignored, never trusted.
-  assert.equal(b.parseBlobShape('blobatar:abc:mystery', 'x').kind, '')
-
-  assert.equal(b.blobShapeString('', ''), 'blobatar')
-  assert.equal(b.blobShapeString('abc', ''), 'blobatar:abc')
-  assert.equal(b.blobShapeString('abc', 'sun'), 'blobatar:abc:sun')
-  assert.equal(b.blobShapeString('', 'sun'), 'blobatar::sun')
-})
-
-test('every silhouette has a trait position inside its frozen band', () => {
-  const b = load()
-  const bands = {
-    round: [0, 0.22], organic: [0.22, 0.48], boxy: [0.48, 0.60], capsule: [0.60, 0.70],
-    nub: [0.70, 0.79], cloud: [0.79, 0.86], droplet: [0.86, 0.915], hexagon: [0.915, 0.95],
-    sun: [0.95, 0.98], triangle: [0.98, 1]
-  }
-
-  for (const kind of b.BLOB_KINDS) {
-    const v = b.BLOB_KIND_TRAIT[kind]
-    assert.equal(typeof v, 'number', kind)
-    assert.ok(v >= bands[kind][0] && v < bands[kind][1], `${kind} trait ${v} outside band`)
-  }
-})
-
-test('blobMarkup renders via the SDK export, tags data-bot-face, pins traits', () => {
-  const calls = []
-  const b = load({
-    blobatarSvg: (seed, opts) => {
-      calls.push({ seed, opts })
-      return '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"></svg>'
-    }
-  })
-
-  const markup = b.blobMarkup('blobatar', 'inbox-triage', 56)
-  assert.ok(markup.startsWith('<svg data-bot-face="inbox-triage" '), 'roster PNG backfill needs the data-bot-face tag')
-  assert.equal(calls[0].seed, 'inbox-triage')
-  assert.equal(calls[0].opts.size, 56)
-  assert.equal('traits' in calls[0].opts, false)
-
-  b.blobMarkup('blobatar:abc:sun', 'inbox-triage', 32)
-  assert.equal(calls[1].seed, 'abc')
-  assert.equal(calls[1].opts.traits.shape, b.BLOB_KIND_TRAIT.sun)
-})
-
-test('blobMarkup degrades to null when the SDK lacks the export or the renderer throws', () => {
-  const withoutSdk = load()
-  assert.equal(withoutSdk.blobMarkup('blobatar', 'x', 32), null)
-
-  const throwing = load({
-    blobatarSvg: () => {
-      throw new Error('boom')
-    }
-  })
-  assert.equal(throwing.blobMarkup('blobatar', 'x', 32), null)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-attention-badge.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-attention-badge.test.mjs
deleted file mode 100644
index 71ec3e1be70d..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-attention-badge.test.mjs
+++ /dev/null
@@ -1,157 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Needs-attention badge (#93091 item 3): background bot failures whose class
-// is attention-worthy (auth, quota, missing config, blocked) badge the roster
-// tile; transient failures (rate limit, server error, timeout) never do; the
-// bot's next good turn clears the badge. Display-only state — hooks live at
-// the relay deliver reply and the group member turn boundary, and hidden bots
-// keep their entry (hiding is roster-display-only).
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** Evaluate just the delimited needs-attention helper section in a bare vm
- *  context (same slice-and-eval approach as the other pure-helper tests). */
-function loadHelpers() {
-  const start = pluginSource.indexOf('const BOT_ATTENTION_CLASSES')
-  const end = pluginSource.indexOf('/** Last good cron list')
-  assert.ok(start > -1 && end > start, 'needs-attention helper section exists')
-
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = { atom }
-  vm.createContext(context)
-
-  return vm.runInContext(
-    `${pluginSource.slice(start, end)}
-;({ BOT_ATTENTION_CLASSES, BOT_ATTENTION_HINTS, attentionReasonFromError, $botAttention, noteBotAttention, clearBotAttention })`,
-    context
-  )
-}
-
-test('classifier: reason codes pass through; matches the #93091 item-1 enum', () => {
-  const { BOT_ATTENTION_CLASSES, attentionReasonFromError } = loadHelpers()
-
-  assert.deepEqual(
-    [...BOT_ATTENTION_CLASSES].sort(),
-    ['agent_blocked', 'missing_config', 'provider_auth_or_access', 'provider_quota_limit']
-  )
-
-  for (const code of BOT_ATTENTION_CLASSES) {
-    assert.equal(attentionReasonFromError(code), code)
-  }
-})
-
-test('classifier: raw-text fallback maps current gateway error strings', () => {
-  const { attentionReasonFromError } = loadHelpers()
-
-  // The anthropic 401 shape observed on current main.
-  assert.equal(
-    attentionReasonFromError(
-      'Error code: 401 - {"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"}}'
-    ),
-    'provider_auth_or_access'
-  )
-  assert.equal(
-    attentionReasonFromError('No LLM provider configured. Run hermes model to pick one.'),
-    'missing_config'
-  )
-  assert.equal(attentionReasonFromError('No access token found for profile'), 'missing_config')
-  assert.equal(attentionReasonFromError('Your account is out of funds'), 'provider_quota_limit')
-  assert.equal(attentionReasonFromError('quota exceeded for this billing period'), 'provider_quota_limit')
-  assert.equal(attentionReasonFromError('agent is blocked awaiting approval'), 'agent_blocked')
-})
-
-test('classifier: transient classes never badge', () => {
-  const { attentionReasonFromError } = loadHelpers()
-
-  for (const text of [
-    'Rate limit exceeded, retry shortly',
-    'Error code: 429 - too many requests',
-    '500 Internal Server Error',
-    'upstream 503 service unavailable',
-    'the model is overloaded, try again',
-    'request timed out after 180s',
-    'temporarily unavailable',
-    '',
-    null,
-    undefined
-  ]) {
-    assert.equal(attentionReasonFromError(text), null, `expected null for ${JSON.stringify(text)}`)
-  }
-})
-
-test('lifecycle: set on classified failure, latest wins, cleared on success', () => {
-  const { $botAttention, noteBotAttention, clearBotAttention } = loadHelpers()
-
-  // Transient failure sets nothing.
-  noteBotAttention('radar', 'Rate limit exceeded')
-  assert.deepEqual(Object.keys($botAttention.get()), [])
-
-  // Classified failure badges the bot with reason + timestamp + snippet.
-  noteBotAttention('radar', 'Error code: 401 authentication_error')
-  const first = $botAttention.get().radar
-  assert.equal(first.reason, 'provider_auth_or_access')
-  assert.ok(first.at > 0)
-  assert.match(first.message, /401/)
-
-  // A later failure for the same bot merges — latest wins.
-  noteBotAttention('radar', 'No LLM provider configured')
-  assert.equal($botAttention.get().radar.reason, 'missing_config')
-
-  // Other bots are independent.
-  noteBotAttention('dixie', 'quota exceeded')
-  assert.equal($botAttention.get().dixie.reason, 'provider_quota_limit')
-
-  // The next good turn clears exactly that bot.
-  clearBotAttention('radar')
-  assert.equal($botAttention.get().radar, undefined)
-  assert.equal($botAttention.get().dixie.reason, 'provider_quota_limit')
-
-  // Clearing an unbadged bot is a no-op.
-  clearBotAttention('radar')
-  clearBotAttention('')
-  assert.equal($botAttention.get().dixie.reason, 'provider_quota_limit')
-})
-
-test('hooks: relay delivery and group member turns note/clear attention', () => {
-  // Relay drain: deliver success clears, deliver failure notes.
-  const drain = pluginSource.slice(
-    pluginSource.indexOf('async function drainRelayOutboxes'),
-    pluginSource.indexOf('function startBotRelay')
-  )
-  assert.match(drain, /clearBotAttention\(attentionKey\)/)
-  // #93091: the drain prefers the typed reason from bot_relay.deliver's
-  // error.data over free-text re-parsing, and forwards it to the reply.
-  assert.match(drain, /noteBotAttention\(attentionKey, reason \|\| error\?\.message \|\| error\)/)
-  assert.match(drain, /\.\.\.\(reason \? \{ reason \} : \{\}\)/)
-
-  // Group member turn boundary: failure notes under the member key; a real
-  // reply clears it. Typed gateway reasons take precedence over text parsing.
-  assert.match(
-    pluginSource,
-    /noteBotAttention\(groupMemberKey\(member\), reason \|\| error\?\.message \|\| error\)/
-  )
-  assert.match(pluginSource, /clearBotAttention\(groupMemberKey\(member\)\)/)
-})
-
-test('render: roster row shows an amber warning glyph with a per-class hint', () => {
-  assert.match(pluginSource, /BOT_ATTENTION_HINTS\[attention\.reason\]/)
-  assert.match(pluginSource, /name: 'warning'/)
-  // Lookup covers all three key shapes so relay- and group-recorded state
-  // renders, including local/unannotated rows keyed by the ACTIVE connection.
-  assert.match(pluginSource, /attentionByKey\[botSelectionKey\(bot\)\] \|\|/)
-  assert.match(pluginSource, /attentionByKey\[botRosterKey\(bot\)\] \|\|/)
-  assert.match(pluginSource, /attentionByKey\[`\$\{bot\?\.connectionId \|\| activeConnectionId\}::\$\{bot\?\.name \|\| 'default'\}`\]/)
-  // Hint copy for every class.
-  assert.match(pluginSource, /Sign in again for this profile/)
-  assert.match(pluginSource, /Quota or balance exhausted/)
-  assert.match(pluginSource, /Provider not configured — run hermes model/)
-  assert.match(pluginSource, /Bot is blocked — see its last message/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-delete.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-delete.test.mjs
deleted file mode 100644
index 63c58f0d14a4..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-delete.test.mjs
+++ /dev/null
@@ -1,226 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load({ activeConnectionId = 'local', activeProfile = 'default', sdkDeleteProfile = false } = {}) {
-  const requests = []
-  const sdkDeletes = []
-  const invalidations = []
-  const newChats = []
-  const stored = []
-  const storageOps = []
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      state: {
-        profile: { get: () => activeProfile, listen: () => undefined },
-        connectionId: { get: () => activeConnectionId, listen: () => undefined },
-        gateway: { listen: () => undefined }
-      },
-      newChat: profile => newChats.push(profile),
-      ...(sdkDeleteProfile
-        ? {
-            deleteProfile: async profile => {
-              sdkDeletes.push(profile)
-            }
-          }
-        : {}),
-      request: async (method, params) => {
-        requests.push({ method, params })
-        return method === 'cli.exec' ? { blocked: false, code: 0, output: 'deleted' } : { ok: true }
-      }
-    },
-    queryClient: { invalidateQueries: value => invalidations.push(value) }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__delete = { deleteBot, $botMeta, $botUnread, $selectedBot };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  context.plugin.register({
-    storage: {
-      get: () => null,
-      remove: key => storageOps.push({ op: 'remove', key }),
-      set: (key, value) => {
-        stored.push({ key, value })
-        storageOps.push({ op: 'set', key, value })
-      }
-    },
-    register: () => undefined
-  })
-  return { context, requests, sdkDeletes, invalidations, newChats, stored, storageOps }
-}
-
-test('unit: deleting a bot prefers the SDK deleteProfile (teardown-routed REST path)', async () => {
-  const { context, requests, sdkDeletes } = load({ sdkDeleteProfile: true })
-
-  await context.__delete.deleteBot({ name: 'researcher' })
-
-  assert.deepEqual(sdkDeletes, ['researcher'])
-  assert.equal(requests.filter(r => r.method === 'cli.exec').length, 0)
-})
-
-test('unit: source-scoped deletion preserves the route targetProfile', async () => {
-  const { context, sdkDeletes } = load({ sdkDeleteProfile: true })
-  const route = {
-    connectionId: 'source-a',
-    mode: 'remote',
-    profile: 'worker',
-    targetProfile: 'backend-worker'
-  }
-
-  await context.__delete.deleteBot({ name: 'worker', sourceScoped: true, route })
-
-  assert.deepEqual(JSON.parse(JSON.stringify(sdkDeletes)), [route])
-})
-
-test('unit: deleting same-name bot on another connection keeps the active chat', async () => {
-  const { context, newChats } = load({
-    activeConnectionId: 'source-b',
-    activeProfile: 'worker',
-    sdkDeleteProfile: true
-  })
-
-  await context.__delete.deleteBot({
-    name: 'worker',
-    sourceScoped: true,
-    route: {
-      connectionId: 'source-a',
-      mode: 'remote',
-      profile: 'worker',
-      targetProfile: 'worker'
-    }
-  })
-
-  assert.deepEqual(newChats, [])
-})
-
-test('unit: source-scoped deletion commits bot-meta-v2 atomically', async () => {
-  const { context, storageOps } = load({ sdkDeleteProfile: true })
-  const route = {
-    connectionId: 'source-a',
-    mode: 'remote',
-    profile: 'worker',
-    targetProfile: 'backend-worker'
-  }
-  const key = 'source-a::worker'
-  context.__delete.$botMeta.set({
-    [key]: { title: 'Worker' },
-    'source-a::writer': { title: 'Writer' }
-  })
-
-  await context.__delete.deleteBot({
-    name: 'worker',
-    sourceScoped: true,
-    route
-  })
-
-  assert.deepEqual(
-    JSON.parse(JSON.stringify(storageOps.slice(-3))),
-    [
-      { op: 'remove', key: 'bot-meta-v2-migrated' },
-      {
-        op: 'set',
-        key: 'bot-meta-v2',
-        value: { 'source-a::writer': { title: 'Writer' } }
-      },
-      { op: 'set', key: 'bot-meta-v2-migrated', value: true }
-    ]
-  )
-})
-
-test('unit: an alias targeting backend default is rejected before deletion', async () => {
-  const { context, sdkDeletes, requests } = load({ sdkDeleteProfile: true })
-
-  await assert.rejects(
-    context.__delete.deleteBot({
-      name: 'worker',
-      sourceScoped: true,
-      route: {
-        connectionId: 'source-a',
-        mode: 'remote',
-        profile: 'worker',
-        targetProfile: 'default'
-      }
-    }),
-    /default profile cannot be deleted/i
-  )
-
-  assert.deepEqual(sdkDeletes, [])
-  assert.equal(requests.some(request => request.method === 'cli.exec'), false)
-})
-
-test('unit: source-scoped deletion without host.deleteProfile fails closed without CLI execution', async () => {
-  const { context, requests } = load()
-
-  await assert.rejects(
-    context.__delete.deleteBot({
-      name: 'worker',
-      sourceScoped: true,
-      route: {
-        connectionId: 'source-a',
-        mode: 'remote',
-        profile: 'worker',
-        targetProfile: 'worker'
-      }
-    }),
-    /source-scoped profile deletion requires host\.deleteProfile/i
-  )
-
-  assert.equal(requests.some(request => request.method === 'cli.exec'), false)
-})
-
-test('unit: older desktop without host.deleteProfile falls back to the non-interactive profile CLI command', async () => {
-  const { context, requests } = load()
-
-  await context.__delete.deleteBot({ name: 'researcher' })
-
-  // The load-time hide sweep (hideOwnedBotSessions/sweepBotProfileSessions)
-  // may interleave its own profiles.list / session.* traffic — filter to the
-  // delete path's request.
-  const exec = requests.filter(r => r.method === 'cli.exec')
-  assert.deepEqual(JSON.parse(JSON.stringify(exec[0])), {
-    method: 'cli.exec',
-    params: { argv: ['profile', 'delete', 'researcher', '--yes'] }
-  })
-})
-
-test('integration: a deleted bot is removed from plugin-local state and the roster is refreshed', async () => {
-  const { context, invalidations, stored } = load()
-  context.__delete.$botMeta.set({ researcher: { title: 'Research' }, writer: { title: 'Writer' } })
-  context.__delete.$botUnread.set({ researcher: true, writer: true })
-  context.__delete.$selectedBot.set('researcher')
-
-  await context.__delete.deleteBot({ name: 'researcher' })
-
-  assert.equal(context.__delete.$botMeta.get().researcher, undefined)
-  assert.equal(context.__delete.$botUnread.get().researcher, undefined)
-  assert.equal(context.__delete.$selectedBot.get(), 'default')
-  assert.equal(stored.at(-1).key, 'bot-meta')
-  assert.equal(stored.at(-1).value.researcher, undefined)
-  assert.equal(invalidations.length, 1)
-})
-
-test('regression: the bot context menu exposes a destructive delete action and confirmation', () => {
-  assert.match(pluginSource, /ContextMenuItem, \{[\s\S]*?variant: 'destructive'[\s\S]*?children: 'Delete'/)
-  assert.match(pluginSource, /isDefaultBot\(bot\) \? null : jsx\(ContextMenuSeparator/)
-  assert.match(pluginSource, /ConfirmDialog/)
-  assert.match(pluginSource, /title: 'Delete bot and profile\?'/)
-  assert.match(pluginSource, /This will permanently delete the bot[\s\S]*?and its associated Hermes profile at[\s\S]*?This cannot be undone\./)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-asset-sync.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-asset-sync.test.mjs
deleted file mode 100644
index be07ef5d4358..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-asset-sync.test.mjs
+++ /dev/null
@@ -1,91 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Edit Profile always sends the avatar image in its saveBotMeta patch
-// (changed or not), and saveBotMeta fired profiles.set_asset for every patch
-// carrying the key. Each save re-uploaded the full data URL or fired a
-// `clear` — and a no-op `clear` from one machine could race another
-// machine's just-pushed avatar and wipe it server-side. set_asset now fires
-// only when the image actually changed; ui_meta sync is untouched.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const requests = []
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: (method, params) => {
-        requests.push([method, params])
-        return Promise.resolve({})
-      },
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } }
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__meta = { saveBotMeta, $botMeta };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  context.plugin.register({
-    storage: { get: () => null, set: () => undefined },
-    register: () => undefined
-  })
-  return { ...context.__meta, requests }
-}
-
-test('regression: set_asset fires only when the avatar image changes', async () => {
-  const { saveBotMeta, $botMeta, requests } = load()
-  const png = 'data:image/png;base64,AAAA'
-
-  saveBotMeta('ops', { image: png, title: 'One' })
-  saveBotMeta('ops', { image: png, title: 'Two' }) // re-save, same image
-  saveBotMeta('ops', { image: null, title: 'Three' }) // removed
-  saveBotMeta('ops', { title: 'Four' }) // no image key at all
-  await Promise.resolve()
-
-  const assetCalls = JSON.parse(
-    JSON.stringify(requests.filter(([method]) => method === 'profiles.set_asset').map(([, params]) => params))
-  )
-  assert.deepEqual(assetCalls, [
-    { name: 'ops', asset: 'avatar', data: png },
-    { name: 'ops', asset: 'avatar', clear: true }
-  ])
-
-  // Meta still merges per patch, and ui_meta sync is unaffected by the
-  // image-gating.
-  assert.equal($botMeta.get().ops.title, 'Four')
-  assert.equal(requests.filter(([method]) => method === 'profiles.configure').length, 4)
-})
-
-test('regression: duplicating a bot still pushes the copied avatar once', async () => {
-  const { saveBotMeta, requests } = load()
-  const png = 'data:image/png;base64,BBBB'
-
-  saveBotMeta('source', { image: png, title: 'Original' })
-  saveBotMeta('source-2', { image: png, title: 'Original (copy)' })
-  await Promise.resolve()
-
-  const assetCalls = JSON.parse(
-    JSON.stringify(requests.filter(([method]) => method === 'profiles.set_asset').map(([, params]) => params))
-  )
-  assert.deepEqual(assetCalls, [
-    { name: 'source', asset: 'avatar', data: png },
-    { name: 'source-2', asset: 'avatar', data: png } // fresh profile: image differs from its (empty) meta
-  ])
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-hydrate.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-hydrate.test.mjs
deleted file mode 100644
index 4da93318b083..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-hydrate.test.mjs
+++ /dev/null
@@ -1,91 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load(storageGet) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: async () => ({}),
-      state: {
-        profile: { listen: () => undefined },
-        gateway: { listen: () => undefined }
-      }
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__api = { saveBotMeta, $botMeta, plugin };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  context.plugin.register({
-    storage: { get: storageGet, set: () => undefined },
-    register: () => undefined
-  })
-  return context.__api
-}
-
-test('regression: a slow load does not wipe a pin written this session', async () => {
-  let resolveStorage
-  const pending = new Promise(resolve => {
-    resolveStorage = resolve
-  })
-  const runtime = load(() => pending)
-
-  runtime.saveBotMeta('researcher', { chat: 'sess-just-created', title: 'Research' })
-  assert.equal(runtime.$botMeta.get().researcher.chat, 'sess-just-created')
-
-  resolveStorage({ researcher: { title: 'Research' } })
-  await pending
-  await Promise.resolve()
-  await Promise.resolve()
-
-  assert.equal(runtime.$botMeta.get().researcher.chat, 'sess-just-created')
-  assert.equal(runtime.$botMeta.get().researcher.title, 'Research')
-})
-
-test('regression: a slow load still keeps looks from disk under a new pin', async () => {
-  let resolveStorage
-  const pending = new Promise(resolve => {
-    resolveStorage = resolve
-  })
-  const runtime = load(() => pending)
-
-  runtime.saveBotMeta('researcher', { chat: 'sess-just-created' })
-  resolveStorage({ researcher: { title: 'Research', shape: 'cloud', color: '#38bdf8' } })
-  await pending
-  await new Promise(resolve => setTimeout(resolve, 0))
-
-  assert.equal(runtime.$botMeta.get().researcher.chat, 'sess-just-created')
-  assert.equal(runtime.$botMeta.get().researcher.shape, 'cloud')
-  assert.equal(runtime.$botMeta.get().researcher.title, 'Research')
-})
-
-test('unit: disk still fills in bots we have not touched yet', async () => {
-  const runtime = load(() => ({
-    researcher: { title: 'Research', chat: 'sess-old' },
-    writer: { title: 'Writer' }
-  }))
-
-  await Promise.resolve()
-  await Promise.resolve()
-
-  assert.equal(runtime.$botMeta.get().researcher.chat, 'sess-old')
-  assert.equal(runtime.$botMeta.get().writer.title, 'Writer')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-persistence.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-persistence.test.mjs
deleted file mode 100644
index 9451b72a57aa..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-persistence.test.mjs
+++ /dev/null
@@ -1,99 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load(configureResponse) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const requests = []
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: (method, params) => {
-        requests.push([method, params])
-        if (method === 'profiles.configure') {
-          return typeof configureResponse === 'function' ? configureResponse() : Promise.resolve(configureResponse)
-        }
-        return Promise.resolve({})
-      },
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } }
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__meta = { saveBotMeta, $botMeta };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  context.plugin.register({
-    storage: { get: () => null, set: () => undefined },
-    register: () => undefined
-  })
-  return { ...context.__meta, requests }
-}
-
-test('server persistence failure is returned while the local look remains saved', async () => {
-  const { saveBotMeta, $botMeta } = load({ applied: { ui_meta: false } })
-
-  const result = await saveBotMeta('researcher', {
-    shape: 'cloud',
-    color: '#38bdf8',
-    custom: true
-  })
-
-  assert.equal($botMeta.get().researcher.shape, 'cloud')
-  assert.equal($botMeta.get().researcher.color, '#38bdf8')
-  assert.equal(result.serverPersisted, false)
-  assert.equal(result.serverOutcome, 'failed')
-})
-
-test('server persistence success is returned after ui_meta is applied', async () => {
-  const { saveBotMeta } = load({ applied: { ui_meta: true } })
-
-  const result = await saveBotMeta('researcher', {
-    shape: 'hexagon',
-    color: '#8b5cf6',
-    custom: true
-  })
-
-  assert.equal(result.serverPersisted, true)
-  assert.equal(result.serverOutcome, 'persisted')
-})
-
-test('an older gateway (no applied contract) is unsupported, not failed', async () => {
-  const { saveBotMeta } = load({})
-
-  const result = await saveBotMeta('researcher', { shape: 'circle', custom: true })
-
-  assert.equal(result.serverOutcome, 'unsupported')
-  assert.equal(result.serverPersisted, false)
-})
-
-test('a rejected configure request is unsupported, not failed', async () => {
-  const { saveBotMeta } = load(() => Promise.reject(new Error('param shape rejected')))
-
-  const result = await saveBotMeta('researcher', { shape: 'circle', custom: true })
-
-  assert.equal(result.serverOutcome, 'unsupported')
-})
-
-test('Edit Profile waits for persistence and reports a local-only save', () => {
-  assert.match(pluginSource, /const persistence = await saveBotMeta\(bot,/)
-  assert.match(pluginSource, /Saved look locally; remote persistence failed/)
-  // The toast fires only on an explicit remote failure — never on the
-  // documented older-gateway fallback.
-  assert.match(pluginSource, /serverOutcome === 'failed'/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-sync.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-sync.test.mjs
deleted file mode 100644
index e33a5be108f8..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-meta-sync.test.mjs
+++ /dev/null
@@ -1,139 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: { state: { profile: { listen: () => undefined } } },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const source = pluginSource
-    .replace(/^import \* as sdk from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-globalThis.__botMetaSync = {
-  get: () => $botMeta.get(),
-  set: value => $botMeta.set(value),
-  mergeServerMeta,
-  noteBotMetaWrite,
-  saveBotMeta,
-  setPluginCtx: value => { pluginCtx = value }
-};
-`)
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context.__botMetaSync
-}
-
-test('regression: authoritative server metadata removes stale local canonical chat', () => {
-  const writes = []
-  const sync = load()
-  sync.set({
-    default: {
-      chat: '4f6f6798ad6f',
-      shape: 'cloud',
-      image: 'data:image/png;base64,avatar',
-      pet: 'pet-cat'
-    }
-  })
-  sync.setPluginCtx({ storage: { set: (key, value) => writes.push({ key, value }) } })
-
-  sync.mergeServerMeta([
-    {
-      name: 'default',
-      ui_meta: {
-        'hermes-bots': { shape: 'cloud', color: '#8b5cf6', title: 'Hermana' }
-      }
-    }
-  ])
-
-  const current = sync.get().default
-  assert.equal(Object.hasOwn(current, 'chat'), false)
-  assert.equal(current.image, 'data:image/png;base64,avatar')
-  assert.equal(current.pet, 'pet-cat')
-  assert.equal(writes.at(-1).key, 'bot-meta')
-  assert.equal(Object.hasOwn(writes.at(-1).value.default, 'chat'), false)
-})
-
-test('regression: authoritative groups remove a stale local legacy group projection', () => {
-  const writes = []
-  const sync = load()
-  sync.set({ researcher: { groups: ['Old'], group: 'Old', title: 'Researcher' } })
-  sync.setPluginCtx({ storage: { set: (key, value) => writes.push({ key, value }) } })
-
-  sync.mergeServerMeta([
-    {
-      name: 'researcher',
-      ui_meta: { 'hermes-bots': { groups: [], title: 'Researcher' } }
-    }
-  ])
-
-  const current = sync.get().researcher
-  assert.deepEqual(current.groups, [])
-  assert.equal(Object.hasOwn(current, 'group'), false)
-  assert.equal(Object.hasOwn(writes.at(-1).value.researcher, 'group'), false)
-})
-
-test('compatibility: local canonical chat survives when gateway has no server bot metadata', () => {
-  const writes = []
-  const sync = load()
-  sync.set({ default: { chat: 'local-chat', shape: 'cloud' } })
-  sync.setPluginCtx({ storage: { set: (key, value) => writes.push({ key, value }) } })
-
-  sync.mergeServerMeta([{ name: 'default' }])
-
-  assert.equal(sync.get().default.chat, 'local-chat')
-  assert.equal(writes.length, 0)
-})
-
-test('regression (#disband-resurrection): a roster snapshot fetched BEFORE a local write cannot overlay it back', async () => {
-  const writes = []
-  const sync = load()
-  sync.set({ builder: { groups: ['Team'], group: 'Team', title: 'Builder' } })
-  sync.setPluginCtx({ storage: { set: (key, value) => writes.push({ key, value }) } })
-
-  // Snapshot fetched now — its ui_meta still names the group.
-  const staleFetchedAt = Date.now()
-  const staleRow = { name: 'builder', ui_meta: { 'hermes-bots': { groups: ['Team'], group: 'Team', title: 'Builder' } } }
-
-  // Disband path: saveBotMeta removes the membership AFTER the fetch.
-  await new Promise(resolve => setTimeout(resolve, 5))
-  await sync.saveBotMeta('builder', { groups: [], group: null })
-  assert.deepEqual(sync.get().builder.groups, [])
-
-  // The stale snapshot must NOT resurrect the membership...
-  sync.mergeServerMeta([staleRow], staleFetchedAt)
-  assert.deepEqual(sync.get().builder.groups, [])
-  assert.deepEqual(writes.at(-1).value.builder.groups, [])
-
-  // ...but a FRESH snapshot (fetched after the write) still gets the last
-  // word — server truth wins once it actually post-dates the local change.
-  sync.mergeServerMeta([staleRow], Date.now() + 5)
-  assert.deepEqual(sync.get().builder.groups, ['Team'])
-})
-
-test('compatibility: mergeServerMeta without fetchedAt overlays as before (no fence)', async () => {
-  const sync = load()
-  sync.set({})
-  sync.setPluginCtx({ storage: { set: () => undefined } })
-
-  await sync.saveBotMeta('builder', { groups: [], group: null })
-  sync.mergeServerMeta([{ name: 'builder', ui_meta: { 'hermes-bots': { groups: ['Team'] } } }])
-
-  assert.deepEqual(sync.get().builder.groups, ['Team'])
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-open-focus-identity.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-open-focus-identity.test.mjs
deleted file mode 100644
index 65b0c42aca82..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-open-focus-identity.test.mjs
+++ /dev/null
@@ -1,68 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// First-click home bounce (community report, Aug 2026): clicking a bot whose
-// canonical Bot Chat had been COMPRESSED landed on the Bots home instead of
-// the chat; only a second click got through. Root cause: openRosterBot
-// claimed the center with the durable registry id, but the session-focus
-// edge that the open itself fired reports the compression-lineage TIP —
-// releaseStaleOpenBotChat compared tip !== registry id, called the claim
-// stale, released it, and the home reasserted over the freshly opened chat.
-// The second click "worked" only because the tip was already focused, so no
-// new focus edge fired to sabotage it.
-//
-// Contract pinned here (source-shape):
-// - openBotCanonicalChat returns BOTH identities (registryId + openedId);
-// - the $openBotChat claim stores openedSessionId alongside openedRegistryId;
-// - releaseStaleOpenBotChat keeps the claim when the focused id matches
-//   EITHER identity, and still releases on a genuinely foreign session.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('canonical open returns both the registry row and the opened tip', () => {
-  const fn = pluginSource.slice(
-    pluginSource.indexOf('async function openBotCanonicalChat'),
-    pluginSource.indexOf('async function prepareBotSource')
-  )
-  assert.match(fn, /registryId: String\(existing\.id\)/)
-  assert.match(fn, /openedId: String\(openedId\)/)
-})
-
-test('the open claim carries the opened session id', () => {
-  const fn = pluginSource.slice(
-    pluginSource.indexOf('async function openRosterBot'),
-    pluginSource.indexOf('function displayName')
-  )
-  assert.match(fn, /openedSessionId: opened\.openedId/)
-})
-
-test('focus on either owned identity keeps the claim; foreign focus releases', () => {
-  const start = pluginSource.indexOf('function releaseStaleOpenBotChat')
-  const body = pluginSource.slice(start, pluginSource.indexOf('\n}', start) + 2)
-  // executable check: evaluate the function against a stub store
-  let stored = null
-  const $openBotChat = {
-    get: () => stored,
-    set: value => {
-      stored = value
-    }
-  }
-  const release = new Function('$openBotChat', `${body}; return releaseStaleOpenBotChat`)($openBotChat)
-
-  // compressed chat: claim carries registry 'reg-1' and tip 'tip-9'
-  stored = { key: 'k', openedRegistryId: 'reg-1', openedSessionId: 'tip-9' }
-  release('tip-9') // the focus edge the open itself fires
-  assert.ok(stored, 'tip focus must NOT release the claim (first-click bounce)')
-
-  release('reg-1')
-  assert.ok(stored, 'registry-id focus must not release either')
-
-  release('other-session')
-  assert.equal(stored, null, 'a genuinely foreign session releases the claim')
-
-  // legacy draft claim (no ids): any focused session releases
-  stored = { key: 'k', openedRegistryId: '' }
-  release('any')
-  assert.equal(stored, null)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-relay.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-relay.test.mjs
deleted file mode 100644
index d7b8cfae6215..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-relay.test.mjs
+++ /dev/null
@@ -1,80 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// The cross-connection bot relay (Aug 2026 ruling: connections ARE the peer
-// set). Source-shape contracts:
-// - both relay loops exist, start in register(), and stop via ctx.onDispose;
-// - the roster loop pushes bot_relay.roster.sync with agents from OTHER
-//   connections only;
-// - the drain loop wires drain → deliver → reply, and posts an error reply
-//   when the target connection is gone (waiter must never dangle);
-// - the remote-row toast no longer tells users messaging is device-local;
-// - the middleware note carries the message_agent target for cross-
-//   connection rows instead of implying they're unreachable.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('relay loops start in register() and stop on dispose', () => {
-  assert.match(pluginSource, /startBotRelay\(\)/)
-  assert.match(pluginSource, /ctx\.onDispose\(stopBotRelay\)/)
-  // teardown really clears both timers
-  const stop = pluginSource.slice(pluginSource.indexOf('function stopBotRelay'))
-  // 800-char window: stopBotRelay grew a retention release (#93594) ahead of
-  // the timer teardown it also must keep doing.
-  assert.match(stop.slice(0, 800), /clearInterval\(relayRosterTimer\)/)
-  assert.match(stop.slice(0, 800), /clearInterval\(relayDrainTimer\)/)
-})
-
-test('roster loop syncs OTHER connections agents to each gateway', () => {
-  const sync = pluginSource.slice(
-    pluginSource.indexOf('async function syncRelayRosters'),
-    pluginSource.indexOf('async function drainRelayOutboxes')
-  )
-  assert.match(sync, /bot_relay\.roster\.sync/)
-  assert.match(sync, /id !== connection\.id/)
-})
-
-test('roster loop never conflates a transient fetch failure with an empty connection', () => {
-  // relayAgentsOn signals failure as null (not []) so a live machine whose
-  // profiles.list blips is not pushed as absent — the gateway-side liveness
-  // check reads "absent from a fresh roster" as offline and would refuse
-  // enqueues with a false runtime_offline (#93091 item 2).
-  const fetch = pluginSource.slice(
-    pluginSource.indexOf('async function relayAgentsOn'),
-    pluginSource.indexOf('async function syncRelayRosters')
-  )
-  assert.match(fetch, /return null/)
-  assert.doesNotMatch(fetch.slice(fetch.indexOf('catch')), /return \[\]/)
-
-  // syncRelayRosters falls back to the last good rows on failure and prunes
-  // the cache for connections genuinely gone from profileRoutes.
-  const sync = pluginSource.slice(
-    pluginSource.indexOf('async function syncRelayRosters'),
-    pluginSource.indexOf('async function drainRelayOutboxes')
-  )
-  assert.match(sync, /agents === null/)
-  assert.match(sync, /relayAgentsCache\.get\(connection\.id\)/)
-  assert.match(sync, /relayAgentsCache\.delete\(id\)/)
-})
-
-test('drain loop wires drain → deliver → reply with error fallback', () => {
-  const drain = pluginSource.slice(
-    pluginSource.indexOf('async function drainRelayOutboxes'),
-    pluginSource.indexOf('function startBotRelay')
-  )
-  assert.match(drain, /bot_relay\.outbox\.drain/)
-  assert.match(drain, /bot_relay\.deliver/)
-  assert.match(drain, /bot_relay\.reply/)
-  // a missing target connection still posts a reply (error) for the waiter
-  assert.match(drain, /is not connected to this Desktop right now/)
-})
-
-test('remote-row dead-end toast is gone (rows open; relay carries DMs)', () => {
-  assert.doesNotMatch(pluginSource, /Gateway stays on this device/)
-})
-
-test('middleware note names the cross-connection message_agent target', () => {
-  assert.match(pluginSource, /message_agent target: "\$\{target\}"/)
-  assert.match(pluginSource, /agents on other connected machines are reachable too/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bot-row-keeps-closed-chat.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bot-row-keeps-closed-chat.test.mjs
deleted file mode 100644
index 6e7176066225..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bot-row-keeps-closed-chat.test.mjs
+++ /dev/null
@@ -1,144 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// A bot row click is "go to this bot", not "open its Bot Chat". Before this,
-// every click resolved the canonical chat by name and opened it as a tab —
-// with no record of a close anywhere (the plugin keeps no closed set; core's
-// tile bucket only forgets), a Bot Chat the user closed came back beside every
-// newer thread on every bot switch. Now a bot whose workspace already holds
-// tabs comes back to the one the user left; the forever-chat is opened only
-// when nothing is open, or on the explicit asks (row menu "Open Bot Chat",
-// Bots home "Open chat").
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-const atom = initial => {
-  let value = initial
-  return { get: () => value, set: next => { value = typeof next === 'function' ? next(value) : next }, listen: () => () => {} }
-}
-const jsx = (type, props = {}) => ({ type, props })
-
-function load({ focusHit = null, focusApi = true } = {}) {
-  const timeline = []
-  const host = {
-    state: {
-      profile: { get: () => 'default', listen: () => {} },
-      gateway: { get: () => 'open', listen: () => {} },
-      connectionId: { get: () => 'local', listen: () => {} }
-    },
-    request: async () => ({ profiles: [], sessions: [] }),
-    notify: () => {}, notifyError: error => timeline.push({ type: 'error', error }),
-    openSession: async (id, options) => timeline.push({ type: 'openSession', id, options }),
-    ensureAgent: async () => {}, requestProfile: async () => ({}),
-    activeConnectionId: () => 'local', warmAgent: () => {}, warmProfile: () => {},
-    newChat: () => timeline.push({ type: 'newChat' }), navigate: () => {},
-    setWorkspaceScope: (mode, ownerKey) => timeline.push({ type: 'scope', mode, ownerKey }),
-    openWorkspace: () => () => timeline.push({ type: 'homeClose' })
-  }
-  if (focusApi) {
-    host.focusOpenWorkspaceSession = ownerKey => {
-      timeline.push({ type: 'focus', ownerKey })
-      return focusHit
-    }
-  }
-  const ui = 'Button Checkbox Codicon ConfirmDialog ContextMenu ContextMenuContent ContextMenuItem ContextMenuSeparator ContextMenuTrigger CopyButton Dialog DialogContent DialogDescription DialogFooter DialogHeader DialogTitle DropdownMenu DropdownMenuContent DropdownMenuItem DropdownMenuTrigger EmptyState GlyphSpinner Input ScrollArea SearchField Select SelectContent SelectItem SelectTrigger SelectValue Switch Textarea Tip'.split(' ')
-  const context = {
-    atom, jsx, jsxs: jsx, cn: (...values) => values.filter(Boolean).join(' '), haptic: () => {},
-    useEffect: () => {}, useMemo: fn => fn(), useRef: value => ({ current: typeof value === 'function' ? value() : value }),
-    useState: value => [typeof value === 'function' ? value() : value, () => {}],
-    useValue: store => store?.get ? store.get() : store,
-    useQuery: () => ({ data: [], isLoading: false, isFetching: false, refetch: () => {} }),
-    ...Object.fromEntries(ui.map(name => [name, name])),
-    PALETTE_AREA: 'palette', COMPOSER_AREAS: { middleware: 'middleware' },
-    profileColor: () => '#000', queryClient: { invalidateQueries: () => {} }, relativeTime: () => 'now',
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => {} } },
-    setTimeout, clearTimeout, console, Date, Math, JSON, Promise, Map, Set, URL, Error,
-    Array, Object, String, Boolean, Number, RegExp, host
-  }
-  const code = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__h={openRosterBot,$openBotChat,$selectedRosterKey,$botsPaneVisible,openBotsHomeWorkspace};')
-  vm.runInNewContext(code, context, { filename: 'plugin.js' })
-  context.prepareBotSource = async bot => { timeline.push({ type: 'prepare', bot }) }
-  context.openBotCanonicalChat = async bot => {
-    timeline.push({ type: 'canonicalOpen', bot })
-    return { registryId: 'bot-chat', openedId: 'bot-chat' }
-  }
-  return { api: context.__h, timeline, host }
-}
-
-const bot = { connectionId: 'local', name: 'alpha', title: 'Alpha' }
-const types = runtime => runtime.timeline.map(event => event.type)
-
-test('a row click comes back to the tab the bot already has open — no canonical open', async () => {
-  const runtime = load({ focusHit: 'thread-2' })
-
-  assert.equal(await runtime.api.openRosterBot(bot), true)
-  assert.deepEqual(runtime.timeline.find(event => event.type === 'focus'), { type: 'focus', ownerKey: 'bot:alpha' })
-  assert.ok(!types(runtime).includes('canonicalOpen'), 'the closed Bot Chat must not be resolved or re-opened')
-  assert.ok(!types(runtime).includes('prepare'), 'open tabs need no source activation')
-  assert.ok(!types(runtime).includes('openSession'))
-  // The claim carries only the fronted tab: the focus edge it fires keeps the
-  // claim (releaseStaleOpenBotChat), the home yields, and no registry id is
-  // recorded because none was resolved.
-  assert.deepEqual({ ...runtime.api.$openBotChat.get() }, { key: 'local::alpha', openedRegistryId: '', openedSessionId: 'thread-2' })
-  assert.equal(runtime.api.$selectedRosterKey.get(), 'local::alpha')
-})
-
-test('a bot with nothing open still opens its canonical chat', async () => {
-  const runtime = load({ focusHit: null })
-
-  assert.equal(await runtime.api.openRosterBot(bot), true)
-  assert.deepEqual(types(runtime).filter(type => type !== 'scope'), ['focus', 'prepare', 'canonicalOpen'])
-  assert.equal(runtime.api.$openBotChat.get()?.openedRegistryId, 'bot-chat')
-})
-
-test('the explicit canonical ask skips the open-tab shortcut', async () => {
-  const runtime = load({ focusHit: 'thread-2' })
-
-  assert.equal(await runtime.api.openRosterBot(bot, { canonical: true }), true)
-  assert.ok(!types(runtime).includes('focus'))
-  assert.ok(types(runtime).includes('canonicalOpen'))
-  assert.equal(runtime.api.$openBotChat.get()?.openedRegistryId, 'bot-chat')
-})
-
-test('an older shell without the focus API opens the canonical chat as before', async () => {
-  const runtime = load({ focusApi: false, focusHit: 'thread-2' })
-
-  assert.equal(await runtime.api.openRosterBot(bot), true)
-  assert.deepEqual(types(runtime).filter(type => type !== 'scope'), ['prepare', 'canonicalOpen'])
-})
-
-test('a throwing focus API degrades to the canonical open', async () => {
-  const runtime = load()
-  runtime.host.focusOpenWorkspaceSession = () => { throw new Error('no tree yet') }
-
-  assert.equal(await runtime.api.openRosterBot(bot), true)
-  assert.ok(types(runtime).includes('canonicalOpen'))
-})
-
-test('the explicit asks pass canonical: true (row menu, Bots home)', () => {
-  const menu = pluginSource.slice(pluginSource.indexOf("children: 'Open Bot Chat'") - 400, pluginSource.indexOf("children: 'Open Bot Chat'"))
-  assert.match(menu, /openRosterBot\(bot, \{ canonical: true \}\)/)
-
-  const home = pluginSource.slice(pluginSource.indexOf("children: 'Open chat'") - 400, pluginSource.indexOf("children: 'Open chat'"))
-  assert.match(home, /openRosterBot\(bot, \{ canonical: true \}\)/)
-
-  // A plain row click and the Active Now strip stay "go to this bot".
-  assert.match(pluginSource, /const open = \(\) => void openRosterBot\(bot\)\n/)
-  assert.match(pluginSource, /onOpen: bot => void openRosterBot\(bot\)\n/)
-})
-
-test('a reclaim of a fronted non-canonical tab does not re-resolve the Bot Chat', () => {
-  const start = pluginSource.indexOf("host.onEvent('session.reclaimed'")
-  const block = pluginSource.slice(start, pluginSource.indexOf('stopSidebarSync', start))
-  const guard = block.indexOf('if (!claim.openedRegistryId)')
-  assert.ok(guard > 0, 'reclaim listener guards on the registry id')
-  assert.ok(guard < block.indexOf('openBotCanonicalChat(bot)'), 'the guard precedes the canonical re-open')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bots-home-refront-loop.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bots-home-refront-loop.test.mjs
deleted file mode 100644
index a72a369f6966..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bots-home-refront-loop.test.mjs
+++ /dev/null
@@ -1,218 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Re-fronting the Bots home is a CLOSE followed by an OPEN of the workspace
-// tab, which tears down and rebuilds the whole Bots view. The re-front branch
-// runs whenever a passive reconcile finds the tab open but not holding its
-// zone's active slot — and it is completely unbounded: it re-fronts again on
-// every pass, for as long as that condition holds.
-//
-// The condition is not always transient. `revealTreePane` returns early for a
-// pane in `$hiddenTreePanes` WITHOUT activating it, `isPaneVisible` is false
-// for a minimized zone, and a pane the tree never adopted has no group at all.
-// Pinned in that state, every surface sync the plugin runs — sidebar
-// visibility flips, focus churn, group changes all call syncWorkspaceSurfaces
-// — costs one full remount of the Bots view. That is the strobe in the bug
-// report's screen recording: successive frames differ only by text
-// re-rasterization across the whole view, the signature of a remount rather
-// than a repaint.
-//
-// The invariant: a PASSIVE reconcile gets one re-front attempt. If the shell
-// does not grant visibility, the plugin stops rather than remounting on every
-// subsequent signal. An explicit user gesture is still always honored.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** A shell whose reveal does NOT hand the tab its zone's active slot, modelled
- *  on `revealTreePane`'s hidden-pane early return. `grantsVisibility: true`
- *  restores the cooperative shell so the same harness covers both directions. */
-function load({ grantsVisibility = false } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = {
-      get: () => values.get(slot),
-      set: value => {
-        values.set(slot, value)
-        for (const fn of slot.__listeners || []) {
-          fn(value)
-        }
-      },
-      listen: fn => {
-        slot.__listeners = [...(slot.__listeners || []), fn]
-        return () => {
-          slot.__listeners = (slot.__listeners || []).filter(entry => entry !== fn)
-        }
-      }
-    }
-    values.set(slot, initial)
-    return slot
-  }
-
-  const opened = []
-  const closed = []
-  const visible = new Map()
-  const watchers = new Map()
-
-  // Synchronous notification, like a nanostores computed over $layoutTree.
-  const setVisible = (paneId, value) => {
-    if (visible.get(paneId) === value) {
-      return
-    }
-
-    visible.set(paneId, value)
-    for (const fn of watchers.get(paneId) || []) {
-      fn(value)
-    }
-  }
-
-  const host = {
-    state: {
-      profile: { get: () => 'default', listen: () => undefined },
-      gateway: { get: () => 'open', listen: () => undefined },
-      focusedStoredSessionId: atom(null)
-    },
-    request: async () => ({}),
-    requestProfile: async () => ({}),
-    openSession: async () => undefined,
-    setWorkspaceScope: () => true,
-    notify: () => undefined,
-    notifyError: () => undefined,
-    ensureAgent: async () => undefined,
-    activeConnectionId: () => 'local',
-    openWorkspace: (id, options) => {
-      const paneId = `plugin-workspace:${id}`
-      const entry = { id, options }
-      opened.push(entry)
-      setVisible(paneId, grantsVisibility)
-
-      return () => {
-        closed.push(entry)
-        setVisible(paneId, false)
-        options.onClose?.()
-      }
-    },
-    paneVisibility: paneId => ({
-      get: () => visible.get(paneId) ?? false,
-      listen: fn => {
-        watchers.set(paneId, [...(watchers.get(paneId) || []), fn])
-        return () => watchers.set(paneId, (watchers.get(paneId) || []).filter(entry => entry !== fn))
-      }
-    })
-  }
-
-  const context = {
-    atom,
-    haptic: () => undefined,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host,
-    queryClient: { invalidateQueries: () => undefined },
-    navigator: { clipboard: { writeText: async () => undefined } },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-globalThis.__refront = {
-  syncBotsHomeWorkspace,
-  openBotsHomeWorkspace,
-  closeBotsHomeWorkspace,
-  botsHomeVisible,
-  BOTS_HOME_PANE_ID,
-  $botsPaneVisible,
-  $openBotChat
-};
-`)
-
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-
-  return { ...context.__refront, closed, host, opened, setVisible }
-}
-
-test('a passive reconcile re-fronts the home once, not forever', () => {
-  const t = load({ grantsVisibility: false })
-  t.$botsPaneVisible.set(true)
-
-  // First pass opens the tab. The shell does not front it.
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 1)
-  assert.equal(t.botsHomeVisible(), false, 'the shell withheld the active slot')
-
-  // Every later passive pass sees "open but not visible" and takes the
-  // re-front branch. Before the fix each pass closed and re-opened the tab,
-  // remounting the whole Bots view — 20 passes, 20 remounts.
-  for (let i = 0; i < 20; i++) {
-    t.syncBotsHomeWorkspace()
-  }
-
-  assert.equal(t.opened.length, 2, 'exactly one re-front attempt, then the plugin stops')
-  assert.equal(t.closed.length, 1)
-})
-
-test('giving up on the re-front still leaves the tab open', () => {
-  const t = load({ grantsVisibility: false })
-  t.$botsPaneVisible.set(true)
-
-  t.syncBotsHomeWorkspace()
-  for (let i = 0; i < 5; i++) {
-    t.syncBotsHomeWorkspace()
-  }
-
-  // Bounding the retries must not degrade into closing the home: the Bots tab
-  // would fall through to the ownerless Sessions composer, which is the exact
-  // hole the home exists to plug. Stop re-fronting, keep the surface.
-  assert.equal(t.closed.length, 1, 'one close, from the single re-front — not a teardown')
-  assert.equal(t.opened.length, 2)
-})
-
-test('a cooperative shell still gets its one legitimate re-front', () => {
-  const t = load({ grantsVisibility: true })
-  t.$botsPaneVisible.set(true)
-
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 1)
-  assert.equal(t.botsHomeVisible(), true)
-
-  // A persisted layout can restore the tab BEHIND the core draft pane. The
-  // home must still reclaim the active slot — the fix bounds retries, it does
-  // not remove the re-front (bots-home.test.mjs pins this case too).
-  t.setVisible(t.BOTS_HOME_PANE_ID, false)
-  t.syncBotsHomeWorkspace()
-
-  assert.equal(t.opened.length, 2, 're-opened to reclaim the active slot')
-  assert.equal(t.botsHomeVisible(), true)
-
-  // And having converged, the plugin is free to re-front again the next time
-  // the tab is genuinely backgrounded: the bound is per-attempt, not one-shot.
-  t.setVisible(t.BOTS_HOME_PANE_ID, false)
-  t.syncBotsHomeWorkspace()
-
-  assert.equal(t.opened.length, 3)
-})
-
-test('an explicit gesture is never blocked by the passive bound', () => {
-  const t = load({ grantsVisibility: false })
-  t.$botsPaneVisible.set(true)
-
-  t.syncBotsHomeWorkspace()
-  for (let i = 0; i < 5; i++) {
-    t.syncBotsHomeWorkspace()
-  }
-  const passive = t.opened.length
-
-  // The user clicked a bot whose owner is unavailable: the home IS the
-  // destination, so the gesture must re-front even though passive reconciles
-  // have given up on this shell.
-  t.openBotsHomeWorkspace(true)
-
-  assert.equal(t.opened.length, passive + 1, 'an explicit open always re-fronts')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bots-home.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bots-home.test.mjs
deleted file mode 100644
index c29a8c34e998..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bots-home.test.mjs
+++ /dev/null
@@ -1,1152 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Bot Mode's main workspace always has ONE clear owner: a bot chat, a group
-// chat, or the Bots home. The home exists so the Bots tab never falls through
-// to the ownerless Sessions composer.
-//
-// The invariant under test is #90149's: an existing resource carries its exact
-// owner. Selecting or RESTORING a bot is presentation only — it must never
-// activate a gateway, open a chat, create a session, or route a remote bot
-// through whatever connection happens to be live.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load({ focusedStoredSessionId = null, paneVisibility = true, openWorkspace = true } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = {
-      get: () => values.get(slot),
-      set: value => {
-        values.set(slot, value)
-        for (const fn of slot.__listeners || []) {
-          fn(value)
-        }
-      },
-      listen: fn => {
-        slot.__listeners = [...(slot.__listeners || []), fn]
-        return () => {
-          slot.__listeners = (slot.__listeners || []).filter(entry => entry !== fn)
-        }
-      }
-    }
-    values.set(slot, initial)
-    return slot
-  }
-
-  const opened = []
-  const closed = []
-  const notifications = []
-  const requests = []
-  const invalidations = []
-  const sessionOpens = []
-  const workspaceScopes = []
-  const paneVisible = new Map()
-  const focused = atom(focusedStoredSessionId)
-
-  const host = {
-    state: {
-      profile: { get: () => 'default', listen: () => undefined },
-      gateway: { get: () => 'open', listen: () => undefined },
-      focusedStoredSessionId: focused
-    },
-    request: (method, params) => {
-      requests.push({ method, params })
-      return Promise.resolve({})
-    },
-    requestProfile: (route, method, params) => {
-      requests.push({ method, params, route })
-      if (method === 'profiles.list') {
-        return Promise.resolve({ profiles: [{ name: route.targetProfile || route.profile }] })
-      }
-      if (method === 'session.list') {
-        return Promise.resolve({
-          sessions: [{ id: `chat-${route.connectionId}-${route.profile}`, title: 'Bot Chat', message_count: 1 }]
-        })
-      }
-      return Promise.resolve({})
-    },
-    openSession: async (id, options) => sessionOpens.push({ id, options }),
-    setWorkspaceScope: (mode, ownerKey = null) => {
-      workspaceScopes.push({ mode, ownerKey })
-      return true
-    },
-    notify: params => notifications.push(params),
-    notifyError: (error, fallback) => notifications.push({ kind: 'error', message: fallback, error }),
-    ensureAgent: async () => undefined,
-    activeConnectionId: () => 'local'
-  }
-
-  if (openWorkspace) {
-    host.openWorkspace = (id, options) => {
-      const entry = { id, options, disposed: false }
-      opened.push(entry)
-      paneVisible.set(`plugin-workspace:${id}`, true)
-
-      return () => {
-        entry.disposed = true
-        closed.push(entry)
-        paneVisible.set(`plugin-workspace:${id}`, false)
-        options.onClose?.()
-      }
-    }
-  }
-
-  if (paneVisibility) {
-    host.paneVisibility = id => ({
-      get: () => paneVisible.get(id) ?? false,
-      listen: () => () => undefined
-    })
-  }
-
-  const context = {
-    atom,
-    haptic: () => undefined,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host,
-    queryClient: { invalidateQueries: params => invalidations.push(params) },
-    navigator: { clipboard: { writeText: async () => undefined } },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-globalThis.__home = {
-  botRosterKey,
-  parseRosterKey,
-  ghostRosterOwner,
-  rosterWithSelectedOwner,
-  reconcileRosterSelection,
-  saveSelectedRosterBot,
-  clearSelectedRosterBot,
-  clearSelectedRosterKey,
-  releaseStaleOpenBotChat,
-  syncBotsHomeWorkspace,
-  openBotsHomeWorkspace,
-  closeBotsHomeWorkspace,
-  botsHomeMayOpen,
-  botsHomeVisible,
-  botChatOwnsWorkspace,
-  sessionOwnsWorkspace,
-  openRosterBot,
-  openGroupChat,
-  closeGroupChatMainTab,
-  prepareBotSource,
-  $botMeta,
-  $botsPaneVisible,
-  $botChatFocused,
-  $botsHomeFronted,
-  $groupChatWorkspace,
-  $groupChats,
-  $lastRoster,
-  $lastSources,
-  $openBotChat,
-  $rosterHydrated,
-  $selectedBot,
-  $selectedRosterHydrated,
-  $selectedRosterKey,
-  setPluginCtx: value => { pluginCtx = value }
-};
-`)
-
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-
-  return {
-    ...context.__home,
-    closed,
-    focused,
-    host,
-    invalidations,
-    notifications,
-    opened,
-    paneVisible,
-    requests,
-    sessionOpens,
-    workspaceScopes
-  }
-}
-
-/** Every door that would create, activate, or route something. A passive
- *  selection must touch none of them. */
-function assertNothingRouted(t, label) {
-  assert.deepEqual(t.requests, [], `${label}: no gateway RPC`)
-  assert.deepEqual(t.opened.filter(entry => entry.id !== 'hermes-bots:home'), [], `${label}: no chat surface opened`)
-}
-
-// ── selection is source-qualified and presentation-only ─────────────────────
-
-test('selection persists the source-qualified key, not the bare profile name', () => {
-  const t = load()
-  const writes = []
-  t.setPluginCtx({ storage: { set: (key, value) => writes.push({ key, value }) } })
-
-  t.saveSelectedRosterBot({ connectionId: 'work-vps', name: 'researcher', remoteSource: true })
-
-  assert.equal(t.$selectedRosterKey.get(), 'work-vps::researcher')
-  assert.deepEqual(writes.at(-1), { key: 'selected-roster-bot-v1', value: 'work-vps::researcher' })
-  assertNothingRouted(t, 'saving a selection')
-})
-
-test('a remote selection keeps the exact-owner selection distinct from a local twin', () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-
-  // Same profile name on two gateways — the exact-owner class from #90149.
-  t.saveSelectedRosterBot({ connectionId: 'local', name: 'default' })
-  assert.equal(t.$selectedBot.get(), 'default')
-
-  t.saveSelectedRosterBot({ connectionId: 'mac-mini', name: 'default', remoteSource: true })
-
-  assert.equal(t.$selectedRosterKey.get(), 'mac-mini::default')
-  assert.equal(
-    t.$selectedBot.get(),
-    'mac-mini::default',
-    'the shared selection follows the same exact owner as the roster workspace'
-  )
-})
-
-test('clearing only fires for the exact selected owner', () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.saveSelectedRosterBot({ connectionId: 'local', name: 'writer' })
-
-  t.clearSelectedRosterBot({ connectionId: 'mac-mini', name: 'writer' })
-  assert.equal(t.$selectedRosterKey.get(), 'local::writer', 'a same-named bot elsewhere must not clear this one')
-
-  t.clearSelectedRosterBot({ connectionId: 'local', name: 'writer' })
-  assert.equal(t.$selectedRosterKey.get(), '')
-})
-
-test('roster keys round-trip through parseRosterKey', () => {
-  const t = load()
-  const parsed = key => ({ ...t.parseRosterKey(key) })
-
-  assert.deepEqual(parsed('work-vps::researcher'), { connectionId: 'work-vps', name: 'researcher' })
-  assert.deepEqual(parsed('local::default'), { connectionId: 'local', name: 'default' })
-  assert.deepEqual(parsed(''), { connectionId: '', name: '' })
-  // A key always round-trips from the identity that produced it.
-  const bot = { connectionId: 'work-vps', name: 'researcher' }
-  assert.deepEqual(parsed(t.botRosterKey(bot)), { connectionId: 'work-vps', name: 'researcher' })
-})
-
-// ── hydration ───────────────────────────────────────────────────────────────
-
-test('hydration restores the stored key and flips the hydrated flag', async () => {
-  const t = load()
-  t.$selectedRosterHydrated.set(false)
-
-  const ctx = {
-    storage: { get: key => (key === 'selected-roster-bot-v1' ? 'work-vps::researcher' : undefined), set: () => undefined },
-    register: () => () => undefined,
-    onDispose: () => undefined
-  }
-
-  // Only the selection hydrate is under test; run it the way register() does.
-  await Promise.resolve(ctx.storage.get('selected-roster-bot-v1')).then(value => {
-    if (typeof value === 'string' && value.trim()) {
-      t.$selectedRosterKey.set(value.trim())
-    }
-  })
-  t.$selectedRosterHydrated.set(true)
-
-  assert.equal(t.$selectedRosterKey.get(), 'work-vps::researcher')
-  assert.equal(t.$selectedRosterHydrated.get(), true)
-  assertNothingRouted(t, 'restoring a selection')
-})
-
-test('source contract: every hydrate settle path flips the flag, and none of them opens anything', () => {
-  assert.match(
-    pluginSource,
-    /Promise\.resolve\(ctx\.storage\?\.get\?\.\('selected-roster-bot-v1'\)\)[\s\S]{0,400}?\.finally\(\(\) => \$selectedRosterHydrated\.set\(true\)\)/,
-    'a storage quirk must not strand the home in its loading state'
-  )
-  assert.match(pluginSource, /\} catch \{\s*\n\s*\/\* no storage[^\n]*\n\s*\$selectedRosterHydrated\.set\(true\)/)
-})
-
-// ── first selection + reconciliation ────────────────────────────────────────
-
-test('the first selection picks a reachable visible bot and creates nothing', () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$rosterHydrated.set(true)
-  t.$selectedRosterHydrated.set(true)
-
-  const sources = [{ connectionId: 'local', kind: 'local', label: 'This device', reachable: true }]
-  const roster = [{ connectionId: 'local', name: 'writer' }, { connectionId: 'local', name: 'coder' }]
-
-  t.reconcileRosterSelection(roster, sources, {})
-
-  assert.equal(t.$selectedRosterKey.get(), 'local::writer')
-  assert.equal(t.$openBotChat.get(), null, 'selection is not an open')
-  assertNothingRouted(t, 'seating the first selection')
-})
-
-test('an unreachable bot is never auto-selected', () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$rosterHydrated.set(true)
-  t.$selectedRosterHydrated.set(true)
-
-  const sources = [
-    { connectionId: 'work-vps', kind: 'remote', label: 'Work', reachable: false },
-    { connectionId: 'local', kind: 'local', label: 'This device', reachable: true }
-  ]
-  const roster = [
-    { connectionId: 'work-vps', name: 'researcher', remoteSource: true, sourceScoped: true },
-    { connectionId: 'local', name: 'writer' }
-  ]
-
-  t.reconcileRosterSelection(roster, sources, {})
-
-  assert.equal(t.$selectedRosterKey.get(), 'local::writer')
-})
-
-test('nothing is selected before the roster has answered', () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$rosterHydrated.set(false)
-  t.$selectedRosterHydrated.set(true)
-
-  t.reconcileRosterSelection([{ connectionId: 'local', name: 'writer' }], [], {})
-
-  assert.equal(t.$selectedRosterKey.get(), '', 'a pending roster must not seat a selection it may have to revoke')
-})
-
-test('a hidden bot is not auto-selected', () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$rosterHydrated.set(true)
-  t.$selectedRosterHydrated.set(true)
-
-  const sources = [{ connectionId: 'local', kind: 'local', label: 'This device', reachable: true }]
-  const roster = [{ connectionId: 'local', name: 'hidden-one' }, { connectionId: 'local', name: 'writer' }]
-
-  t.reconcileRosterSelection(roster, sources, { 'hidden-one': { hidden: true } })
-
-  assert.equal(
-    t.$selectedRosterKey.get(),
-    'local::writer',
-    'the home must not open onto a bot the user removed from the roster'
-  )
-})
-
-// ── offline owner survives; deleted owner does not ──────────────────────────
-
-test('an offline gateway keeps the selection and its identity (relaunch case)', () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$rosterHydrated.set(true)
-  t.$selectedRosterHydrated.set(true)
-  t.$selectedRosterKey.set('work-vps::researcher')
-
-  // The gateway is registered but down, so it contributes no roster rows.
-  const sources = [
-    { connectionId: 'work-vps', kind: 'remote', label: 'Work', reachable: false, error: 'ECONNREFUSED' },
-    { connectionId: 'local', kind: 'local', label: 'This device', reachable: true }
-  ]
-  const roster = [{ connectionId: 'local', name: 'writer' }]
-
-  t.reconcileRosterSelection(roster, sources, {})
-
-  assert.equal(
-    t.$selectedRosterKey.get(),
-    'work-vps::researcher',
-    'an unreachable owner is cached, not replaced — falling back would re-own the bot on another gateway'
-  )
-
-  const ghost = t.ghostRosterOwner('work-vps::researcher', sources)
-  assert.equal(ghost.name, 'researcher')
-  assert.equal(ghost.connectionId, 'work-vps')
-  assert.equal(ghost.connectionLabel, 'Work')
-  assert.equal(ghost.remoteSource, true)
-  assert.equal(ghost.sourceReachable, false)
-  assertNothingRouted(t, 'rendering an offline owner')
-})
-
-test('cold-start outage keeps the selected owner in the visible roster without caching every bot', () => {
-  const t = load()
-  const sources = [
-    { connectionId: 'work-vps', kind: 'remote', label: 'Work', reachable: false, error: 'ECONNREFUSED' },
-    { connectionId: 'local', kind: 'local', label: 'This device', reachable: true }
-  ]
-  const localOnly = [{ connectionId: 'local', name: 'writer' }]
-
-  const restored = t.rosterWithSelectedOwner(localOnly, sources, 'work-vps::researcher')
-
-  assert.equal(restored.length, 2, 'only the exact selected owner is restored, not an invented remote roster')
-  assert.equal(t.botRosterKey(restored[1]), 'work-vps::researcher')
-  assert.equal(restored[1].connectionLabel, 'Work')
-  assert.equal(restored[1].sourceReachable, false)
-  assert.equal(t.rosterWithSelectedOwner(restored, sources, 'work-vps::researcher').length, 2, 'never duplicated')
-})
-
-test('a reachable source never receives a ghost row for a deleted bot', () => {
-  const t = load()
-  const roster = [{ connectionId: 'local', name: 'writer' }]
-  const sources = [
-    { connectionId: 'work-vps', kind: 'remote', label: 'Work', reachable: true },
-    { connectionId: 'local', kind: 'local', label: 'This device', reachable: true }
-  ]
-
-  assert.equal(t.rosterWithSelectedOwner(roster, sources, 'work-vps::deleted').length, 1)
-})
-
-test('a reachable source that no longer lists the bot clears the selection', () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$rosterHydrated.set(true)
-  t.$selectedRosterHydrated.set(true)
-  t.$selectedRosterKey.set('local::deleted-bot')
-
-  const sources = [{ connectionId: 'local', kind: 'local', label: 'This device', reachable: true }]
-  const roster = [{ connectionId: 'local', name: 'writer' }]
-
-  assert.equal(t.ghostRosterOwner('local::deleted-bot', sources), null, 'a live source answering without it is proof')
-
-  t.reconcileRosterSelection(roster, sources, {})
-
-  assert.equal(t.$selectedRosterKey.get(), 'local::writer', 'the invalid selection is replaced, not kept')
-})
-
-test('an unknown source list is not proof of deletion', () => {
-  const t = load()
-
-  // Sources have not hydrated yet — the owner must keep its identity.
-  assert.ok(t.ghostRosterOwner('work-vps::researcher', []))
-  assert.equal(t.ghostRosterOwner('work-vps::researcher', [{ connectionId: 'local', reachable: true }]), null)
-})
-
-// ── explicit open: every reachable owner routes exactly ────────────────────
-
-test('opening a remote bot selects and opens its exact owner chat', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-
-  const bot = {
-    connectionId: 'work-vps',
-    connectionLabel: 'Work',
-    name: 'researcher',
-    remoteSource: true,
-    sourceScoped: true
-  }
-
-  const result = await t.openRosterBot(bot)
-
-  assert.equal(result, true)
-  assert.equal(t.$selectedRosterKey.get(), 'work-vps::researcher')
-  const openBotChat = t.$openBotChat.get()
-  assert.equal(openBotChat?.key, 'work-vps::researcher')
-  assert.equal(openBotChat?.openedRegistryId, 'chat-work-vps-researcher')
-  assert.equal(t.sessionOpens.length, 1)
-  assert.equal(t.sessionOpens[0].options.workspaceMode, 'bots')
-  assert.equal(t.sessionOpens[0].options.workspaceOwnerKey, 'bot:work-vps::researcher')
-  assert.equal(t.sessionOpens[0].options.tabTitle, 'Bot Chat')
-  assert.equal(t.sessionOpens[0].options.keepAllProfilesScope, true)
-  assert.equal(t.sessionOpens[0].options.route.connectionId, 'work-vps')
-  assert.ok(t.requests.every(request => request.route?.connectionId === 'work-vps'))
-})
-
-test('a remote owner opens its chat without closing an unrelated group tab', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.openGroupChat('Launch room')
-  const groupEntry = t.opened.find(entry => entry.id === 'hermes-bots:group:launch-room')
-
-  const result = await t.openRosterBot({
-    connectionId: 'work-vps',
-    connectionLabel: 'Work',
-    name: 'researcher',
-    remoteSource: true
-  })
-
-  assert.equal(result, true)
-  assert.equal(t.botsHomeVisible(), false)
-  assert.equal(t.$groupChatWorkspace.get(), null)
-  assert.equal(groupEntry.disposed, false, 'explicit selection must not close an unrelated group tab')
-  assert.equal(t.sessionOpens.length, 1)
-})
-
-test('a remote owner does not depend on the informational home surface', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.openGroupChat('Launch room')
-  const groupEntry = t.opened.find(entry => entry.id === 'hermes-bots:group:launch-room')
-  t.host.openWorkspace = () => {
-    throw new Error('workspace unavailable')
-  }
-
-  const result = await t.openRosterBot({
-    connectionId: 'work-vps',
-    connectionLabel: 'Work',
-    name: 'researcher',
-    remoteSource: true
-  })
-
-  assert.equal(result, true)
-  assert.equal(t.$groupChatWorkspace.get(), null)
-  assert.equal(groupEntry.disposed, false)
-  assert.equal(t.sessionOpens.length, 1)
-})
-
-test('a failed local open leaves no phantom owner in the center', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.$openBotChat.set({ key: 'local::writer', openedRegistryId: 'previous' })
-
-  // A source-scoped row on a desktop that cannot address it: prepareBotSource
-  // refuses rather than letting the open fall through to the live gateway.
-  delete t.host.requestProfile
-  const bot = { connectionId: 'work-vps', name: 'writer', sourceScoped: true }
-
-  const result = await t.openRosterBot(bot)
-
-  assert.equal(result, false)
-  assert.equal(t.$openBotChat.get(), null, 'a failed open must release the center back to the home')
-  assert.equal(t.notifications.at(-1).kind, 'error', 'and the failure is surfaced, not swallowed')
-  assertNothingRouted(t, 'a refused local open')
-})
-
-test('an older gateway gets an actionable Bot Mode update message', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.host.requestProfile = async () => {
-    throw new Error('Unknown method profiles.list')
-  }
-
-  const result = await t.openRosterBot({
-    connectionId: 'work-vps',
-    connectionLabel: 'Work',
-    name: 'writer',
-    sourceScoped: true
-  })
-
-  assert.equal(result, false)
-  assert.equal(t.notifications.at(-1).title, 'Update this gateway to use Bot Mode')
-  assert.equal(t.notifications.at(-1).message, 'Update Work, then try again.')
-})
-
-test('a missing profile-scoped draft API returns to the home without navigating', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.host.request = async method => {
-    if (method === 'session.list') return { sessions: [] }
-    if (method === 'session.create') return {}
-    return {}
-  }
-
-  const result = await t.openRosterBot({ connectionId: 'local', name: 'writer' })
-
-  assert.equal(result, false)
-  assert.equal(t.$openBotChat.get(), null, 'no draft was opened without the owner-scoped API')
-  assert.ok(t.botsHomeVisible(), 'the owner home remains the visible recovery surface')
-})
-
-test('a local bot chat retires the prior group tab before taking the center', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.$groupChats.set({ 'Launch room': { roomId: 'r-launch', log: [], watermarks: {}, sessions: {} } })
-  t.host.openSession = async () => undefined
-  t.host.request = async method => {
-    if (method === 'session.list') {
-      return { sessions: [{ id: 'bot-chat', title: 'Bot Chat', message_count: 4 }] }
-    }
-
-    return {}
-  }
-
-  t.openGroupChat('Launch room')
-  const groupEntry = t.opened.find(entry => entry.id === 'hermes-bots:group:launch-room')
-  assert.ok(groupEntry)
-  assert.equal(t.$groupChatWorkspace.get(), 'Launch room')
-
-  const result = await t.openRosterBot({ connectionId: 'local', name: 'writer' })
-
-  assert.equal(result, true)
-  assert.equal(t.$groupChatWorkspace.get(), null)
-  assert.equal(groupEntry.disposed, true, 'the local bot chat must release the group workspace owner')
-  assert.equal(t.$openBotChat.get()?.key, 'local::writer')
-  assert.equal(t.$openBotChat.get()?.openedRegistryId, 'bot-chat')
-})
-
-test('a failed canonical-chat open preserves the visible group owner', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.$groupChats.set({ 'Launch room': { roomId: 'r-launch', log: [], watermarks: {}, sessions: {} } })
-  t.host.openSession = async () => {
-    throw new Error('gateway unavailable')
-  }
-  t.host.request = async method => {
-    if (method === 'session.list') {
-      return { sessions: [{ id: 'bot-chat', title: 'Bot Chat', message_count: 4 }] }
-    }
-
-    return {}
-  }
-
-  t.openGroupChat('Launch room')
-  const groupEntry = t.opened.find(entry => entry.id === 'hermes-bots:group:launch-room')
-  const result = await t.openRosterBot({ connectionId: 'local', name: 'writer' })
-
-  assert.equal(result, false)
-  assert.equal(t.$groupChatWorkspace.get(), 'Launch room')
-  assert.equal(groupEntry.disposed, true, 'the stale group tab was retired before the attempted open')
-  const restoredGroup = t.opened.filter(entry => entry.id === 'hermes-bots:group:launch-room').at(-1)
-  assert.notEqual(restoredGroup, groupEntry)
-  assert.equal(restoredGroup.disposed, false, 'a failed transition re-registers the group tab')
-  assert.equal(t.$openBotChat.get(), null)
-  assert.equal(t.notifications.at(-1).kind, 'error')
-})
-
-test('a failed remote canonical open re-fronts the preserved group tab', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.$groupChats.set({ 'Launch room': { roomId: 'r-launch', log: [], watermarks: {}, sessions: {} } })
-  t.openGroupChat('Launch room')
-  const groupEntry = t.opened.find(entry => entry.id === 'hermes-bots:group:launch-room')
-  t.host.openSession = async () => {
-    throw new Error('hydration failed after fronting Bot Chat')
-  }
-
-  const result = await t.openRosterBot({
-    connectionId: 'work-vps',
-    connectionLabel: 'Work',
-    name: 'researcher',
-    remoteSource: true
-  })
-
-  assert.equal(result, false)
-  assert.equal(groupEntry.disposed, false, 'remote open preserves the original tab')
-  assert.equal(t.$groupChatWorkspace.get(), 'Launch room')
-  assert.equal(
-    t.opened.filter(entry => entry.id === 'hermes-bots:group:launch-room').length,
-    2,
-    're-opening the same workspace id re-fronts the preserved group tab'
-  )
-})
-
-test('a failed remote open cannot restore a group disbanded while the tab was preserved', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.$groupChats.set({ 'Launch room': { roomId: 'r-launch', log: [], watermarks: {}, sessions: {} } })
-  t.openGroupChat('Launch room')
-
-  let rejectOpen
-  let markOpenStarted
-  const openStarted = new Promise(resolve => {
-    markOpenStarted = resolve
-  })
-  t.host.openSession = () =>
-    new Promise((resolve, reject) => {
-      rejectOpen = reject
-      markOpenStarted()
-    })
-
-  const opening = t.openRosterBot({
-    connectionId: 'work-vps',
-    connectionLabel: 'Work',
-    name: 'researcher',
-    remoteSource: true
-  })
-  await openStarted
-
-  t.$groupChats.set({ 'Launch room': { roomId: 'r-launch', tombstone: true } })
-  t.closeGroupChatMainTab('Launch room')
-  rejectOpen(new Error('gateway unavailable'))
-
-  assert.equal(await opening, false)
-  assert.equal(t.$groupChatWorkspace.get(), null)
-  assert.equal(t.$openBotChat.get(), null)
-})
-
-test('a failed local open cannot re-register a group tombstoned after retirement', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.$groupChats.set({ 'Launch room': { roomId: 'r-launch', log: [], watermarks: {}, sessions: {} } })
-  t.host.request = async method => {
-    if (method === 'session.list') {
-      return { sessions: [{ id: 'bot-chat', title: 'Bot Chat', message_count: 4 }] }
-    }
-
-    return {}
-  }
-
-  let rejectOpen
-  let markOpenStarted
-  const openStarted = new Promise(resolve => {
-    markOpenStarted = resolve
-  })
-  t.host.openSession = () =>
-    new Promise((resolve, reject) => {
-      rejectOpen = reject
-      markOpenStarted()
-    })
-
-  t.openGroupChat('Launch room')
-  const opening = t.openRosterBot({ connectionId: 'local', name: 'writer' })
-  await openStarted
-
-  t.$groupChats.set({ 'Launch room': { roomId: 'r-launch', tombstone: true } })
-  rejectOpen(new Error('gateway unavailable'))
-
-  assert.equal(await opening, false)
-  assert.equal(t.$groupChatWorkspace.get(), null)
-  assert.equal(t.opened.filter(entry => entry.id === 'hermes-bots:group:launch-room').length, 1)
-  assert.equal(t.$openBotChat.get(), null)
-})
-
-test('switching bots does not let the home cover the current chat while the next chat opens', async () => {
-  const t = load({ focusedStoredSessionId: 'chat-alpha' })
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  t.$openBotChat.set({
-    key: 'local::alpha',
-    openedRegistryId: 'chat-alpha',
-    openedSessionId: 'chat-alpha'
-  })
-  t.host.request = async method => {
-    if (method === 'session.list') {
-      return { sessions: [{ id: 'chat-beta', title: 'Bot Chat', message_count: 4 }] }
-    }
-
-    return {}
-  }
-
-  let finishOpen
-  let markOpenStarted
-  const openStarted = new Promise(resolve => {
-    markOpenStarted = resolve
-  })
-  t.host.openSession = () =>
-    new Promise(resolve => {
-      finishOpen = resolve
-      markOpenStarted()
-    })
-
-  const opening = t.openRosterBot({ connectionId: 'local', name: 'beta' })
-  await openStarted
-
-  // The destination focus edge releases the old chat claim before the async
-  // open has returned its replacement claim. Passive workspace reconciliation
-  // must not use that handoff gap to put Bots home in front.
-  t.focused.set(null)
-  t.releaseStaleOpenBotChat(null)
-  t.syncBotsHomeWorkspace()
-
-  assert.equal(t.opened.some(entry => entry.id === 'hermes-bots:home'), false)
-
-  finishOpen()
-  assert.equal(await opening, true)
-  assert.equal(t.$openBotChat.get()?.openedRegistryId, 'chat-beta')
-})
-
-test('choosing a group prevents a stale canonical-chat open from closing it later', async () => {
-  const t = load()
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-
-  let finishOpen
-  let markOpenStarted
-  const openStarted = new Promise(resolve => {
-    markOpenStarted = resolve
-  })
-  t.host.openSession = () =>
-    new Promise(resolve => {
-      finishOpen = resolve
-      markOpenStarted()
-    })
-  t.host.request = async method => {
-    if (method === 'session.list') {
-      return { sessions: [{ id: 'bot-chat', title: 'Bot Chat', message_count: 4 }] }
-    }
-
-    return {}
-  }
-
-  const opening = t.openRosterBot({ connectionId: 'local', name: 'writer' })
-  await openStarted
-  t.openGroupChat('Launch room')
-  const groupEntry = t.opened.find(entry => entry.id === 'hermes-bots:group:launch-room')
-
-  finishOpen()
-  assert.equal(await opening, false)
-  assert.equal(t.$groupChatWorkspace.get(), 'Launch room')
-  assert.equal(groupEntry.disposed, false)
-  assert.equal(t.$openBotChat.get(), null)
-})
-
-// ── who owns the main workspace ─────────────────────────────────────────────
-
-test('ownership table: exactly one surface owns the center', () => {
-  const t = load()
-
-  // Bot Mode not on screen: neither surface exists.
-  t.$botsPaneVisible.set(false)
-  assert.equal(t.botsHomeMayOpen(false), false)
-  assert.equal(t.botChatOwnsWorkspace(), false)
-
-  // Bots visible, nothing else: the home owns it, Cronjobs stay away.
-  t.$botsPaneVisible.set(true)
-  assert.equal(t.botsHomeMayOpen(false), true)
-  assert.equal(t.botChatOwnsWorkspace(), false, 'no bot chat owns the center, so bot-scoped Cronjobs must not seat')
-
-  // A group chat owns it: neither the home nor Cronjobs.
-  t.$groupChatWorkspace.set('Core')
-  assert.equal(t.botsHomeMayOpen(false), false)
-  assert.equal(t.botsHomeMayOpen(true), false, 'even an explicit gesture cannot cover a group chat')
-  assert.equal(t.botChatOwnsWorkspace(), false)
-  t.$groupChatWorkspace.set(null)
-
-  // A bot chat owns it: the home yields and Cronjobs seat.
-  t.$openBotChat.set({ key: 'local::writer', openedRegistryId: 'chat-1' })
-  assert.equal(t.botsHomeMayOpen(false), false)
-  assert.equal(t.botChatOwnsWorkspace(), true)
-  t.$openBotChat.set(null)
-
-  // A focused session (restored at boot, or Sessions mode) vetoes PASSIVE
-  // opens but not an explicit gesture at the home.
-  t.focused.set('chat-9')
-  assert.equal(t.sessionOwnsWorkspace(), true)
-  assert.equal(t.botsHomeMayOpen(false), false)
-  assert.equal(t.botsHomeMayOpen(true), true)
-  assert.equal(t.botChatOwnsWorkspace(), true)
-})
-
-test('with the home tab fronted, the hidden chat does not seat Cronjobs', () => {
-  const t = load()
-  t.$botsPaneVisible.set(true)
-
-  // Explicitly front the home over a focused chat.
-  t.focused.set('chat-1')
-  t.openBotsHomeWorkspace(true)
-  assert.equal(t.botsHomeVisible(), true)
-  assert.equal(
-    t.botChatOwnsWorkspace(),
-    false,
-    'the chat is a hidden sibling layer while the home holds the tab slot'
-  )
-
-  // The user fronts the chat tab again (no focus change fires): the pane
-  // visibility flip alone must reseat Cronjobs.
-  t.closeBotsHomeWorkspace()
-  assert.equal(t.botsHomeVisible(), false)
-  assert.equal(t.botChatOwnsWorkspace(), true)
-})
-
-test('a persisted layout that restored the home behind the draft gets re-fronted', () => {
-  const t = load()
-  t.$botsPaneVisible.set(true)
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 1)
-
-  // The tree restored the tab BEHIND the core draft pane (adoption kept the
-  // persisted active slot): the ownerless composer would sit on top.
-  t.paneVisible.set('plugin-workspace:hermes-bots:home', false)
-
-  t.syncBotsHomeWorkspace()
-
-  assert.equal(t.opened.length, 2, 're-opened to reclaim the active slot')
-  assert.equal(t.closed.length, 1, 'the stale registration was closed first — never two live disposers')
-  assert.equal(t.botsHomeVisible(), true)
-})
-
-test('an explicit remote selection opens its owner tab without moving the focused Sessions chat', async () => {
-  const t = load({ focusedStoredSessionId: 'local-scout-chat' })
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-
-  // Passive sync must not cover the chat…
-  t.syncBotsHomeWorkspace()
-  assert.deepEqual(t.opened, [])
-
-  // …but clicking the same-named twin on another gateway opens that owner in
-  // Bot Mode while the Sessions chat stays alive underneath.
-  await t.openRosterBot({ connectionId: 'work-vps', connectionLabel: 'Work', name: 'scout', remoteSource: true })
-
-  assert.equal(t.opened.length, 0)
-  assert.equal(t.sessionOpens.length, 1)
-  assert.equal(t.$selectedRosterKey.get(), 'work-vps::scout')
-  assert.equal(t.$openBotChat.get().key, 'work-vps::scout')
-  assert.equal(t.focused.get(), 'local-scout-chat')
-
-  // Browsing more remote owners opens that owner without reusing the first.
-  await t.openRosterBot({ connectionId: 'work-vps', connectionLabel: 'Work', name: 'relay', remoteSource: true })
-  assert.equal(t.sessionOpens.length, 2)
-  assert.equal(t.$selectedRosterKey.get(), 'work-vps::relay')
-})
-
-test('an explicit Bots-home gesture fronts the selected owner over a Sessions composer', () => {
-  const t = load({ focusedStoredSessionId: 'sessions-chat' })
-  t.$botsPaneVisible.set(true)
-
-  t.syncBotsHomeWorkspace()
-  assert.deepEqual(t.opened, [], 'passive polling still leaves a focused session alone')
-
-  t.openBotsHomeWorkspace(true)
-  assert.equal(t.opened.length, 1, 'the explicit gesture has an exact owner instead of the Sessions composer')
-  assert.equal(t.opened[0].id, 'hermes-bots:home')
-})
-
-test('source contract: sidebar entry and boot restore reconcile passively after layout hydration', () => {
-  assert.match(pluginSource, /const syncWorkspaceSurfaces = \(\) =>/)
-  assert.match(pluginSource, /stopSidebarSync = \$sidebarVisible\.listen\(visible => \{[\s\S]{0,1500}?syncWorkspaceSurfaces\(\)/)
-  assert.doesNotMatch(pluginSource, /stopSidebarSync = \$sidebarVisible\.listen\(visible => \{[\s\S]{0,1500}?syncWorkspaceSurfaces\(Boolean\(visible\)\)/)
-  assert.match(
-    pluginSource,
-    /\$botChatFocused\.set\(sessionOwnsWorkspace\(\)\)[\s\S]{0,500}?syncWorkspaceSurfaces\(\)[\s\S]{0,120}?scheduleSurfaceSync\(\)/
-  )
-  assert.match(
-    pluginSource,
-    /homeVisibleStore\.listen\(visible => \{[\s\S]{0,260}?\$botsHomeFronted\.set\(Boolean\(visible\)\)[\s\S]{0,120}?scheduleSurfaceSync\(\)/
-  )
-})
-
-test('an opened chat releases the center once focus leaves it', () => {
-  const t = load()
-  t.$openBotChat.set({ key: 'local::writer', openedRegistryId: 'chat-1' })
-
-  t.releaseStaleOpenBotChat('chat-1')
-  assert.deepEqual(t.$openBotChat.get(), { key: 'local::writer', openedRegistryId: 'chat-1' }, 'still the focused chat')
-
-  t.releaseStaleOpenBotChat('chat-2')
-  assert.equal(t.$openBotChat.get(), null, 'another session took the center')
-
-  t.$openBotChat.set({ key: 'local::writer', openedRegistryId: 'chat-1' })
-  t.releaseStaleOpenBotChat(null)
-  assert.equal(t.$openBotChat.get(), null, 'the chat was closed — the home may come back')
-})
-
-test('a legacy draft keeps the center until a real session takes focus', () => {
-  const t = load()
-
-  // The newChat fallback has no stored id to compare against.
-  t.$openBotChat.set({ key: 'local::writer', openedRegistryId: '' })
-
-  t.releaseStaleOpenBotChat(null)
-  assert.deepEqual(t.$openBotChat.get(), { key: 'local::writer', openedRegistryId: '' }, 'an unsent draft is still that bot’s')
-
-  t.releaseStaleOpenBotChat('chat-7')
-  assert.equal(t.$openBotChat.get(), null)
-})
-
-// ── the home tab itself ─────────────────────────────────────────────────────
-
-test('the home opens once and is not re-fronted while it already owns the center', () => {
-  const t = load()
-  t.$botsPaneVisible.set(true)
-
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 1)
-  assert.equal(t.opened[0].id, 'hermes-bots:home')
-  assert.equal(t.opened[0].options.title, 'Bots')
-
-  // Repeated signals (focus churn, roster polls) must not steal focus back
-  // or mint a second disposer whose stale predecessor could tear down the
-  // newer registration.
-  t.syncBotsHomeWorkspace()
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 1)
-  assert.deepEqual(t.closed, [])
-})
-
-test('the home yields the center to a chat and returns when the chat closes', () => {
-  const t = load()
-  t.$botsPaneVisible.set(true)
-
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 1)
-
-  t.$openBotChat.set({ key: 'local::writer', openedRegistryId: 'chat-1' })
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.closed.length, 1, 'the home closed for the chat')
-
-  t.$openBotChat.set(null)
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 2, 'and comes back when nothing else owns the center')
-})
-
-test('a restored session at boot keeps the home from covering it', () => {
-  const t = load({ focusedStoredSessionId: 'restored-chat' })
-  t.$botsPaneVisible.set(true)
-
-  t.syncBotsHomeWorkspace()
-
-  assert.deepEqual(t.opened, [], 'the home must not steal the tab from a session the user left open')
-})
-
-test('closing the home tab does not resurrect it mid-close', () => {
-  const t = load()
-  t.$botsPaneVisible.set(true)
-  t.syncBotsHomeWorkspace()
-
-  // The tab's own ✕ routes through the same disposer.
-  t.opened[0].options.onClose()
-
-  assert.equal(t.opened.length, 1, 'onClose must not re-open the tab the user just closed')
-
-  // It comes back only when something else actually happens.
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 2)
-})
-
-test('the home never yanks the center back from a sibling tab the user chose', () => {
-  const t = load()
-  t.$botsPaneVisible.set(true)
-  t.syncBotsHomeWorkspace()
-  assert.equal(t.opened.length, 1)
-
-  // The user tabs to the ordinary draft workspace: no session owns the
-  // center, so the home still "should" own it — but it is already open, and
-  // re-opening would front it over the tab the user just picked.
-  t.focused.set(null)
-  t.syncBotsHomeWorkspace()
-  t.syncBotsHomeWorkspace()
-
-  assert.equal(t.opened.length, 1, 'focus churn must not re-front the home')
-  assert.deepEqual(t.closed, [])
-})
-
-test('older shells without owner routing fail with an update path', async () => {
-  const t = load({ openWorkspace: false, paneVisibility: false })
-  t.setPluginCtx({ storage: { set: () => undefined } })
-  t.$botsPaneVisible.set(true)
-  delete t.host.requestProfile
-  delete t.host.openSession
-
-  t.syncBotsHomeWorkspace()
-  assert.deepEqual(t.opened, [])
-
-  // A remote row cannot guess through the active gateway on an old shell.
-  await t.openRosterBot({
-    connectionId: 'work-vps',
-    connectionLabel: 'Work',
-    name: 'researcher',
-    remoteSource: true,
-    sourceScoped: true
-  })
-
-  assert.equal(t.notifications.length, 1)
-  assert.match(t.notifications[0].message, /Could not reach Work/)
-  assert.match(String(t.notifications[0].error), /Update Hermes Desktop/)
-  assertNothingRouted(t, 'remote row on an older shell')
-})
-
-// ── view contracts ──────────────────────────────────────────────────────────
-
-test('the home Tip wraps exactly one element (Radix asChild)', () => {
-  const start = pluginSource.indexOf('function BotsHomeView(')
-  assert.ok(start >= 0)
-  const view = pluginSource.slice(start, pluginSource.indexOf('function closeBotsHomeWorkspace('))
-
-  assert.match(view, /jsx\(Tip, \{\s*\n\s*label:[^\n]*\n\s*children: jsxs\('div'/, 'one child element, not an array')
-  assert.doesNotMatch(view, /jsxs\(Tip, \{/, 'jsxs would pass multiple children and break the trigger')
-  // The screen-reader text rides INSIDE the trigger element.
-  assert.match(view, /className: 'sr-only'/)
-})
-
-test('the home shows a loading state rather than flashing “No bots”', () => {
-  const start = pluginSource.indexOf('function BotsHomeView(')
-  const view = pluginSource.slice(start, pluginSource.indexOf('function closeBotsHomeWorkspace('))
-
-  assert.match(view, /if \(!rosterHydrated \|\| !selectionHydrated\) \{[\s\S]{0,220}?GlyphSpinner/)
-  const spinnerAt = view.indexOf('GlyphSpinner')
-  const emptyAt = view.indexOf("title: roster.length ? 'Choose a bot or group chat' : 'No bots yet'")
-  assert.ok(spinnerAt >= 0 && emptyAt > spinnerAt, 'the empty state is only reachable after both hydrations')
-})
-
-test('the home uses the neutral workspace surface instead of a transient blue tint', () => {
-  const start = pluginSource.indexOf('function BotsHomeView(')
-  const view = pluginSource.slice(start, pluginSource.indexOf('function closeBotsHomeWorkspace('))
-
-  assert.match(view, /className: 'flex h-full min-h-0 flex-col bg-background'/)
-  assert.doesNotMatch(view, /bg-\(--ui-bg-primary\)/)
-})
-
-test('roster hydration and selection reconciliation run after render', () => {
-  const start = pluginSource.indexOf('function BotsPane(')
-  const pane = pluginSource.slice(start, pluginSource.indexOf('// ── registration'))
-
-  assert.match(
-    pane,
-    /useEffect\(\(\) => \{[\s\S]{0,500}?\$rosterHydrated\.set\(true\)[\s\S]{0,300}?reconcileRosterSelection\(roster, sourceSnapshot, allMeta\)[\s\S]{0,700}?\}, \[data, error, selectionHydrated, roster, sourceSnapshot, allMeta\]\)/,
-    'persisted roster ownership must reconcile from an effect, never from a replayable render'
-  )
-  assert.equal(
-    (pane.match(/reconcileRosterSelection\(roster, sourceSnapshot, allMeta\)/g) || []).length,
-    1,
-    'BotsPane has one effect-bound reconciliation path'
-  )
-  assert.match(
-    pane,
-    /sourceWithSelectedOwner = selectionHydrated && rosterHydrated[\s\S]{0,180}?rosterWithSelectedOwner/,
-    'an unavailable-owner placeholder cannot bypass initial roster hydration'
-  )
-  assert.match(
-    pane,
-    /\$lastRoster\.set\(roster\.filter\(row => !row\?\.ghost\)\)/,
-    'presentation-only owner placeholders never enter shared roster state'
-  )
-})
-
-test('an unavailable owner offers retry instead of a dead Open chat button', () => {
-  const start = pluginSource.indexOf('function BotsHomeView(')
-  const view = pluginSource.slice(start, pluginSource.indexOf('function closeBotsHomeWorkspace('))
-
-  assert.match(view, /unavailable && !sourceRemoved\s*\n\s*\? jsx\(Button, \{[\s\S]{0,200}?children: 'Retry'/)
-  // Retry re-polls the roster; it must not activate or route anything.
-  assert.match(view, /queryClient\.invalidateQueries\(\{ queryKey: ROSTER_KEY \}\)/)
-  assert.doesNotMatch(view, /ensureAgent|requestProfile|newChat/)
-  assert.match(view, /\$\{gateway\} is unavailable\. Retry when it is back online\./)
-  assert.match(view, /\$\{gateway\} was removed\. Choose another bot from the sidebar\./)
-  assert.doesNotMatch(view, /This bot remains selected/)
-  assert.doesNotMatch(view, /its work keeps running on that gateway/)
-})
-
-test('an available remote owner offers the same direct chat action', () => {
-  const start = pluginSource.indexOf('function BotsHomeView(')
-  const view = pluginSource.slice(start, pluginSource.indexOf('function closeBotsHomeWorkspace('))
-
-  assert.match(view, /children: 'Open chat'/)
-  assert.match(view, /Open this bot’s continuous chat/)
-  assert.doesNotMatch(view, /Copy @/)
-  assert.doesNotMatch(view, /remoteCopy/)
-  assert.doesNotMatch(view, /Mention it from any Bot Chat/)
-})
-
-test('an unavailable owner never presents a guessed mention handle', () => {
-  const start = pluginSource.indexOf('function BotsHomeView(')
-  const view = pluginSource.slice(start, pluginSource.indexOf('function closeBotsHomeWorkspace('))
-
-  assert.match(view, /const handle = bot\.ghost \? '' : botHandle\(bot\.name, bot\)/)
-  assert.match(view, /handle\s*\n\s*\? jsx\('span'/)
-})
-
-test('Bot Mode copy says bot, not agent', () => {
-  assert.doesNotMatch(pluginSource, /Name the agent first/)
-  assert.doesNotMatch(pluginSource, /create agents first/)
-  assert.doesNotMatch(pluginSource, /children: busy \? 'Creating…' : 'Create Agent'/)
-  assert.doesNotMatch(pluginSource, /`Agent "\$\{displayName\(\{ name: slug, title \}\)\}" created/)
-  assert.match(pluginSource, /Name the bot first/)
-  assert.match(pluginSource, /children: busy \? 'Creating…' : 'Create Bot'/)
-  assert.match(pluginSource, /`Bot "\$\{displayName\(\{ name: slug, title \}\)\}" created/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/bots-search.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/bots-search.test.mjs
deleted file mode 100644
index b7269961f0f5..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/bots-search.test.mjs
+++ /dev/null
@@ -1,95 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadFilter() {
-  const start = source.indexOf('function botHandle')
-  const end = source.indexOf('function slugify')
-
-  assert.ok(start >= 0 && end > start, 'bot identity helper block must remain extractable')
-
-  const context = { botActivitySession: bot => bot?.canonical_session || bot?.last_session || null }
-  vm.runInNewContext(
-    `${source.slice(start, end)}\nglobalThis.__filterBots = filterBots;`,
-    context
-  )
-
-  return context.__filterBots
-}
-
-const roster = [
-  { name: 'agency-audio-designer', title: 'Audio Designer' },
-  { name: 'agency-ai-engineer', title: 'AI Engineer' },
-  { name: 'default' }
-]
-const meta = {
-  'agency-audio-designer': { title: 'Sound Studio' },
-  default: {}
-}
-
-test('bot search matches visible display names case-insensitively', () => {
-  const filterBots = loadFilter()
-
-  assert.deepEqual(
-    filterBots(roster, meta, 'SOUND').map(bot => bot.name),
-    ['agency-audio-designer']
-  )
-})
-
-test('bot search matches profile handles and preserves roster order', () => {
-  const filterBots = loadFilter()
-
-  assert.deepEqual(
-    filterBots(roster, meta, 'agency-').map(bot => bot.name),
-    ['agency-audio-designer', 'agency-ai-engineer']
-  )
-  assert.deepEqual(
-    filterBots(roster, meta, '@hermes').map(bot => bot.name),
-    ['default']
-  )
-  assert.deepEqual(
-    filterBots(roster, meta, 'default').map(bot => bot.name),
-    ['default']
-  )
-})
-
-test('bot search also matches roles, message previews, and gateway labels', () => {
-  const filterBots = loadFilter()
-  const richerRoster = [
-    {
-      name: 'reviewer',
-      connectionLabel: 'Work Studio',
-      description: 'Release quality and compliance',
-      last_session: { preview: 'Checked the deployment checklist' }
-    },
-    { name: 'writer', description: 'Editorial support' }
-  ]
-
-  assert.equal(filterBots(richerRoster, {}, 'compliance')[0].name, 'reviewer')
-  assert.equal(filterBots(richerRoster, {}, 'deployment checklist')[0].name, 'reviewer')
-  assert.equal(filterBots(richerRoster, {}, 'work studio')[0].name, 'reviewer')
-})
-
-test('blank bot search returns the existing roster reference', () => {
-  const filterBots = loadFilter()
-
-  assert.equal(filterBots(roster, meta, '   '), roster)
-})
-
-test('Bot pane renders the canonical search field and no-match state', () => {
-  assert.match(
-    source,
-    /const showRosterSearch =\s*gatewayOptions\.length > 1 \|\| rosterItemCount >= BOT_ROSTER_SEARCH_THRESHOLD/
-  )
-  assert.match(source, /jsx\(SearchField,\s*\{[\s\S]*?placeholder: 'Search bots and group chats…'/)
-  assert.match(source, /query \? 'opacity-100!' : 'opacity-50 focus-within:opacity-100'/)
-  assert.match(source, /placeholder:text-\(--ui-text-tertiary\)/)
-  assert.match(source, /children: jsx\(Codicon, \{ name: 'list-filter' \}\)/)
-  assert.match(source, /'aria-live': 'polite'/)
-  assert.match(source, /No bots or group chats match “\$\{query\.trim\(\)\}”/)
-  assert.match(source, /const initialRosterLoading = !data && !error && roster\.length === 0/)
-  assert.match(source, /\(isLoading \|\| initialRosterLoading\) && !roster\.length/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-adopt-on-conflict.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-adopt-on-conflict.test.mjs
deleted file mode 100644
index 94fa018afa9a..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-adopt-on-conflict.test.mjs
+++ /dev/null
@@ -1,87 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// ADOPT-BEFORE-MINT (#92473 part 2): between the registry miss and our eager
-// session.title write, another writer can take the canonical title (peer dm
-// minting server-side, a second machine, cross-connection sync). UNIQUE(title)
-// rejects our write with "already in use". Before this fix that rejection was
-// read as "old gateway" and the compat path prompted into OUR stray lazy
-// session — forking the forever chat. Now the mint re-consults the registry
-// and adopts the winner; the stray zero-message session is abandoned to the
-// gateway's pruner.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadCanonicalCreation({ openSession, request }) {
-  const start = source.indexOf('const canonicalCreations = new Map()')
-  const end = source.indexOf('function displayName(', start)
-  const context = {
-    host: { openSession, request },
-    backendTargetProfile: (route, name) => route?.targetProfile || name,
-    botOwner: name => (typeof name === 'string'
-      ? { bot: { name }, key: name, name, route: null }
-      : { bot: name, key: name?.name, name: name?.name, route: name?.route || null }),
-    requestForBot: (_bot, method, params) => context.host.request(method, params),
-    botWorkspaceOwnerKey: bot => String(bot?.name || bot || ''),
-    window: { setTimeout: callback => callback() }
-  }
-  const section = source
-    .slice(start, end)
-    .concat('\nglobalThis.__canonical = { createCanonicalChat };\n')
-
-  assert.notEqual(start, -1, 'canonical creation section is missing')
-  assert.notEqual(end, -1, 'canonical creation section delimiter is missing')
-  vm.runInNewContext(section, context, { filename: 'canonical-adopt.js' })
-  return { ...context.__canonical }
-}
-
-test('title-uniqueness rejection adopts the racing winner instead of forking', async () => {
-  const events = []
-  let lists = 0
-  const runtime = loadCanonicalCreation({
-    openSession: async id => events.push(`open:${id}`),
-    request: async method => {
-      events.push(method)
-      if (method === 'session.list') {
-        lists += 1
-        // First consult: registry miss (this is why we mint at all). Second
-        // consult (after the conflict): the racing winner exists.
-        if (lists === 1) return { sessions: [] }
-        return { sessions: [{ id: 'winner-1', resolved_id: 'winner-1', title: 'Bot Chat', message_count: 3 }] }
-      }
-      if (method === 'session.create') return { stored_session_id: 'stray-1', session_id: 'rt-stray' }
-      if (method === 'session.title') {
-        throw new Error("Title 'Bot Chat' is already in use by session winner-1")
-      }
-      return {}
-    }
-  })
-
-  assert.equal(await runtime.createCanonicalChat('ops'), 'winner-1')
-  // The winner is opened; the stray is never prompted into or opened.
-  assert.ok(events.includes('open:winner-1'), `winner opened (events: ${events})`)
-  assert.ok(!events.includes('prompt.submit'), 'no prompt into the stray session')
-  assert.ok(!events.includes('open:stray-1'), 'stray session never mounted')
-})
-
-test('a NON-conflict title failure still takes the compat path (old gateways)', async () => {
-  const events = []
-  const runtime = loadCanonicalCreation({
-    openSession: async id => events.push(`open:${id}`),
-    request: async (method) => {
-      events.push(method)
-      if (method === 'session.list') return { sessions: [] }
-      if (method === 'session.create') return { stored_session_id: 'stored-1', session_id: 'rt-1' }
-      if (method === 'session.title') throw new Error('unknown method')
-      return {}
-    }
-  })
-
-  assert.equal(await runtime.createCanonicalChat('ops'), 'stored-1')
-  // Old gateway: eager title unsupported → the kickoff persists the lazy row.
-  assert.ok(events.includes('prompt.submit'), 'compat kickoff persists the session')
-  // Only the initial registry consult — a plain failure must not re-list.
-  assert.equal(events.filter(e => e === 'session.list').length, 1)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-creation.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-creation.test.mjs
deleted file mode 100644
index bf3d251cb471..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-creation.test.mjs
+++ /dev/null
@@ -1,168 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadCanonicalCreation({ openSession, request }) {
-  const start = source.indexOf('const canonicalCreations = new Map()')
-  const end = source.indexOf('function displayName(', start)
-  const context = {
-    host: { openSession, request },
-    backendTargetProfile: (route, name) => route?.targetProfile || name,
-    botOwner: name => (typeof name === 'string'
-      ? { bot: { name }, key: name, name, route: null }
-      : { bot: name, key: name?.name, name: name?.name, route: name?.route || null }),
-    botWorkspaceOwnerKey: bot => `bot:local::${bot.name}`,
-    requestForBot: (_bot, method, params) => context.host.request(method, params),
-    window: { setTimeout: callback => callback() }
-  }
-  const section = source
-    .slice(start, end)
-    .concat('\nglobalThis.__canonical = { createCanonicalChat };\n')
-
-  assert.notEqual(start, -1, 'canonical creation section is missing')
-  assert.notEqual(end, -1, 'canonical creation section delimiter is missing')
-  vm.runInNewContext(section, context, { filename: 'canonical-creation.js' })
-  return { ...context.__canonical }
-}
-
-test('regression: creation materializes and titles the lazy row before opening it', async () => {
-  const events = []
-  const runtime = loadCanonicalCreation({
-    openSession: async id => events.push(`open:${id}`),
-    request: async (method, params) => {
-      events.push(method)
-      if (method === 'session.create') return { stored_session_id: 'stored-1', session_id: 'runtime-1' }
-      if (method === 'session.title') {
-        // vm-realm objects fail assert.deepEqual on prototype identity —
-        // compare via JSON.stringify (harness contract). A throw here is
-        // NOT inert: createCanonicalChat reads it as "eager title
-        // unsupported" and falls back to the compat kickoff.
-        assert.equal(JSON.stringify(params), JSON.stringify({ session_id: 'runtime-1', title: 'Bot Chat' }))
-      }
-      return {}
-    }
-  })
-
-  // No kickoff option: the click-path mint. The eager title write persists
-  // the row, so NO intro turn fires — the user speaks first (ScottFive).
-  assert.equal(await runtime.createCanonicalChat('ops'), 'stored-1')
-  assert.deepEqual(events, [
-    'session.list',
-    'session.create',
-    'session.title',
-    'open:stored-1'
-  ])
-})
-
-test('New Agent creation (kickoff: true) still sends the one intro turn', async () => {
-  const events = []
-  const runtime = loadCanonicalCreation({
-    openSession: async id => events.push(`open:${id}`),
-    request: async (method, params) => {
-      events.push(method)
-      if (method === 'session.create') return { stored_session_id: 'stored-1', session_id: 'runtime-1' }
-      if (method === 'prompt.submit') {
-        assert.equal(params.session_id, 'runtime-1')
-      }
-      return {}
-    }
-  })
-
-  assert.equal(await runtime.createCanonicalChat('ops', { kickoff: true }), 'stored-1')
-  assert.deepEqual(events, [
-    'session.list',
-    'session.create',
-    'session.title',
-    'open:stored-1',
-    'prompt.submit'
-  ])
-})
-
-test('compatibility: navigation retries after kickoff when eager title persistence is unavailable', async () => {
-  const events = []
-  let attempts = 0
-  const runtime = loadCanonicalCreation({
-    openSession: async id => {
-      events.push(`open:${id}`)
-      attempts += 1
-      if (attempts === 1) throw new Error('stored row not persisted yet')
-    },
-    request: async method => {
-      if (method === 'session.create') return { stored_session_id: 'stored-1', session_id: 'runtime-1' }
-      if (method === 'session.title') throw new Error('unknown method')
-      if (method === 'prompt.submit') events.push('kickoff:persisted')
-      return {}
-    }
-  })
-
-  assert.equal(await runtime.createCanonicalChat('ops'), 'stored-1')
-  assert.deepEqual(events, ['open:stored-1', 'kickoff:persisted', 'open:stored-1'])
-})
-
-test('regression: a failed intro still returns the created registry row', async () => {
-  const runtime = loadCanonicalCreation({
-    openSession: async () => undefined,
-    request: async method => {
-      if (method === 'session.create') return { stored_session_id: 'new-bot-chat', session_id: 'rt-1' }
-      if (method === 'prompt.submit') throw new Error('gateway timeout')
-      return {}
-    }
-  })
-
-  // The chat exists under the canonical title — the next click finds it by
-  // NAME (the registry), so a failed kickoff can never orphan or fork it.
-  assert.equal(await runtime.createCanonicalChat('newbie', { kickoff: true }), 'new-bot-chat')
-})
-
-test('a superseded roster open may create the canonical row but never navigate it', async () => {
-  const opens = []
-  let current = true
-  const runtime = loadCanonicalCreation({
-    openSession: async (id, options) => opens.push({ id, options }),
-    request: async method => {
-      if (method === 'session.create') {
-        current = false
-        return { stored_session_id: 'new-stored', session_id: 'new-runtime' }
-      }
-      return {}
-    }
-  })
-
-  assert.equal(await runtime.createCanonicalChat('ops', { openingStillCurrent: () => current }), 'new-stored')
-  assert.deepEqual(opens, [])
-})
-
-test('a newer same-bot open replaces the in-flight creation navigation guard', async () => {
-  const opens = []
-  let releaseCreate
-  let markCreateStarted
-  let firstCurrent = true
-  const createStarted = new Promise(resolve => {
-    markCreateStarted = resolve
-  })
-  const runtime = loadCanonicalCreation({
-    openSession: async (id, options) => opens.push({ id, options }),
-    request: async method => {
-      if (method === 'session.create') {
-        markCreateStarted()
-        return new Promise(resolve => {
-          releaseCreate = () => resolve({ stored_session_id: 'shared-stored', session_id: 'shared-runtime' })
-        })
-      }
-      return {}
-    }
-  })
-
-  const first = runtime.createCanonicalChat('ops', { openingStillCurrent: () => firstCurrent })
-  await createStarted
-  firstCurrent = false
-  const second = runtime.createCanonicalChat('ops', { openingStillCurrent: () => true })
-  releaseCreate()
-
-  assert.equal(await first, 'shared-stored')
-  assert.equal(await second, 'shared-stored')
-  assert.equal(opens.length, 1, 'the newer current click owns the shared creation navigation')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-registry.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-registry.test.mjs
deleted file mode 100644
index 3e013bbda198..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/canonical-chat-registry.test.mjs
+++ /dev/null
@@ -1,253 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// ── The canonical-chat REGISTRY contract ────────────────────────────────────
-//
-// A bot's forever-chat has exactly ONE identity: the session titled "Bot Chat"
-// on that bot's profile. The core UNIQUE(title) index makes (profile,
-// "Bot Chat") an exact registry — at most one row, resolved fresh on every
-// open via `session.list { title: 'Bot Chat', include_hidden: true }`.
-//
-// There is NO session-id pin. The previous design stored a pointer in
-// ui_meta['hermes-bots'].chat and spent five hardening waves (#88690, #90732,
-// #90751, #91791-revert, #92042) guarding its failure modes: rows[0] steals,
-// last_session adoptions, transient clears, drifted-title welds. Every "lost
-// canonical chat" incident traced to that pointer dangling and a later guard
-// then welding the wrong session in. Name-as-identity removes the failure
-// class instead of guarding it: a name cannot dangle.
-//
-// This suite pins the whole contract:
-//   1. open = registry lookup → open the row (lineage tip)
-//   2. no row → create (adopt-before-mint lives inside creation)
-//   3. no pointer is ever read or written on the open path
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadOpenPath({ openSession, request }) {
-  const start = source.indexOf('const canonicalCreations = new Map()')
-  const end = source.indexOf('function displayName(', start)
-  const requests = []
-  const opened = []
-  const context = {
-    host: {
-      openSession: async (id, options) => {
-        opened.push({ id, options })
-        return openSession ? openSession(id, options) : undefined
-      },
-      request: async (method, params) => {
-        requests.push({ method, params: JSON.parse(JSON.stringify(params ?? null)) })
-        return request(method, params)
-      }
-    },
-    // Owner-shape helpers (plugin scope): local bots carry no route, so the
-    // harness resolves everything onto the ambient host.request — the exact
-    // legacy single-connection behavior these tests pin.
-    botOwner: owner => (typeof owner === 'string'
-      ? { bot: { name: owner }, key: owner, name: owner, route: null }
-      : { bot: owner, key: owner?.name, name: owner?.name, route: owner?.route || null }),
-    backendTargetProfile: (route, name) => route?.targetProfile || name,
-    botWorkspaceOwnerKey: bot => `bot:${bot?.connectionId ? `${bot.connectionId}::` : ''}${bot?.name || 'default'}`,
-    requestForBot: (_bot, method, params) => context.host.request(method, params),
-    window: { setTimeout: callback => callback() }
-  }
-  const section = source
-    .slice(start, end)
-    .concat('\nglobalThis.__open = { createCanonicalChat, openBotCanonicalChat, findExistingCanonicalChat };\n')
-
-  assert.notEqual(start, -1, 'canonical section is missing')
-  assert.notEqual(end, -1, 'canonical section delimiter is missing')
-  vm.runInNewContext(section, context, { filename: 'canonical-registry.js' })
-  return { ...context.__open, requests, opened }
-}
-
-// ── 1. the registry row wins, always ────────────────────────────────────────
-
-test('open resolves the profile\u2019s "Bot Chat" row by exact title and opens it', async () => {
-  const runtime = loadOpenPath({
-    request: async method => {
-      if (method === 'session.list') {
-        return { sessions: [{ id: 'forever-chat', title: 'Bot Chat', message_count: 930 }] }
-      }
-      if (method === 'session.create') {
-        throw new Error('must not create: the registry row exists')
-      }
-      return {}
-    }
-  })
-
-  const opened = await runtime.openBotCanonicalChat('ops')
-  assert.equal(opened.registryId, 'forever-chat')
-  assert.equal(opened.openedId, 'forever-chat')
-  assert.equal(runtime.opened.length, 1)
-  assert.equal(runtime.opened[0].id, 'forever-chat')
-  assert.equal(runtime.opened[0].options.profile, 'ops')
-  assert.equal(runtime.opened[0].options.keepAllProfilesScope, true,
-    'opening a bot leaves the Sessions workspace on its current gateway')
-  assert.equal(runtime.opened[0].options.intent, 'tab')
-  assert.equal(runtime.opened[0].options.workspaceMode, 'bots')
-  assert.equal(runtime.opened[0].options.workspaceOwnerKey, 'bot:ops')
-  assert.equal(runtime.opened[0].options.tabTitle, 'Bot Chat')
-
-  const list = runtime.requests.find(r => r.method === 'session.list')
-  assert.equal(list?.params?.title, 'Bot Chat', 'lookup is by exact title')
-  assert.equal(list?.params?.profile, 'ops')
-  assert.equal(list?.params?.include_hidden, true,
-    'canonical chats are always hidden — the lookup must see hidden rows')
-})
-
-test('a compression-rotated registry row opens the lineage tip', async () => {
-  const runtime = loadOpenPath({
-    request: async method => {
-      if (method === 'session.list') {
-        return {
-          sessions: [{ id: 'root-1', resolved_id: 'tip-9', root_title: 'Bot Chat', title: 'Bot Chat', message_count: 400 }]
-        }
-      }
-      return {}
-    }
-  })
-
-  const opened = await runtime.openBotCanonicalChat('ops')
-  assert.equal(opened.registryId, 'root-1', 'the durable registry id is returned')
-  assert.equal(opened.openedId, 'tip-9', 'the lineage tip rides alongside for focus matching')
-  assert.equal(runtime.opened[0].id, 'tip-9', 'the live tip is what opens')
-})
-
-test('the open path never reads or writes a stored pointer', () => {
-  const start = source.indexOf('const canonicalCreations = new Map()')
-  const end = source.indexOf('function displayName(', start)
-  const section = source.slice(start, end)
-
-  assert.doesNotMatch(section, /saveBotMeta/, 'no pointer writes on the canonical path')
-  assert.doesNotMatch(section, /meta\??\.chat\b/, 'no pointer reads on the canonical path')
-  assert.doesNotMatch(section, /preferred_session_ids/, 'no id-verification RPC on the canonical path')
-})
-
-test('openBotCanonicalChat takes owner identity plus only an optional navigation-freshness guard', () => {
-  // The owner is the bot's name (local) or its roster row carrying the
-  // immutable connection route (remote). The optional callback controls only
-  // whether an async result may still navigate; it carries no identity.
-  assert.match(source, /async function openBotCanonicalChat\(owner, openingStillCurrent = null\) \{/)
-})
-
-// ── 2. no registry row → create ─────────────────────────────────────────────
-
-test('no registry row mints a hidden "Bot Chat" session WITHOUT an intro kickoff', async () => {
-  // Click-path resolution: a miss mints the session silently. The intro turn
-  // fires only from New Agent creation (kickoff: true) — re-firing it here
-  // burned a model turn and stamped a user-attributed prompt into the chat
-  // on every resolution miss (retitle/hidden-listing/update skew).
-  const runtime = loadOpenPath({
-    request: async method => {
-      if (method === 'session.list') return { sessions: [] }
-      if (method === 'session.create') return { stored_session_id: 'fresh-1', session_id: 'rt-1' }
-      return {}
-    }
-  })
-
-  const opened = await runtime.openBotCanonicalChat('newbie')
-  assert.equal(opened.registryId, 'fresh-1')
-  assert.equal(opened.openedId, 'fresh-1')
-  const create = runtime.requests.find(r => r.method === 'session.create')
-  assert.equal(create?.params?.title, 'Bot Chat')
-  assert.equal(create?.params?.hidden, true)
-  // The eager title write persisted the row; no user-attributed intro.
-  const titled = runtime.requests.find(r => r.method === 'session.title')
-  assert.equal(titled?.params?.session_id, 'rt-1')
-  const kickoff = runtime.requests.find(r => r.method === 'prompt.submit')
-  assert.equal(kickoff, undefined)
-})
-
-test('a failed open of the registry row surfaces instead of forking a replacement', async () => {
-  const runtime = loadOpenPath({
-    openSession: async () => {
-      throw new Error('backend restarting')
-    },
-    request: async method => {
-      if (method === 'session.list') {
-        return { sessions: [{ id: 'forever-chat', title: 'Bot Chat', message_count: 12 }] }
-      }
-      if (method === 'session.create') {
-        throw new Error('must not create: a transient open failure is not ownership loss')
-      }
-      return {}
-    }
-  })
-
-  await assert.rejects(() => runtime.openBotCanonicalChat('ops'), /backend restarting/)
-})
-
-// ── 3. ordinary sessions are never claimed ──────────────────────────────────
-
-test('an ordinary titled session never satisfies the registry lookup', async () => {
-  const runtime = loadOpenPath({
-    request: async method => {
-      if (method === 'session.list') {
-        // A misbehaving/older gateway ignores the title param and returns a
-        // windowed listing — the local exact-title scan still applies.
-        return {
-          sessions: [
-            { id: 'scratch', title: 'help me with x', message_count: 40 },
-            { id: 'draft', title: '', message_count: 0 }
-          ]
-        }
-      }
-      if (method === 'session.create') return { stored_session_id: 'fresh-2', session_id: 'rt-2' }
-      return {}
-    }
-  })
-
-  const opened = await runtime.openBotCanonicalChat('ops')
-  assert.equal(opened.registryId, 'fresh-2', 'no row titled "Bot Chat" → create; never adopt an ordinary conversation')
-  assert.equal(opened.openedId, 'fresh-2')
-  assert.ok(!runtime.opened.some(o => o.id === 'scratch'))
-})
-
-// ── 4. a failed lookup fails CLOSED — never "no chat exists" ────────────────
-//
-// The post-update window: the desktop restarts every profile backend, the
-// first bot click races the warm-up, and the registry lookup RPC fails
-// transiently. Swallowing that error and returning null made the failure
-// indistinguishable from "this bot has no Bot Chat yet", so the create path
-// minted a fresh forever-chat while the real one (data intact, hidden) still
-// held the canonical title — read by users as "my bot lost everything after
-// the update". A lookup failure must surface (the open paths toast
-// "try again"), never resolve to mint.
-
-test('a failed registry lookup rejects instead of minting a replacement chat', async () => {
-  const runtime = loadOpenPath({
-    request: async method => {
-      if (method === 'session.list') {
-        throw new Error('gateway not ready')
-      }
-      if (method === 'session.create') {
-        throw new Error('must not create: a failed lookup is not "no chat exists"')
-      }
-      return {}
-    }
-  })
-
-  await assert.rejects(() => runtime.openBotCanonicalChat('ops'), /Bot Chat registry/)
-  assert.ok(!runtime.requests.some(r => r.method === 'session.create'),
-    'session.create must never fire off a failed lookup')
-  assert.equal(runtime.opened.length, 0)
-})
-
-test('createCanonicalChat also refuses to mint when the adoption lookup fails', async () => {
-  const runtime = loadOpenPath({
-    request: async method => {
-      if (method === 'session.list') {
-        throw new Error('backend warming up')
-      }
-      if (method === 'session.create') {
-        throw new Error('must not create: adoption check failed, ownership is unknown')
-      }
-      return {}
-    }
-  })
-
-  await assert.rejects(() => runtime.createCanonicalChat('ops'), /Bot Chat registry/)
-  assert.ok(!runtime.requests.some(r => r.method === 'session.create'))
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/cloud-alias-identity.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/cloud-alias-identity.test.mjs
deleted file mode 100644
index 0c684319ff8c..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/cloud-alias-identity.test.mjs
+++ /dev/null
@@ -1,162 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #89131: a Desktop per-profile Cloud alias ("moxie" → exact Cloud connection
-// → backend targetProfile "default") must keep its friendly identity after
-// the hosted session activates, and must render as the alias — not generic
-// "Hermes" or a hostname label — when Cloud is the only active source.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function runtime({ connectionId = 'local' } = {}) {
-  const atom = value => ({ get: () => value, set: next => { value = next } })
-  const jsx = (type, props = {}) => ({ type, props })
-  const context = {
-    atom,
-    jsx,
-    jsxs: jsx,
-    useQuery: () => ({}),
-    useValue: value => (value?.get ? value.get() : value),
-    useState: value => [value, () => undefined],
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      state: {
-        connectionId: { get: () => connectionId, listen: () => undefined },
-        profile: { get: () => 'default', listen: () => undefined }
-      },
-      request: () => undefined
-    },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const code = source
-    .replace(/^import \* as sdk from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__indexAliasRoutes = indexAliasRoutes;' +
-        '\nglobalThis.__aliasIdentityFor = aliasIdentityFor;' +
-        '\nglobalThis.__displayName = displayName;' +
-        '\nglobalThis.__botRosterMeta = botRosterMeta;' +
-        '\nglobalThis.__botFriendlyNames = botFriendlyNames;' +
-        '\nglobalThis.__botMentionTag = botMentionTag;' +
-        '\nglobalThis.__botMeta = $botMeta;'
-    )
-  vm.runInNewContext(code, context)
-  return context
-}
-
-const MOXIE_ROUTE = { connectionId: 'cloud-abc', mode: 'remote', profile: 'moxie', targetProfile: 'default' }
-
-/** The hosted backend's own roster row after alias handoff: the Cloud
- *  connection answers as its root profile, so the row identity is
- *  (cloud-abc, default) — NOT the alias key. */
-const hostedRow = {
-  name: 'default',
-  connectionId: 'cloud-abc',
-  connectionLabel: 'cloud.example.com',
-  targetProfile: 'default',
-  remoteSource: true,
-  sourceScoped: true,
-  route: { connectionId: 'cloud-abc', mode: 'remote', profile: 'default', targetProfile: 'default' }
-}
-
-test('alias identity survives hosted-session activation (roster refresh)', () => {
-  const ctx = runtime()
-  ctx.__indexAliasRoutes([
-    { connectionId: 'local', mode: 'local', profile: 'default', targetProfile: 'default' },
-    MOXIE_ROUTE
-  ])
-
-  // No stored title anywhere: the alias NAME is still the identity.
-  assert.equal(ctx.__displayName(hostedRow, null), 'Moxie')
-
-  // The alias's Bot Mode title (either meta key generation) claims the row.
-  const metaV2 = { 'cloud-abc::moxie': { title: 'Moxie' } }
-  assert.equal(ctx.__botRosterMeta(hostedRow, metaV2), metaV2['cloud-abc::moxie'])
-  assert.equal(ctx.__displayName(hostedRow, ctx.__botRosterMeta(hostedRow, metaV2)), 'Moxie')
-
-  const metaV1 = { moxie: { title: 'Moxie ✨' } }
-  assert.equal(ctx.__displayName(hostedRow, ctx.__botRosterMeta(hostedRow, metaV1)), 'Moxie ✨')
-})
-
-test('Cloud-only mode: the sole active-gateway default renders as the alias, not Hermes', () => {
-  // Global route is Cloud: the active gateway IS the Cloud connection and
-  // profiles.list returns one unannotated rich `default` row.
-  const ctx = runtime({ connectionId: 'cloud-abc' })
-  ctx.__indexAliasRoutes([MOXIE_ROUTE])
-
-  const soleBot = { name: 'default' }
-  assert.equal(ctx.__displayName(soleBot, null), 'Moxie')
-
-  // A user-set title still wins over the alias name.
-  assert.equal(ctx.__displayName(soleBot, { title: 'Custom' }), 'Custom')
-})
-
-test('alias never leaks to same-named defaults on other connections', () => {
-  const ctx = runtime()
-  ctx.__indexAliasRoutes([MOXIE_ROUTE])
-
-  const otherDefault = { ...hostedRow, connectionId: 'other-conn', route: null, targetProfile: 'default', connectionLabel: 'Personal' }
-  // Different connection: no alias claim — hostname label behavior stands.
-  assert.equal(ctx.__aliasIdentityFor(otherDefault), null)
-  assert.equal(ctx.__displayName(otherDefault, null), 'Personal')
-
-  // Local default while the ACTIVE gateway is local: untouched "Hermes".
-  assert.equal(ctx.__displayName({ name: 'default' }, null), 'Hermes')
-})
-
-test('two aliases claiming one backend row fail closed', () => {
-  const ctx = runtime()
-  ctx.__indexAliasRoutes([
-    MOXIE_ROUTE,
-    { connectionId: 'cloud-abc', mode: 'remote', profile: 'roxie', targetProfile: 'default' }
-  ])
-
-  assert.equal(ctx.__aliasIdentityFor(hostedRow), null)
-  // Ambiguous: fall back to the source label, not a guessed alias.
-  assert.equal(ctx.__displayName(hostedRow, null), 'cloud.example.com')
-})
-
-test('the alias row itself never claims its own alias entry', () => {
-  const ctx = runtime()
-  ctx.__indexAliasRoutes([MOXIE_ROUTE])
-
-  const aliasRow = {
-    name: 'moxie',
-    connectionId: 'cloud-abc',
-    targetProfile: 'default',
-    sourceScoped: true,
-    route: { ...MOXIE_ROUTE }
-  }
-  assert.equal(ctx.__aliasIdentityFor(aliasRow), null)
-  assert.equal(ctx.__displayName(aliasRow, null), 'Moxie')
-})
-
-test('mentions keep resolving @moxie against the hosted row after handoff', () => {
-  const ctx = runtime()
-  ctx.__indexAliasRoutes([MOXIE_ROUTE])
-  ctx.__botMeta.set({ 'cloud-abc::moxie': { title: 'Moxie' } })
-
-  const friendly = ctx.__botFriendlyNames(hostedRow).filter(Boolean)
-  assert.equal(friendly.length, 1)
-  assert.equal(friendly[0], 'Moxie')
-  assert.equal(ctx.__botMentionTag(hostedRow), 'moxie')
-})
-
-test('non-alias routes never enter the index; index refresh replaces stale claims', () => {
-  const ctx = runtime()
-  ctx.__indexAliasRoutes([
-    { connectionId: 'local', mode: 'local', profile: 'rune', targetProfile: 'rune' },
-    MOXIE_ROUTE
-  ])
-  assert.ok(ctx.__aliasIdentityFor(hostedRow))
-
-  // Alias removed from config → next inventory drops the claim.
-  ctx.__indexAliasRoutes([{ connectionId: 'local', mode: 'local', profile: 'rune', targetProfile: 'rune' }])
-  assert.equal(ctx.__aliasIdentityFor(hostedRow), null)
-  assert.equal(ctx.__displayName(hostedRow, null), 'cloud.example.com')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/create-agent-clone-default.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/create-agent-clone-default.test.mjs
deleted file mode 100644
index 2b943e0d3f65..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/create-agent-clone-default.test.mjs
+++ /dev/null
@@ -1,21 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// CreateAgentDialog seeds cloneFrom with useState('default') — "Clone from:
-// default (the main profile)" — but reset() restored it to '__none__' ("Fresh
-// profile"). The first dialog open cloned the main profile; every later open
-// after a create/cancel silently defaulted to a fresh profile. reset() must
-// restore the same default the dialog was mounted with.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-const initialMatch = source.match(/const \[cloneFrom, setCloneFrom\] = useState\('([^']+)'\)/)
-assert.ok(initialMatch, 'cloneFrom useState initializer is missing')
-
-test('regression: New Agent reset restores the initial clone-from default', () => {
-  const initial = initialMatch[1]
-  assert.equal(initial, 'default')
-  assert.match(source, new RegExp(`setCloneFrom\\('${initial}'\\)`))
-  assert.doesNotMatch(source, /setCloneFrom\('__none__'\)/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/create-agent-mcp-setup.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/create-agent-mcp-setup.test.mjs
deleted file mode 100644
index 3200676dbc68..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/create-agent-mcp-setup.test.mjs
+++ /dev/null
@@ -1,48 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// The New Agent dialog must let you configure MCP OAuth / API-key credentials
-// DURING creation (not force create-then-edit). It does this by lazily
-// materializing the profile on first setup via ensureAgentCreated(), passed to
-// McpSetupButton as ensureProfile.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('McpSetupButton accepts an ensureProfile callback and resolves the profile lazily', () => {
-  const fn = source.slice(
-    source.indexOf('function McpSetupButton('),
-    source.indexOf('function botAppearance(')
-  )
-  // Signature carries ensureProfile.
-  assert.match(fn, /function McpSetupButton\(\{ profile, entry, onDone, ensureProfile \}\)/)
-  // resolveProfile falls back to ensureProfile() when no profile is set yet.
-  assert.match(fn, /const resolveProfile = async \(\) =>/)
-  assert.match(fn, /const created = await ensureProfile\(\)/)
-  // Both credential paths resolve the profile before adding the server.
-  const beginKeys = fn.slice(fn.indexOf('const beginKeys ='), fn.indexOf('const submitKeys ='))
-  assert.match(beginKeys, /const profile = await resolveProfile\(\)/)
-  const beginOAuth = fn.slice(fn.indexOf('const beginOAuth ='), fn.indexOf('if (supported === false)'))
-  assert.match(beginOAuth, /const profile = await resolveProfile\(\)/)
-})
-
-test('CreateAgentDialog materializes the profile lazily and idempotently', () => {
-  const fn = source.slice(
-    source.indexOf('function CreateAgentDialog('),
-    source.indexOf('function RoutinesPane(') > source.indexOf('function CreateAgentDialog(')
-      ? source.indexOf('function RoutinesPane(')
-      : source.length
-  )
-  // Idempotent creation guard shares the in-flight creation promise.
-  assert.match(fn, /const ensureAgentCreated = \(\) =>/)
-  assert.match(fn, /singleFlight\(flightRef, async \(\) =>/)
-  // The slug ref stays a string for its sibling consumers (taken check,
-  // draft discard, MCP setup profile param).
-  assert.match(fn, /createdRef\.current = slug/)
-  // submit() routes through the same helper (no duplicate profiles.create).
-  assert.match(fn, /const slugCreated = await ensureAgentCreated\(\)/)
-  // The MCP setup button in Create is wired to lazy creation, not disabled.
-  assert.match(fn, /ensureProfile: ensureAgentCreated/)
-  // The dead "save the agent first" gate is gone.
-  assert.doesNotMatch(source, /save the agent first/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/create-group-chat.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/create-group-chat.test.mjs
deleted file mode 100644
index 899a2a3e3688..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/create-group-chat.test.mjs
+++ /dev/null
@@ -1,42 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// Discord-style creation flow: the header "+" is a dropdown (New Bot /
-// New Group Chat), and New Group Chat opens a checkbox-picker modal with
-// search, a name input, and a Create button. Source-contract style, like
-// the other roster affordance tests.
-
-test('source contract: header + is a dropdown offering agent and group chat', () => {
-  assert.match(pluginSource, /DropdownMenuTrigger/)
-  assert.match(pluginSource, /'New Bot'/)
-  assert.match(pluginSource, /'New Group Chat'/)
-})
-
-test('source contract: create-group modal has search, checkboxes, name, create', () => {
-  assert.match(pluginSource, /function CreateGroupChatDialog\(/)
-  // An outage placeholder preserves identity, but cannot receive a message.
-  assert.match(pluginSource, /const selectableRoster = roster\.filter\(bot => !bot\?\.ghost\)/)
-  // Reuses the roster search filter so name/@handle/title all match.
-  assert.match(pluginSource, /const visible = filterBots\(selectableRoster, allMeta, query\)/)
-  // Selection is checkbox-driven and capped at the room member limit.
-  assert.match(pluginSource, /const atCap = selected\.length >= GROUP_CHAT_MAX_MEMBERS/)
-  // Create requires 2+ members. Membership mutation is covered by the
-  // behavioral groupMembershipPatch tests rather than another source regex.
-  assert.match(pluginSource, /selected\.length >= 2/)
-  // Creating drops the user straight into the room (main window when the
-  // desktop offers host.openWorkspace, in-panel fallback otherwise).
-  assert.match(pluginSource, /onCreated: groupName => openGroupChat\(groupName\)/)
-})
-
-test('source contract: group name falls back to member names, Discord-style', () => {
-  assert.match(pluginSource, /selected\.map\(bot => displayName\(bot, botRosterMeta\(bot, allMeta\)\)\)\.join\(', '\)/)
-})
-
-test('source contract: every selected machine is persisted in the durable room record', () => {
-  assert.match(pluginSource, /const roomMembers = durableGroupChatMembers\(selected\)/)
-  assert.match(pluginSource, /room\.members = roomMembers/)
-  assert.doesNotMatch(pluginSource, /const remoteMembers = selected/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/cross-connection-bots.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/cross-connection-bots.test.mjs
deleted file mode 100644
index e60fb8d2bdd0..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/cross-connection-bots.test.mjs
+++ /dev/null
@@ -1,231 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Cross-connection Bot Mode: the New Agent "Create on" picker targets another
-// registered connection's backend, and group chats seat members from other
-// machines by routing their turns through host.requestProfile route
-// descriptors instead of the active gateway.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function runtime() {
-  const context = {
-    console,
-    setTimeout,
-    clearTimeout,
-    Date,
-    URL,
-    atom: initial => {
-      const listeners = new Set()
-      let value = initial
-      return {
-        get: () => value,
-        set: next => {
-          value = next
-          listeners.forEach(fn => fn(next))
-        },
-        listen: fn => {
-          listeners.add(fn)
-          return () => listeners.delete(fn)
-        }
-      }
-    },
-    host: {
-      request: async () => ({}),
-      requestProfile: async () => ({}),
-      state: {
-        profile: { get: () => 'default', listen: () => undefined },
-        connectionId: { get: () => 'local', listen: () => undefined },
-        gateway: { listen: () => undefined }
-      }
-    },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } }
-  }
-  const code = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__x = { botConnectionRoute, scopedBotParams, botBackendProfileScope, requestForBot, groupMemberKey, parseGroupChatMentions, resolveGroupResponders, formatGroupChatLine, buildGroupChatTurnPrompt };\n'
-    )
-  vm.runInNewContext(code, context, { filename: 'plugin.js' })
-  return context
-}
-
-test('botConnectionRoute: every source-scoped row gets an immutable route', () => {
-  const ctx = runtime()
-  const { botConnectionRoute } = ctx.__x
-
-  assert.equal(botConnectionRoute({ name: 'writer', connectionId: 'local' }), null)
-  assert.equal(botConnectionRoute({ name: 'writer' }), null)
-  const active = botConnectionRoute({ name: 'writer', connectionId: 'spark', sourceScoped: true })
-  assert.equal(Object.isFrozen(active), true)
-
-  const route = botConnectionRoute({ name: 'dixie', connectionId: 'mac-mini', remoteSource: true })
-  assert.deepEqual(JSON.parse(JSON.stringify(route)), {
-    connectionId: 'mac-mini',
-    mode: 'remote',
-    profile: 'dixie',
-    targetProfile: 'dixie'
-  })
-})
-
-test('requestForBot: source-scoped members go through requestProfile', async () => {
-  const ctx = runtime()
-  const calls = []
-  ctx.host.request = async (method, params) => {
-    calls.push(['active', method, params])
-    return {}
-  }
-  ctx.host.requestProfile = async (route, method, params) => {
-    calls.push(['routed', route.connectionId, method, params])
-    return {}
-  }
-
-  const { requestForBot } = ctx.__x
-
-  await requestForBot({ name: 'local-bot' }, 'session.create', { title: 'x' })
-  await requestForBot({ name: 'local-bot', connectionId: 'local', sourceScoped: true }, 'session.create', { title: 'x' })
-  await requestForBot({ name: 'dixie', connectionId: 'mac-mini', remoteSource: true }, 'prompt.submit', { text: 'hi' })
-
-  assert.equal(calls[0][0], 'active')
-  assert.equal(calls[0][1], 'session.create')
-  assert.equal(calls[1][0], 'routed')
-  assert.equal(calls[1][1], 'local')
-  assert.equal(calls[2][0], 'routed')
-  assert.equal(calls[2][1], 'mac-mini')
-  assert.equal(calls[2][2], 'prompt.submit')
-})
-
-test('requestForBot: non-identity aliases translate every backend profile RPC shape', async () => {
-  const ctx = runtime()
-  const calls = []
-  ctx.host.requestProfile = async (route, method, params) => {
-    calls.push({ route, method, params })
-    return {}
-  }
-  const bot = {
-    name: 'worker',
-    sourceScoped: true,
-    route: {
-      connectionId: 'remote-a',
-      mode: 'remote',
-      profile: 'worker',
-      targetProfile: 'backend-worker'
-    }
-  }
-
-  await ctx.__x.requestForBot(bot, 'profiles.describe', { name: 'worker' })
-  await ctx.__x.requestForBot(bot, 'profiles.configure', { name: 'worker', soul: 'x' })
-  await ctx.__x.requestForBot(bot, 'profiles.create', { name: 'worker-2', clone_from: 'worker' })
-  await ctx.__x.requestForBot(bot, 'session.create', { profile: 'worker', title: 'Bot Chat' })
-  await ctx.__x.requestForBot(bot, 'cli.exec', { argv: ['--profile', 'worker', 'config', 'unset', 'model'] })
-  await ctx.__x.requestForBot(bot, 'cli.exec', {
-    argv: ['profile', 'describe', 'worker', '--text', 'worker']
-  })
-
-  assert.deepEqual(JSON.parse(JSON.stringify(calls.map(call => call.params))), [
-    { name: 'backend-worker' },
-    { name: 'backend-worker', soul: 'x' },
-    { name: 'worker-2', clone_from: 'backend-worker' },
-    { profile: 'backend-worker', title: 'Bot Chat' },
-    { argv: ['--profile', 'backend-worker', 'config', 'unset', 'model'] },
-    { argv: ['profile', 'describe', 'backend-worker', '--text', 'worker'] }
-  ])
-  assert.equal(calls.every(call => call.route.profile === 'worker'), true)
-})
-
-test('advanced capability scope keeps Desktop identity separate from backend targetProfile', () => {
-  const scope = runtime().__x.botBackendProfileScope({
-    connectionId: 'remote-a',
-    profile: 'worker',
-    targetProfile: 'backend-worker'
-  })
-
-  assert.deepEqual(JSON.parse(JSON.stringify(scope)), {
-    connectionId: 'remote-a',
-    profile: 'backend-worker'
-  })
-})
-
-test('groupMemberKey: local members keep bare names (persisted-room compat), remote members are source-qualified', () => {
-  const ctx = runtime()
-  const { groupMemberKey } = ctx.__x
-
-  assert.equal(groupMemberKey({ name: 'ops' }), 'ops')
-  assert.equal(groupMemberKey({ name: 'dixie', connectionId: 'mac-mini', remoteSource: true }), 'mac-mini::dixie')
-})
-
-test('mentions: @name-device handle resolves the remote member; same-named agents stay distinct', () => {
-  const ctx = runtime()
-  const { parseGroupChatMentions, resolveGroupResponders } = ctx.__x
-  const members = [
-    { name: 'dixie', title: '' },
-    { name: 'dixie', handle: 'dixie-mac-mini', connectionId: 'mac-mini', remoteSource: true }
-  ]
-
-  const parsed = parseGroupChatMentions('hey @dixie-mac-mini can you check disk space', members)
-  assert.deepEqual([...parsed.mentioned], ['mac-mini::dixie'])
-
-  const log = [{ from: { kind: 'user', name: 'You' }, text: '@dixie-mac-mini ping', at: 1 }]
-  const responders = resolveGroupResponders(log, members)
-  assert.equal(responders.length, 1)
-  assert.equal(responders[0].remoteSource, true)
-})
-
-test('room lines and turn prompts badge cross-connection speakers with their device', () => {
-  const ctx = runtime()
-  const { formatGroupChatLine, buildGroupChatTurnPrompt } = ctx.__x
-
-  const line = formatGroupChatLine(
-    { from: { kind: 'member', name: 'dixie', source: 'Mac Mini' }, text: 'done', at: 1 },
-    'ops'
-  )
-  assert.equal(line, 'dixie [Mac Mini]: done')
-
-  const prompt = buildGroupChatTurnPrompt({
-    groupName: 'infra',
-    members: [
-      { name: 'ops', title: '' },
-      { name: 'dixie', connectionId: 'mac-mini', connectionLabel: 'Mac Mini', remoteSource: true }
-    ],
-    viewer: { name: 'ops' },
-    deltaLines: ['You (user): hi']
-  })
-  assert.match(prompt, /@dixie \[on Mac Mini\]/)
-})
-
-test('source contract: New Agent has a Create on picker that routes creation to the target backend', () => {
-  assert.match(pluginSource, /'Create on'/)
-  assert.match(pluginSource, /const \[targetConnection, setTargetConnection\] = useState\(''\)/)
-  // Creation and configuration go through the target door, not bare host.request.
-  assert.match(pluginSource, /await requestForTarget\('profiles\.create', \{/)
-  assert.match(pluginSource, /await requestForTarget\('profiles\.configure', \{ name: slug/)
-  // The picker only renders on multi-connection registries.
-  assert.match(pluginSource, /connections\.length > 1/)
-})
-
-test('source contract: group chat turns route through requestForBot on the member source', () => {
-  assert.match(pluginSource, /await requestForBot\(member, 'prompt\.submit'/)
-  assert.match(pluginSource, /await requestForBot\(member, 'session\.create'/)
-  // Room records persist remote member descriptors.
-  assert.match(pluginSource, /members: Array\.isArray\(room\.members\) \? room\.members : \[\]/)
-})
-
-test('regression: host.connections() result is normalized for BOTH SDK shapes before the picker gate', () => {
-  // Current SDKs return the registry ROWS from host.connections() (the
-  // documented contract); desktops that predate the SDK-side unwrap resolve
-  // the raw IPC payload — the registry OBJECT ({version, primary,
-  // connections: [...]}). The picker gate (Array.isArray(connections) &&
-  // length > 1) needs rows either way, so the plugin must accept both
-  // shapes. Pinning one shape only reopens #89823 on the other.
-  assert.match(
-    pluginSource,
-    /setConnections\(Array\.isArray\(value\) \? value : Array\.isArray\(value\?\.connections\) \? value\.connections : \[\]\)/
-  )
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/draft-agent-discard.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/draft-agent-discard.test.mjs
deleted file mode 100644
index 5d3c2b09aef9..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/draft-agent-discard.test.mjs
+++ /dev/null
@@ -1,41 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// New Agent's lazily-materialized profile (Capabilities tab / MCP setup) is a
-// DRAFT until Create Agent is pressed: cancelling the dialog must delete it so
-// preconfigure-then-back-out leaves zero residue.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('discardDraft deletes the materialized draft (deleteBot locally, remote CLI for other connections)', () => {
-  assert.match(source, /const discardDraft = \(\) => \{/)
-  assert.match(source, /: deleteBot\(\{ name: draft \}\)/)
-  // Ref cleared FIRST so a re-entrant cancel can't double-delete.
-  assert.match(source, /createdRef\.current = null\n\s*flightRef\.current = null\n\s*const discard = remoteTarget/)
-})
-
-test('both cancel paths discard the draft (esc/overlay + Cancel button)', () => {
-  const dialogClose = /discardDraft\(\)\s*\n\s*reset\(\)\s*\n\s*onClose\(\)/g
-  const hits = source.match(dialogClose) || []
-  assert.ok(hits.length >= 2, `expected discardDraft before reset/onClose in both cancel paths, found ${hits.length}`)
-})
-
-test('successful create does NOT discard: reset clears createdRef before close', () => {
-  // reset() nulls the ref, so the dialog-close discard becomes a no-op after
-  // a real Create.
-  assert.match(source, /setError\(null\)\n\s*createdRef\.current = null\n\s*flightRef\.current = null\n\s*\}/)
-})
-
-test('renaming after materialization discards the orphaned draft', () => {
-  assert.match(source, /createdRef\.current && createdRef\.current !== slug/)
-})
-
-test("the draft's own slug does not read as taken", () => {
-  // Both branches of the target-scoped taken check exempt the draft's slug.
-  assert.match(source, /roster\.some\(b => !b\.remoteSource && b\.name === slug && b\.name !== createdRef\.current\)/)
-  assert.match(
-    source,
-    /roster\.some\(b => b\.remoteSource && b\.connectionId === targetConnection && b\.name === slug && b\.name !== createdRef\.current\)/
-  )
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/duplicate-bot.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/duplicate-bot.test.mjs
deleted file mode 100644
index 4301ad53e9f3..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/duplicate-bot.test.mjs
+++ /dev/null
@@ -1,87 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const calls = []
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      state: { profile: { listen: () => undefined } },
-      request: async (method, params) => {
-        calls.push({ method, params })
-        return { ok: true }
-      }
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__dup = { duplicateBot, $botMeta };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return { context, calls }
-}
-
-test('unit: duplicate copies the look but not the source chat pin', async () => {
-  const { context, calls } = load()
-  const { duplicateBot, $botMeta } = context.__dup
-  $botMeta.set({
-    researcher: {
-      shape: 'circle',
-      color: '#f97316',
-      title: 'Researcher',
-      image: 'data:image/png;base64,xx',
-      chat: 'sess-source-forever',
-      created: 1700000000000
-    }
-  })
-
-  const name = await duplicateBot({ name: 'researcher', description: 'finds things' }, [{ name: 'researcher' }])
-  assert.equal(name, 'researcher-2')
-
-  const clone = $botMeta.get()['researcher-2']
-  assert.equal(clone.shape, 'circle')
-  assert.equal(clone.color, '#f97316')
-  assert.equal(clone.image, 'data:image/png;base64,xx')
-  assert.equal(clone.title, 'Researcher (copy)')
-  assert.equal(clone.chat, undefined)
-  assert.equal(clone.created, undefined)
-
-  const created = calls.find(c => c.method === 'profiles.create')
-  assert.equal(created.params.clone_from, 'researcher')
-  assert.equal(created.params.name, 'researcher-2')
-
-  const configure = calls.filter(c => c.method === 'profiles.configure')
-  assert.ok(configure.length)
-  const ui = configure[configure.length - 1].params.ui_meta['hermes-bots']
-  assert.equal(ui.chat, undefined)
-  assert.equal(ui.created, undefined)
-  assert.equal(ui.title, 'Researcher (copy)')
-})
-
-test('regression: a bot with no pin still duplicates its look', async () => {
-  const { context } = load()
-  const { duplicateBot, $botMeta } = context.__dup
-  $botMeta.set({ painter: { shape: 'cloud', color: '#38bdf8', title: 'Painter' } })
-  const name = await duplicateBot({ name: 'painter' }, [{ name: 'painter' }])
-  const clone = $botMeta.get()[name]
-  assert.equal(clone.title, 'Painter (copy)')
-  assert.equal(clone.shape, 'cloud')
-  assert.equal(clone.chat, undefined)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/embed-real-capabilities.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/embed-real-capabilities.test.mjs
deleted file mode 100644
index a72cbdc5d0fb..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/embed-real-capabilities.test.mjs
+++ /dev/null
@@ -1,41 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// The bot editor (Edit Profile → Advanced) must render the REAL core Capabilities
-// components — ToolsetConfigPanel (full per-toolset env/keys/model/post-setup)
-// and McpTab (per-server enable + OAuth + API-key setup) — scoped to the bot's
-// profile, instead of bare checkbox stand-ins. Both are feature-detected so the
-// plugin still loads on older desktop builds that don't export them yet.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('resolves optional Capabilities components from the SDK namespace', () => {
-  assert.match(source, /import \* as sdk from '@hermes\/plugin-sdk'/)
-  assert.match(source, /const \{ McpTab, ToolsetConfigPanel \} = sdk/)
-})
-
-test('AdvancedProfileConfig embeds ToolsetConfigPanel per toolset, scoped to the bot profile', () => {
-  // Rendered only when the SDK export exists (older builds: just the toggle).
-  assert.match(source, /ToolsetConfigPanel\s*\n?\s*\?\s*jsx\('div'/)
-  assert.match(source, /jsx\(ToolsetConfigPanel, \{ toolset: tset\.name, profile: backendScope \}\)/)
-})
-
-test('AdvancedProfileConfig embeds the real McpTab with a live gateway + profile, feature-detected', () => {
-  assert.match(source, /McpTab && typeof host\.getGateway === 'function'/)
-  assert.match(source, /jsx\(McpTab, \{ gateway: host\.getGateway\(\), profile: backendScope \}\)/)
-})
-
-test('AdvancedProfileConfig scopes SkillsView to the connection and backend target profile', () => {
-  // Route lookup is the NON-throwing resolver (#93492): the dialog renders
-  // degraded for an orphaned row instead of crashing the pane.
-  assert.match(source, /const botRoute = resolveBotConnectionRoute\(bot\)\.route/)
-  assert.match(source, /fixedProfile: backendProfile/)
-  assert.match(source, /fixedConnection: botRoute\.connectionId/)
-})
-
-test('older-build fallback: the checkbox MCP list + inline McpSetupButton is still present', () => {
-  // The graceful path for desktops without the SDK export must remain intact.
-  assert.match(source, /jsx\(McpSetupButton, \{/)
-  assert.match(source, /No MCP servers configured or in the catalog\./)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/embed-skills-view.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/embed-skills-view.test.mjs
deleted file mode 100644
index a90f8270dacb..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/embed-skills-view.test.mjs
+++ /dev/null
@@ -1,230 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Newer desktop builds export the WHOLE core Capabilities surface (SkillsView,
-// hermes-agent#87317). The bot editor's Advanced section must render it pinned
-// to the bot's profile — in Edit Profile directly, and in New Agent behind a
-// Capabilities tab that materializes the profile first. Feature-detected so
-// the plugin still loads (and keeps its checklist UI) on older desktops.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadAdvanced(SkillsView, sdkComponents = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = {
-      get: () => values.get(slot),
-      set: value => values.set(slot, value),
-      listen: () => undefined
-    }
-    values.set(slot, initial)
-    return slot
-  }
-  const jsx = (type, props = {}) => ({ type, props })
-  const stateValues = [true, false, '']
-  const routed = []
-  let gatewayReads = 0
-  let query
-  const context = {
-    atom,
-    Checkbox: 'Checkbox',
-    GlyphSpinner: 'GlyphSpinner',
-    Input: 'Input',
-    ScrollArea: 'ScrollArea',
-    Textarea: 'Textarea',
-    document: { createElement: () => ({}), getElementById: () => null, head: { appendChild: () => undefined } },
-    host: {
-      getGateway: () => {
-        gatewayReads += 1
-        return 'ambient-gateway'
-      },
-      request: async (...args) => routed.push(['ambient', ...args]),
-      requestProfile: async (...args) => routed.push(['profile', ...args]),
-      state: {
-        gateway: { get: () => 'open', listen: () => undefined },
-        profile: { get: () => 'default', listen: () => undefined }
-      }
-    },
-    jsx,
-    jsxs: jsx,
-    queryClient: { invalidateQueries: () => undefined },
-    sdk: { SkillsView, ...sdkComponents },
-    useQuery: options => {
-      query = options
-      return { data: { providers: [] }, isLoading: false, error: null }
-    },
-    useState: initial => [stateValues.length ? stateValues.shift() : initial, () => undefined],
-    window: { setTimeout, clearTimeout }
-  }
-  const code = source
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__AdvancedProfileConfig = AdvancedProfileConfig; globalThis.__useModelOptions = useModelOptions;')
-  vm.runInNewContext(code, context, { filename: 'plugin.js' })
-
-  return { context, gatewayReads: () => gatewayReads, query: () => query, routed }
-}
-
-function descendants(node) {
-  if (!node || typeof node !== 'object') return []
-  const children = Array.isArray(node.props?.children) ? node.props.children : [node.props?.children]
-  return [node, ...children.flatMap(descendants)]
-}
-
-const remoteBot = {
-  connectionId: 'remote-a',
-  name: 'default',
-  remoteSource: true,
-  route: {
-    connectionId: 'remote-a',
-    mode: 'remote',
-    profile: 'default',
-    targetProfile: 'backend-default'
-  },
-  sourceScoped: true,
-  targetProfile: 'backend-default'
-}
-
-const localBot = {
-  connectionId: 'local',
-  name: 'default',
-  remoteSource: false,
-  route: {
-    connectionId: 'local',
-    mode: 'local',
-    profile: 'default',
-    targetProfile: 'default'
-  },
-  sourceScoped: true,
-  targetProfile: 'default'
-}
-
-const advancedState = {
-  loaded: true,
-  provider: '',
-  model: '',
-  soul: '',
-  skills: [],
-  toolsets: [],
-  mcp: [{ name: 'remote-mcp', enabled: false, fromCatalog: true, installed: false, requires: ['TOKEN'] }]
-}
-
-test('resolves SkillsView as an optional SDK namespace export', () => {
-  assert.match(source, /import \* as sdk from '@hermes\/plugin-sdk'/)
-  assert.match(source, /const SkillsView = typeof sdk === 'undefined' \? undefined : sdk\.SkillsView/)
-})
-
-test('Edit Profile renders the pinned Capabilities surface when the export exists', () => {
-  assert.match(source, /if \(SkillsView && \(!botRoute \|\| skillsViewRoutesConnections\)\) \{/)
-  assert.match(source, /fixedProfile: backendProfile/)
-  assert.match(source, /fixedConnection: botRoute\.connectionId/)
-})
-
-test('New Agent gains a Capabilities tab that materializes the profile first', () => {
-  // Tab list swaps to General + Capabilities on newer builds…
-  assert.match(source, /\['capabilities', 'Capabilities'\]/)
-  // …and opening it creates the profile through the same lazy door MCP setup uses.
-  assert.match(source, /id === 'capabilities'/)
-  assert.match(source, /ensureAgentCreated\(\)\s*\n?\s*\.then\(created => created && setCreatedForCaps\(created\)\)/)
-  assert.match(source, /jsx\(SkillsView, \{\s*embedded: true,\s*fixedProfile: createdForCaps,/)
-})
-
-test('remote-target drafts pin the live surface to the target connection', () => {
-  // Builds whose SkillsView routes fixedConnection get the live Capabilities
-  // tab for remote targets too — pinned to the target machine's backend.
-  assert.match(source, /skillsViewRoutesConnections = Boolean\(SkillsView && SkillsView\.supportsFixedConnection\)/)
-  assert.match(source, /SkillsView && \(!remoteTarget \|\| skillsViewRoutesConnections\)/)
-  assert.match(source, /\.\.\.\(remoteTarget \? \{ fixedConnection: targetConnection \} : \{\}\)/)
-})
-
-test('older-build fallback keeps the checklist UI intact', () => {
-  // The staged CheckList sections and the hub search section must survive for
-  // desktops without the SkillsView export.
-  assert.match(source, /jsx\(CheckList, \{ items: visibleSkills/)
-  assert.match(source, /jsx\(HubSkillsSection, \{/)
-})
-
-test('older SkillsView builds fail closed for remote Edit Profile', () => {
-  function OldSkillsView() {}
-  function McpTab() {}
-  function ToolsetConfigPanel() {}
-  const runtime = loadAdvanced(OldSkillsView, { McpTab, ToolsetConfigPanel })
-  const tree = runtime.context.__AdvancedProfileConfig({
-    bot: remoteBot,
-    state: advancedState,
-    setState: () => undefined
-  })
-  const nodes = descendants(tree)
-
-  assert.equal(nodes.some(node => node.type === OldSkillsView), false)
-  assert.equal(nodes.some(node => node.type?.name === 'ModelPicker'), true)
-  assert.equal(nodes.some(node => node.type === 'Textarea'), true)
-  assert.equal(nodes.some(node => node.type?.name === 'HubSkillsSection'), false)
-  assert.equal(nodes.some(node => node.type?.name === 'McpSetupButton'), false)
-  assert.equal(nodes.some(node => node.type === McpTab), false)
-  assert.equal(nodes.some(node => node.type === ToolsetConfigPanel), false)
-  assert.equal(runtime.gatewayReads(), 0)
-
-  for (const node of nodes) {
-    node.props?.onClick?.()
-    node.props?.onCheckedChange?.(true)
-  }
-
-  assert.equal(runtime.routed.some(call => call[0] === 'ambient'), false)
-  assert.equal(runtime.gatewayReads(), 0)
-})
-
-test('older SkillsView builds keep local capability fallback unchanged', () => {
-  function OldSkillsView() {}
-  function McpTab() {}
-  function ToolsetConfigPanel() {}
-  const runtime = loadAdvanced(OldSkillsView, { McpTab, ToolsetConfigPanel })
-  const tree = runtime.context.__AdvancedProfileConfig({
-    bot: localBot,
-    state: { ...advancedState, toolsets: [{ name: 'local-tools', enabled: true }] },
-    setState: () => undefined
-  })
-  const nodes = descendants(tree)
-
-  assert.equal(nodes.some(node => node.type?.name === 'HubSkillsSection'), true)
-  assert.equal(nodes.some(node => node.type === McpTab), true)
-  assert.equal(nodes.some(node => node.type === ToolsetConfigPanel), true)
-  assert.equal(runtime.gatewayReads(), 1)
-})
-
-test('connection-aware SkillsView receives separate connection and backend profile', () => {
-  function RoutedSkillsView() {}
-  RoutedSkillsView.supportsFixedConnection = true
-  const runtime = loadAdvanced(RoutedSkillsView)
-  const tree = runtime.context.__AdvancedProfileConfig({
-    bot: remoteBot,
-    state: advancedState,
-    setState: () => undefined
-  })
-  const view = descendants(tree).find(node => node.type === RoutedSkillsView)
-
-  assert.equal(view.props.fixedConnection, 'remote-a')
-  assert.equal(view.props.fixedProfile, 'backend-default')
-})
-
-test('Edit Profile model options use the captured non-identity Bot route', async () => {
-  const runtime = loadAdvanced(undefined)
-  runtime.context.__useModelOptions(remoteBot)
-
-  await runtime.query().queryFn()
-
-  assert.deepEqual(JSON.parse(JSON.stringify(runtime.routed)), [[
-    'profile',
-    remoteBot.route,
-    'model.options',
-    // No `refresh`: the picker's catalog read participates in the staleTime
-    // cache — a forced network read on every mount re-entered the spinner and
-    // wiped staged selections on Bots view remounts (#95279).
-    { include_unconfigured: true, explicit_only: false }
-  ]])
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/face-catchlight.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/face-catchlight.test.mjs
deleted file mode 100644
index 6df742ffa1cf..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/face-catchlight.test.mjs
+++ /dev/null
@@ -1,20 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// Catchlight contrast follows the PUPIL, not the body (image14 report,
-// Aug 2026): dark bodies flip the pupils to light cream (`eyeFill`), and a
-// white catchlight on a cream pupil is invisible — maroon/ink/oxblood
-// avatars looked like they had "no dots in their eyes". The sparkle must be
-// dark on light pupils and light on dark pupils.
-
-test('catchlight fill flips with pupil polarity (hlFill), not hardcoded white', () => {
-  assert.match(pluginSource, /const hlFill = isDarkColor\(color\) \? 'rgba\(0,0,0,0\.6\)' : 'rgba\(255,255,255,0\.85\)'/)
-  // Both initial catchlight circles use it.
-  assert.match(pluginSource, /'data-hb-hl-l': '1', cx: 14\.8, cy: eyeY0 - 0\.7, r: 0\.65, fill: hlFill/)
-  assert.match(pluginSource, /'data-hb-hl-r': '1', cx: 24, cy: eyeY0 - 0\.7, r: 0\.65, fill: hlFill/)
-  // No stray hardcoded white catchlight remains on the hb-hl elements.
-  assert.doesNotMatch(pluginSource, /data-hb-hl-[lr]': '1'[^}]*rgba\(255,255,255/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/face-clock.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/face-clock.test.mjs
deleted file mode 100644
index a1def1bee90a..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/face-clock.test.mjs
+++ /dev/null
@@ -1,200 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// Extract the clock functions only — the plugin is an ES module, so the whole
-// file can't be evaluated in a bare vm context. The slice is anchored on the
-// function declarations themselves.
-const start = pluginSource.indexOf('function startFaceClock()')
-const end = pluginSource.indexOf('/**\n * Live math face.')
-assert.ok(start > 0 && end > start, 'face clock functions present in plugin.js')
-const clockSource = pluginSource.slice(start, end)
-
-function load({ budgetedLoop = undefined, faces = [], intersectionObserver = true } = {}) {
-  const rafQueue = new Map()
-  let rafSeq = 0
-  let observerInstance = null
-
-  class FakeIntersectionObserver {
-    constructor(callback) {
-      this.callback = callback
-      this.observed = new Set()
-      this.disconnected = false
-      observerInstance = this
-    }
-
-    observe(el) {
-      this.observed.add(el)
-    }
-
-    unobserve(el) {
-      this.observed.delete(el)
-    }
-
-    disconnect() {
-      this.disconnected = true
-      this.observed.clear()
-    }
-
-    emit(entries) {
-      this.callback(entries)
-    }
-  }
-
-  const windowObj = {
-    requestAnimationFrame: cb => {
-      rafSeq += 1
-      rafQueue.set(rafSeq, cb)
-      return rafSeq
-    },
-    cancelAnimationFrame: id => {
-      rafQueue.delete(id)
-    }
-  }
-
-  const context = {
-    window: windowObj,
-    document: { hidden: false },
-    performance: { now: () => 0 },
-    IntersectionObserver: intersectionObserver ? FakeIntersectionObserver : undefined,
-    walkMathFaces: () => [...faces],
-    paintMathFace: () => undefined,
-    createBudgetedLoop: budgetedLoop
-  }
-  vm.createContext(context)
-  vm.runInContext(`${clockSource}; __start = startFaceClock; __stop = stopFaceClock`, context)
-
-  let now = 0
-  const pump = (advance = 100) => {
-    now += advance
-    const pending = [...rafQueue.entries()]
-    rafQueue.clear()
-    for (const [, cb] of pending) {
-      cb(now)
-    }
-  }
-
-  return {
-    start: () => context.__start(),
-    stop: () => context.__stop(),
-    pump,
-    pending: () => rafQueue.size,
-    observer: () => observerInstance,
-    clock: () => context.window.__hbFaceClock,
-    setFaces: next => {
-      faces.length = 0
-      faces.push(...next)
-    }
-  }
-}
-
-test('unit: the clock parks itself when no faces are mounted', () => {
-  const h = load({ faces: [] })
-  h.start()
-  assert.equal(h.pending(), 1, 'clock schedules its first frame')
-  h.pump()
-  assert.equal(h.pending(), 0, 'no faces -> dormant, no further frames scheduled')
-})
-
-test('unit: a mounting face (startFaceClock re-entry) wakes a parked clock', () => {
-  const h = load({ faces: [] })
-  h.start()
-  h.pump()
-  assert.equal(h.pending(), 0, 'parked')
-
-  const face = { isConnected: true }
-  h.setFaces([face])
-  h.start() // BotFace render path
-  assert.equal(h.pending(), 1, 'wake scheduled a frame')
-})
-
-test('unit: the clock parks when all faces scroll out and the observer wakes it back', () => {
-  const face = { isConnected: true }
-  const h = load({ faces: [face] })
-  h.start()
-  h.pump()
-  // Face observed but not yet visible -> visibleFaces empty -> parked.
-  assert.equal(h.pending(), 0, 'no visible faces -> dormant')
-
-  h.observer().emit([{ target: face, isIntersecting: true }])
-  assert.equal(h.pending(), 1, 'visibility wakes the clock')
-  h.pump()
-  assert.equal(h.pending(), 1, 'visible face keeps the clock running')
-
-  h.observer().emit([{ target: face, isIntersecting: false }])
-  h.pump()
-  h.pump()
-  assert.equal(h.pending(), 0, 'all faces hidden -> parked again')
-})
-
-test('unit: stopFaceClock cancels the frame, disconnects the observer, and clears the handle', () => {
-  const face = { isConnected: true }
-  const h = load({ faces: [face] })
-  h.start()
-  h.observer().emit([{ target: face, isIntersecting: true }])
-  h.pump()
-  assert.equal(h.pending(), 1, 'running')
-
-  h.stop()
-  assert.equal(h.pending(), 0, 'pending frame cancelled')
-  assert.equal(h.observer().disconnected, true, 'observer disconnected')
-  assert.equal(h.clock(), undefined, 'window handle removed')
-
-  // A fresh start after teardown re-initializes rather than hitting a dead handle.
-  h.start()
-  assert.equal(h.pending(), 1, 'clock restarts cleanly after stop')
-})
-
-test('source: plugin registers face-clock teardown via ctx.onDispose', () => {
-  assert.match(pluginSource, /ctx\.onDispose\(stopFaceClock\)/)
-})
-
-test('unit: SDK path — clock delegates scheduling to createBudgetedLoop', () => {
-  const calls = { dispose: 0, wake: 0 }
-  let capturedDraw = null
-  let capturedOptions = null
-  const fakeLoop = {
-    dispose: () => {
-      calls.dispose += 1
-    },
-    isDormant: () => false,
-    wake: () => {
-      calls.wake += 1
-    }
-  }
-  const face = { isConnected: true }
-  const h = load({
-    faces: [face],
-    budgetedLoop: (draw, options) => {
-      capturedDraw = draw
-      capturedOptions = options
-      return fakeLoop
-    }
-  })
-
-  h.start()
-  assert.equal(typeof capturedDraw, 'function', 'draw handed to the SDK loop')
-  assert.equal(capturedOptions.fps, 15, '15fps budget requested')
-  assert.equal(typeof capturedOptions.idleWhen, 'function', 'idle predicate wired')
-  assert.equal(h.pending(), 0, 'no hand-rolled rAF scheduled on the SDK path')
-
-  // idleWhen reflects visible-face state: observed-but-not-visible = idle.
-  capturedDraw(1000) // triggers the initial scan + observation
-  assert.equal(capturedOptions.idleWhen(), true, 'no visible faces -> idle')
-  h.observer().emit([{ target: face, isIntersecting: true }])
-  assert.equal(capturedOptions.idleWhen(), false, 'visible face -> not idle')
-  assert.ok(calls.wake >= 1, 'visibility wakes the SDK loop')
-
-  // Re-entry (BotFace mount) wakes rather than re-initializing.
-  h.start()
-  assert.ok(calls.wake >= 2, 'startFaceClock re-entry wakes the SDK loop')
-
-  // Teardown disposes the loop and clears the handle.
-  h.stop()
-  assert.equal(calls.dispose, 1, 'stop disposes the SDK loop')
-  assert.equal(h.observer().disconnected, true, 'observer disconnected')
-  assert.equal(h.clock(), undefined, 'window handle removed')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/focused-bot-highlight.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/focused-bot-highlight.test.mjs
deleted file mode 100644
index 02f0afe45274..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/focused-bot-highlight.test.mjs
+++ /dev/null
@@ -1,91 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// The roster highlight and the Routines (Cronjobs) tile must follow the chat
-// the user is LOOKING AT — the focused session's owner profile — not the
-// gateway socket's home. Tab/tile focus moves without swapping the socket, so
-// keying these off `host.state.profile` alone highlighted (and scoped the
-// Cronjobs panel to) the wrong bot whenever a focused tab showed another
-// profile's chat (community report: Newsanalyst chat open, Hermes highlighted).
-
-test('$focusedBotOwner prefers the connection-qualified focused owner atom', () => {
-  assert.match(
-    source,
-    /const \$focusedBotOwner = host\.state\.focusedSessionOwner \|\|/,
-    'newer desktops expose a complete focused owner; older builds retain a feature-detected fallback'
-  )
-})
-
-test('legacy focused-profile-only SDK never pairs foreign focus with ambient connection', () => {
-  const ownerStart = source.indexOf('const $focusedBotProfile =')
-  const ownerEnd = source.indexOf('/** Optional secondary navigation', ownerStart)
-  const activeStart = source.indexOf('function isActiveRosterBot(')
-  const activeEnd = source.indexOf('function botSelectionKey(', activeStart)
-  const store = value => ({ get: () => value, listen: () => undefined })
-  const context = {
-    host: {
-      activeConnectionId: () => 'source-a',
-      state: {
-        connectionId: store('source-a'),
-        focusedSessionProfile: store('worker'),
-        profile: store('default')
-      }
-    }
-  }
-
-  vm.runInNewContext(
-    `${source.slice(ownerStart, ownerEnd)}\n${source.slice(activeStart, activeEnd)}\n` +
-      'globalThis.result = { owner: focusedRosterOwner($focusedBotOwner.get()), isActiveRosterBot };',
-    context
-  )
-
-  assert.equal(context.result.owner, null)
-  assert.equal(context.result.isActiveRosterBot({
-    connectionId: 'source-a',
-    name: 'worker',
-    remoteSource: true
-  }, context.result.owner), false)
-  assert.equal(context.result.isActiveRosterBot({ name: 'default' }, context.result.owner), false)
-})
-
-test('BotRow keys the highlight off the focused profile, not the socket home', () => {
-  const rowStart = source.indexOf('function BotRow(')
-  assert.ok(rowStart >= 0)
-  const row = source.slice(rowStart, rowStart + 2000)
-
-  assert.match(row, /const focusedOwner = focusedRosterOwner\(useValue\(\$focusedBotOwner\)\)/)
-  assert.match(row, /const isActive = botRowOwnsWorkspace\([\s\S]*?focusedOwner,[\s\S]*?selectedRosterKey/)
-})
-
-test('BotRow keeps turn-busy (work mood) a socket fact', () => {
-  const rowStart = source.indexOf('function BotRow(')
-  const row = source.slice(rowStart, rowStart + 5000)
-
-  // Only the gateway-home profile can actually be mid-turn: the mood must NOT
-  // switch to the focus-keyed identity.
-  assert.match(row, /const isGatewayHome = !bot\.remoteSource && bot\.name === activeProfile/)
-  assert.match(row, /const botMood = workerActive \|\| \(isGatewayHome && gatewayState === 'busy'\) \? 'work' : 'idle'/)
-})
-
-test('RoutinesPane scopes the Cronjobs tile to the focused chat owner', () => {
-  const paneStart = source.indexOf('function RoutinesPane(')
-  assert.ok(paneStart >= 0)
-  const pane = source.slice(paneStart, paneStart + 1200)
-
-  assert.match(pane, /const focusedOwner = focusedRosterOwner\(useValue\(\$focusedBotOwner\)\)/)
-  // The roster read must be a SUBSCRIPTION, not a bare .get(): BotsHomeView
-  // owns the fetch and can hydrate after this pane mounted, so a bare snapshot
-  // pinned the tile on "unavailable" forever (#94483). Scoping intent is
-  // unchanged — it still keys off the focused owner, never the socket-home
-  // profile atom asserted against below.
-  assert.match(pane, /const owner = resolveRoutineOwner\(useValue\(\$lastRoster\), focusedOwner, selected\)/)
-  assert.ok(!/useValue\(host\.state\.profile\)/.test(pane), 'the tile must not read the socket-home atom directly')
-})
-
-test('the $selectedBot tracker binds the focused profile ladder (reseed + unbind captured)', () => {
-  assert.match(source, /const unbindProfileListener = bindProfileSync\(\$focusedBotOwner\)/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-activity.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-activity.test.mjs
deleted file mode 100644
index e46085be69d4..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-activity.test.mjs
+++ /dev/null
@@ -1,309 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Collapsible group Activity view: a runtime-only, bounded feed of truthful
-// turn events (queued / working / replied / passed / timed-out / failed /
-// cancelled / settled / delivered) that the room shows in a quiet disclosure.
-// The transcript stays the only durable record — activity is never persisted.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** Load the plugin in a vm with a scripted gateway so member turns are
- *  deterministic. `turnScript(profile, prompt, n, session)` returns the
- *  member's reply text, a promise of it, or throws for a failed turn. */
-function load(turnScript = () => '(pass)') {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const calls = []
-  const sessions = new Map()
-  const runtimeToStored = new Map()
-  const titleToStored = new Map()
-  let sessionSequence = 0
-
-  const resolveSession = (profile, target) => {
-    const stored = runtimeToStored.get(target) || (sessions.has(target) ? target : titleToStored.get(`${profile}::${target}`))
-    return stored ? sessions.get(stored) : null
-  }
-  const context = {
-    atom,
-    setTimeout: fn => {
-      fn()
-      return 0
-    },
-    clearTimeout: () => undefined,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: async (method, params) => {
-        if (method === 'session.create') {
-          sessionSequence += 1
-          const stored = `sid-${params.profile}-${sessionSequence}`
-          const runtime = `rt-${params.profile}-${sessionSequence}`
-          const session = { stored, runtime, profile: params.profile, title: params.title, messages: [] }
-          sessions.set(stored, session)
-          runtimeToStored.set(runtime, stored)
-          titleToStored.set(`${params.profile}::${params.title}`, stored)
-          return { session_id: runtime, stored_session_id: stored, message_count: 0, messages: [] }
-        }
-        if (method === 'session.resume') {
-          const session = resolveSession(params.profile, params.session_id)
-          if (!session) {
-            // Shaped like the real gateway's JsonRpcGatewayError (`.code`,
-            // apps/shared/src/json-rpc-gateway.ts) so ensureGroupChatSession's
-            // fail-closed `.code !== 4007` check sees the same "genuinely
-            // not found" signal production does.
-            const err = new Error(`session not found: ${params.session_id}`)
-            err.code = 4007
-            throw err
-          }
-          return {
-            session_id: session.runtime,
-            session_key: session.stored,
-            message_count: session.messages.length,
-            messages: [...session.messages],
-            inflight: false,
-            running: false
-          }
-        }
-        if (method === 'prompt.submit') {
-          const session = resolveSession(null, params.session_id)
-          if (!session) {
-            throw new Error(`runtime session not found: ${params.session_id}`)
-          }
-          session.messages.push({ role: 'user', content: params.text })
-          calls.push({
-            profile: session.profile,
-            prompt: params.text,
-            runtime: session.runtime,
-            stored: session.stored,
-            title: session.title
-          })
-          const reply = await turnScript(session.profile, params.text, calls.length, session)
-          session.messages.push({ role: 'assistant', content: reply })
-          return {}
-        }
-        return {}
-      },
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } },
-      notify: () => undefined,
-      notifyError: () => undefined
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__ga = { sendToGroupChat, recordGroupActivity, currentGroupActivity, groupActivityLabel, updateGroupChat, $groupChats, $groupActivity, $botAttention, GROUP_ACTIVITY_LIMIT };\n'
-    )
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  const storageWrites = new Map()
-  context.plugin.register({
-    storage: { get: () => null, set: (key, value) => storageWrites.set(key, value) },
-    register: () => undefined
-  })
-  return { ...context.__ga, calls, sessions, storageWrites }
-}
-
-const MEMBERS = [{ name: 'research', title: '' }, { name: 'builder', title: '' }, { name: 'ops', title: 'The Ops' }]
-
-async function drain(gc, group) {
-  for (let i = 0; i < 200 && (gc.$groupChats.get()[group] || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-}
-
-function feed(gc, group) {
-  return gc.$groupActivity.get()[group]?.events || []
-}
-
-test('a settled turn records the full truthful arc: queued, working, replies and passes, settled', async () => {
-  const gc = load((profile, prompt) => {
-    if (profile === 'research' && !prompt.includes('(you)')) {
-      return 'I looked into it — ship it.'
-    }
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Room', MEMBERS, 'please review')
-  await drain(gc, 'Room')
-
-  const events = feed(gc, 'Room')
-  const kinds = events.map(e => e.kind)
-  assert.equal(kinds[0], 'queued', 'the send lands first')
-  assert.equal(kinds[kinds.length - 1], 'settled', 'the run ends with a settle')
-  assert.equal(kinds.filter(k => k === 'working').length >= 3, true, 'every member on turn shows working')
-  assert.equal(kinds.includes('replied'), true, 'a real reply records replied')
-  assert.equal(kinds.filter(k => k === 'passed').length >= 2, true, 'silent members record passed')
-  const replied = events.find(e => e.kind === 'replied')
-  assert.equal(replied.member, 'research')
-})
-
-test('a failed member turn records failed instead of a phantom reply', async () => {
-  const gc = load(profile => {
-    if (profile === 'builder') {
-      throw new Error('gateway hiccup')
-    }
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Flaky', MEMBERS, 'anyone around?')
-  await drain(gc, 'Flaky')
-
-  const events = feed(gc, 'Flaky')
-  assert.equal(events.some(e => e.kind === 'failed' && e.member === 'builder'), true)
-})
-
-test('a failed member turn preserves and prefers its typed reason', async () => {
-  const gc = load(profile => {
-    if (profile === 'builder') {
-      const error = new Error('generic gateway failure')
-      error.data = { reason: 'provider_auth_or_access' }
-      throw error
-    }
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Typed failure', MEMBERS, 'anyone around?')
-  await drain(gc, 'Typed failure')
-
-  const failed = feed(gc, 'Typed failure').find(e => e.kind === 'failed' && e.member === 'builder')
-  assert.equal(failed.reason, 'provider_auth_or_access')
-  assert.equal(Object.values(gc.$botAttention.get())[0]?.reason, 'provider_auth_or_access')
-})
-
-test('an untyped failed member turn keeps the message-classification fallback', async () => {
-  const gc = load(profile => {
-    if (profile === 'builder') {
-      throw new Error('No LLM provider configured')
-    }
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Untyped failure', MEMBERS, 'anyone around?')
-  await drain(gc, 'Untyped failure')
-
-  const failed = feed(gc, 'Untyped failure').find(e => e.kind === 'failed' && e.member === 'builder')
-  assert.equal(failed.reason, undefined)
-  assert.equal(Object.values(gc.$botAttention.get())[0]?.reason, 'missing_config')
-})
-
-test('a newer send interrupts the previous run and records cancelled in the CURRENT epoch', async () => {
-  const gates = [null, null]
-  const gate = n => {
-    gates[n] = gates[n] || { promise: null, resolve: null }
-    if (!gates[n].promise) {
-      gates[n].promise = new Promise(resolve => {
-        gates[n].resolve = resolve
-      })
-    }
-    return gates[n].promise
-  }
-  const gc = load((profile, prompt, n) => gate(n))
-  const member = [{ name: 'research', title: '' }]
-
-  gc.sendToGroupChat('Busy', member, 'first ask')
-  for (let i = 0; i < 50 && gc.calls.length < 1; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-  gc.sendToGroupChat('Busy', member, 'second ask, supersede')
-  for (let i = 0; i < 50 && gc.calls.length < 2; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  gates[2].resolve('from the new run')
-  await drain(gc, 'Busy')
-  gates[1].resolve('late from the old run')
-  await new Promise(resolve => setImmediate(resolve))
-  await new Promise(resolve => setImmediate(resolve))
-
-  const epoch = (gc.$groupChats.get().Busy || {}).epoch || 0
-  const events = feed(gc, 'Busy')
-  assert.equal(events.some(e => e.kind === 'cancelled'), true, 'the superseded loop reports its own interruption')
-  // The view shows only the current run: every visible event is this epoch.
-  assert.equal(gc.currentGroupActivity('Busy').every(e => (e.epoch || 0) === epoch), true)
-  assert.equal(gc.currentGroupActivity('Busy').some(e => e.kind === 'cancelled'), true)
-})
-
-test('epoch filtering drops events from a superseded run', () => {
-  const gc = load()
-  gc.updateGroupChat('Epoch', r => {
-    r.log = []
-    r.epoch = 5
-    return r
-  })
-  gc.recordGroupActivity('Epoch', { kind: 'queued', member: 'You' })
-  gc.recordGroupActivity('Epoch', { kind: 'working', member: 'research' })
-
-  gc.updateGroupChat('Epoch', r => {
-    r.epoch = 6
-    return r
-  })
-
-  assert.equal(gc.currentGroupActivity('Epoch').length, 0, 'old-run events drop out of view')
-
-  gc.recordGroupActivity('Epoch', { kind: 'working', member: 'research' })
-  const current = gc.currentGroupActivity('Epoch')
-  assert.equal(current.length, 1)
-  assert.equal(current[0].kind, 'working')
-})
-
-test('the feed is bounded and never grows past GROUP_ACTIVITY_LIMIT', () => {
-  const gc = load()
-  gc.updateGroupChat('Cap', r => {
-    r.log = []
-    return r
-  })
-
-  for (let i = 0; i < gc.GROUP_ACTIVITY_LIMIT + 25; i++) {
-    gc.recordGroupActivity('Cap', { kind: 'working', member: 'research' })
-  }
-
-  assert.equal(feed(gc, 'Cap').length, gc.GROUP_ACTIVITY_LIMIT)
-})
-
-test('activity is runtime-only: never persisted, never hydrated', async () => {
-  const gc = load()
-  gc.sendToGroupChat('Volatile', MEMBERS, 'hello')
-  await drain(gc, 'Volatile')
-
-  assert.equal(gc.storageWrites.has('group-activity'), false, 'no activity storage key is ever written')
-  assert.doesNotMatch(pluginSource, /['"]group-activity['"]/, 'the plugin never reads or writes an activity key')
-})
-
-test('labels read like a person wrote them, with settled/cancelled as room-level lines', () => {
-  const gc = load()
-  assert.equal(gc.groupActivityLabel({ kind: 'queued', member: 'You' }), 'You sent a message')
-  assert.equal(gc.groupActivityLabel({ kind: 'replied', member: 'research' }), 'research replied')
-  assert.equal(gc.groupActivityLabel({ kind: 'timed-out', member: 'ops' }), 'ops took too long')
-  assert.equal(gc.groupActivityLabel({ kind: 'cancelled', member: null }), 'turn interrupted by a newer message')
-  assert.equal(gc.groupActivityLabel({ kind: 'settled', member: null }), 'turn settled')
-})
-
-test('source contract: the workspace mounts a quiet, collapsed-by-default disclosure', () => {
-  // Collapsed default — opening is always an explicit user action.
-  assert.match(pluginSource, /const \[activityOpen, setActivityOpen\] = useState\(false\)/)
-  // Accessible disclosure pattern.
-  assert.match(pluginSource, /'aria-expanded': activityOpen/)
-  assert.match(pluginSource, /'aria-controls': `group-activity:\$\{group\}`/)
-  // The panel body never steals focus and never auto-scrolls.
-  const panel = pluginSource.slice(pluginSource.indexOf('// Activity disclosure:'), pluginSource.indexOf('const submit = () => {'))
-  assert.doesNotMatch(panel, /autoFocus/)
-  assert.doesNotMatch(panel, /autoScroll|scrollIntoView/)
-  // Truthful event vocabulary is wired.
-  assert.match(pluginSource, /'timed-out': 'took too long'/)
-  assert.match(pluginSource, /cancelled: 'turn interrupted by a newer message'/)
-  // The panel sits inside the workspace between the header and the log.
-  const workspace = pluginSource.slice(pluginSource.indexOf('function GroupChatWorkspace('), pluginSource.indexOf('function GroupChatMainView('))
-  assert.match(workspace, /header,\s*\n\s*activityPanel,/s)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-chat-attachments.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-chat-attachments.test.mjs
deleted file mode 100644
index 93d251623908..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-chat-attachments.test.mjs
+++ /dev/null
@@ -1,266 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** Harness mirroring group-chat.test.mjs, extended to record image.attach_bytes
- *  calls so attachment staging order and fan-out are assertable. */
-function load(turnScript) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const calls = []
-  const attaches = []
-  const sessions = new Map()
-  const runtimeToStored = new Map()
-  const titleToStored = new Map()
-  let sessionSequence = 0
-
-  const resolveSession = (profile, target) => {
-    const stored = runtimeToStored.get(target) || (sessions.has(target) ? target : titleToStored.get(`${profile}::${target}`))
-    return stored ? sessions.get(stored) : null
-  }
-  const context = {
-    atom,
-    setTimeout: fn => {
-      fn()
-      return 0
-    },
-    clearTimeout: () => undefined,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: async (method, params) => {
-        if (method === 'session.create') {
-          sessionSequence += 1
-          const stored = `sid-${params.profile}-${sessionSequence}`
-          const runtime = `rt-${params.profile}-${sessionSequence}`
-          const session = { stored, runtime, profile: params.profile, title: params.title, messages: [] }
-          sessions.set(stored, session)
-          runtimeToStored.set(runtime, stored)
-          titleToStored.set(`${params.profile}::${params.title}`, stored)
-          return { session_id: runtime, stored_session_id: stored, message_count: 0, messages: [] }
-        }
-        if (method === 'session.resume') {
-          const session = resolveSession(params.profile, params.session_id)
-          if (!session) {
-            // Shaped like the real gateway's JsonRpcGatewayError (`.code`,
-            // apps/shared/src/json-rpc-gateway.ts) so ensureGroupChatSession's
-            // fail-closed `.code !== 4007` check sees the same "genuinely
-            // not found" signal production does.
-            const err = new Error(`session not found: ${params.session_id}`)
-            err.code = 4007
-            throw err
-          }
-          return {
-            session_id: session.runtime,
-            session_key: session.stored,
-            message_count: session.messages.length,
-            messages: [...session.messages],
-            inflight: false,
-            running: false
-          }
-        }
-        if (method === 'image.attach_bytes' || method === 'pdf.attach' || method === 'file.attach') {
-          const session = resolveSession(null, params.session_id)
-          attaches.push({
-            method,
-            profile: session ? session.profile : null,
-            runtime: params.session_id,
-            filename: params.filename || params.name,
-            data: params.content_base64 || params.data_url,
-            order: calls.length // how many prompt.submits happened before this attach
-          })
-          if (method === 'file.attach') {
-            return { attached: true, ref_text: `@file:attachments/${params.name || 'attachment'}` }
-          }
-          return { attached: true }
-        }
-        if (method === 'prompt.submit') {
-          const session = resolveSession(null, params.session_id)
-          if (!session) {
-            throw new Error(`runtime session not found: ${params.session_id}`)
-          }
-          session.messages.push({ role: 'user', content: params.text })
-          calls.push({ profile: session.profile, prompt: params.text, runtime: session.runtime })
-          const reply = turnScript(session.profile, params.text, calls.length, session)
-          session.messages.push({ role: 'assistant', content: reply })
-          return {}
-        }
-        return {}
-      },
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } },
-      notify: () => undefined,
-      notifyError: () => undefined
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__gca = { sendToGroupChat, formatGroupChatLine, $groupChats };\n'
-    )
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  context.plugin.register({
-    storage: { get: () => null, set: () => undefined },
-    register: () => undefined
-  })
-  return { ...context.__gca, calls, attaches, sessions }
-}
-
-const MEMBERS = [{ name: 'research', title: '' }, { name: 'builder', title: '' }]
-const IMG = { name: 'screenshot.png', data: 'data:image/png;base64,iVBORw0KGgo=' }
-
-async function drain(gc, group) {
-  for (let i = 0; i < 200 && (gc.$groupChats.get()[group] || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-}
-
-test('attachments are staged into EVERY responding member session before its submit', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Vision', MEMBERS, 'what does this show?', null, [IMG])
-  await drain(gc, 'Vision')
-
-  // Both members got the image, on their own per-group sessions.
-  assert.equal(gc.attaches.length, 2)
-  assert.deepEqual(gc.attaches.map(a => a.profile).sort(), ['builder', 'research'])
-  for (const attach of gc.attaches) {
-    assert.equal(attach.filename, 'screenshot.png')
-    assert.equal(attach.data, IMG.data)
-  }
-  // Each attach landed before that member's prompt.submit: the first attach
-  // happens before any submit, the second before the second submit.
-  assert.equal(gc.attaches[0].order, 0)
-  assert.ok(gc.attaches[1].order <= 1)
-  assert.equal(gc.calls.length, 2)
-})
-
-test('mention routing scopes attachments: only the mentioned member receives the image', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Scoped', MEMBERS, '@builder look at this', null, [IMG])
-  await drain(gc, 'Scoped')
-
-  assert.deepEqual(gc.attaches.map(a => a.profile), ['builder'])
-})
-
-test('image-only send works and the room entry carries the attachment', async () => {
-  const gc = load(() => '(pass)')
-
-  const minted = gc.sendToGroupChat('Silent', MEMBERS, '', null, [IMG])
-  await drain(gc, 'Silent')
-
-  assert.ok(minted)
-  const log = gc.$groupChats.get().Silent.log
-  assert.equal(log.length, 1)
-  assert.equal(log[0].images.length, 1)
-  assert.equal(log[0].images[0].name, 'screenshot.png')
-  // Members still got prompted (with the image staged).
-  assert.equal(gc.attaches.length, 2)
-  assert.equal(gc.calls.length, 2)
-})
-
-test('a text-only send stages nothing and old entries never re-attach on later turns', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Plain', MEMBERS, 'with image', null, [IMG])
-  await drain(gc, 'Plain')
-  const afterFirst = gc.attaches.length
-  assert.equal(afterFirst, 2)
-
-  // Second, text-only send: the image already sits behind every member's
-  // watermark, so no new attach calls may happen.
-  gc.sendToGroupChat('Plain', MEMBERS, 'plain follow-up')
-  await drain(gc, 'Plain')
-  assert.equal(gc.attaches.length, afterFirst)
-})
-
-test('formatGroupChatLine names attachments for user and member entries', () => {
-  const gc = load(() => '(pass)')
-
-  const userLine = gc.formatGroupChatLine(
-    { from: { kind: 'user', name: 'You' }, text: 'see attached', images: [IMG] },
-    'research'
-  )
-  assert.equal(userLine, 'You (user): see attached [attached image: screenshot.png]')
-
-  const noImages = gc.formatGroupChatLine({ from: { kind: 'user', name: 'You' }, text: 'plain' }, 'research')
-  assert.equal(noImages, 'You (user): plain')
-
-  const memberLine = gc.formatGroupChatLine(
-    { from: { kind: 'member', name: 'builder' }, text: 'made this', images: [{ data: 'data:image/png;base64,x' }] },
-    'research'
-  )
-  assert.equal(memberLine, 'builder: made this [attached image: image]')
-})
-
-test('an invalid attachment is skipped and the member turn still runs text-only', async () => {
-  const gc = load(() => '(pass)')
-
-  // runGroupChatMemberTurn skips entries without a string data field.
-  gc.sendToGroupChat('Degraded', MEMBERS, 'look', null, [{ name: 'bad', data: null }])
-  await drain(gc, 'Degraded')
-
-  assert.equal(gc.attaches.length, 0) // invalid image skipped, no attach attempted
-  assert.equal(gc.calls.length, 2) // both turns still ran
-})
-
-const PDF = { name: 'spec.pdf', data: 'data:application/pdf;base64,JVBERi0=', kind: 'pdf' }
-const DOC = { name: 'notes.txt', data: 'data:text/plain;base64,aGVsbG8=', kind: 'file' }
-
-test('PDFs route through pdf.attach and files through file.attach, per member', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Mixed', MEMBERS, 'review these', null, [IMG, PDF, DOC])
-  await drain(gc, 'Mixed')
-
-  // 3 attachments × 2 members, each via its own RPC.
-  assert.equal(gc.attaches.length, 6)
-  const byMethod = {}
-  for (const a of gc.attaches) {
-    byMethod[a.method] = (byMethod[a.method] || 0) + 1
-  }
-  assert.deepEqual(byMethod, { 'image.attach_bytes': 2, 'pdf.attach': 2, 'file.attach': 2 })
-
-  const pdfAttach = gc.attaches.find(a => a.method === 'pdf.attach')
-  assert.equal(pdfAttach.filename, 'spec.pdf')
-  assert.equal(pdfAttach.data, PDF.data)
-})
-
-test('file.attach ref_text is appended to the member turn prompt', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Refs', MEMBERS, 'read the notes', null, [DOC])
-  await drain(gc, 'Refs')
-
-  assert.equal(gc.calls.length, 2)
-  for (const call of gc.calls) {
-    assert.ok(call.prompt.includes('Attached files staged in your session workspace:'), 'prompt carries the staging note')
-    assert.ok(call.prompt.includes('notes.txt → @file:attachments/notes.txt'), 'prompt carries the @file: ref')
-  }
-})
-
-test('formatGroupChatLine labels PDFs and files distinctly', () => {
-  const gc = load(() => '(pass)')
-
-  const line = gc.formatGroupChatLine(
-    { from: { kind: 'user', name: 'You' }, text: 'here', images: [PDF, DOC, IMG] },
-    'research'
-  )
-  assert.equal(
-    line,
-    'You (user): here [attached PDF: spec.pdf] [attached file: notes.txt] [attached image: screenshot.png]'
-  )
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-chat-empty-sentinel.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-chat-empty-sentinel.test.mjs
deleted file mode 100644
index 80dcdfa67abb..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-chat-empty-sentinel.test.mjs
+++ /dev/null
@@ -1,242 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** Load the plugin in a vm with a scripted cli.exec so member turns are
- *  deterministic. `turnScript(profile, prompt)` returns the member's reply
- *  text (or throws to simulate a failed turn). */
-function load(turnScript, { busyUntilResumeCall, clarifyUntilResumeCall, approvalUntilResumeCall, conflictOnce = false, deferredTimers = false } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => {
-      if (process.env.TRACE_ATOM && value && typeof value === 'object' && value.Grind) {
-        console.error('ATOM SET Grind stranded=', JSON.stringify(value.Grind.stranded), new Error().stack.split('\n').slice(2,5).join(' | '))
-      }
-      values.set(slot, value)
-    } }
-    values.set(slot, initial)
-    return slot
-  }
-  const calls = []
-  const clarifyResponds = []
-  const approvalResponds = []
-  const requests = []
-  const sessions = new Map()
-  const runtimeToStored = new Map()
-  const titleToStored = new Map()
-  const sharedUiMeta = {}
-  const uiMetaRevisions = {}
-  let sessionSequence = 0
-  const resumeCallCounts = new Map()
-  let injectedConflict = false
-
-  const resolveSession = (profile, target) => {
-    const stored = runtimeToStored.get(target) || (sessions.has(target) ? target : titleToStored.get(`${profile}::${target}`))
-    return stored ? sessions.get(stored) : null
-  }
-  const context = {
-    atom,
-    setTimeout: fn => {
-      if (deferredTimers) {
-        setImmediate(fn)
-        return 1
-      }
-      fn()
-      return 0
-    },
-    clearTimeout: () => undefined,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: async (method, params) => {
-        requests.push({ method, params })
-        if (method === 'profiles.list') {
-          return {
-            profiles: [
-              {
-                name: 'default',
-                ui_meta: { ...sharedUiMeta },
-                ui_meta_revisions: { ...uiMetaRevisions }
-              }
-            ]
-          }
-        }
-        if (method === 'profiles.configure') {
-          if (conflictOnce && !injectedConflict) {
-            injectedConflict = true
-            sharedUiMeta['hermes-bots-groups'] = {
-              version: 2,
-              rooms: {
-                Shared: {
-                  revision: 1,
-                  log: [{ id: 'writer-a:1', from: { kind: 'user', name: 'You' }, text: 'alpha', at: 1 }],
-                  members: [{ name: 'alpha' }]
-                }
-              }
-            }
-            uiMetaRevisions['hermes-bots-groups'] = 1
-            return {
-              applied: {
-                ui_meta: false,
-                ui_meta_conflicts: { 'hermes-bots-groups': { expected: 0, actual: 1 } },
-                ui_meta_revisions: { 'hermes-bots-groups': 1 }
-              }
-            }
-          }
-          const expected = params.ui_meta_expected_revisions || null
-          if (expected) {
-            for (const key of Object.keys(params.ui_meta || {})) {
-              if ((uiMetaRevisions[key] || 0) !== expected[key]) {
-                return {
-                  applied: {
-                    ui_meta: false,
-                    ui_meta_conflicts: {
-                      [key]: { expected: expected[key], actual: uiMetaRevisions[key] || 0 }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          for (const [key, value] of Object.entries(params.ui_meta || {})) {
-            if (value === null) {
-              delete sharedUiMeta[key]
-            } else {
-              sharedUiMeta[key] = value
-            }
-            uiMetaRevisions[key] = (uiMetaRevisions[key] || 0) + 1
-          }
-          return { applied: { ui_meta: true, ui_meta_revisions: { ...uiMetaRevisions } } }
-        }
-        if (method === 'session.create') {
-          sessionSequence += 1
-          const stored = `sid-${params.profile}-${sessionSequence}`
-          const runtime = `rt-${params.profile}-${sessionSequence}`
-          const session = { stored, runtime, profile: params.profile, title: params.title, messages: [] }
-          sessions.set(stored, session)
-          runtimeToStored.set(runtime, stored)
-          titleToStored.set(`${params.profile}::${params.title}`, stored)
-          return { session_id: runtime, stored_session_id: stored, message_count: 0, messages: [] }
-        }
-        if (method === 'session.resume') {
-          const session = resolveSession(params.profile, params.session_id)
-          if (!session) {
-            const err = new Error(`session not found: ${params.session_id}`)
-            err.code = 4007
-            throw err
-          }
-          const profile = params.profile
-          const seen = (resumeCallCounts.get(profile) || 0) + 1
-          resumeCallCounts.set(profile, seen)
-          const limit = busyUntilResumeCall && busyUntilResumeCall[profile]
-          const busy = Boolean(limit && seen <= limit)
-          const clarify = clarifyUntilResumeCall && clarifyUntilResumeCall[profile]
-          const pendingClarify = clarify && seen <= clarify.until ? clarify.payload : null
-          const approval = approvalUntilResumeCall && approvalUntilResumeCall[profile]
-          const pendingApproval = approval && seen <= approval.until ? approval.payload : null
-          return {
-            session_id: session.runtime,
-            session_key: session.stored,
-            message_count: session.messages.length,
-            messages: [...session.messages],
-            inflight: busy,
-            running: busy,
-            ...(pendingClarify ? { pending_clarify: pendingClarify } : {}),
-            ...(pendingApproval ? { pending_approval: pendingApproval } : {})
-          }
-        }
-        if (method === 'prompt.submit') {
-          const session = resolveSession(null, params.session_id)
-          if (!session) {
-            throw new Error(`runtime session not found: ${params.session_id}`)
-          }
-          session.messages.push({ role: 'user', content: params.text })
-          calls.push({
-            profile: session.profile,
-            prompt: params.text,
-            runtime: session.runtime,
-            stored: session.stored,
-            title: session.title
-          })
-          const reply = turnScript(session.profile, params.text, calls.length, session)
-          session.messages.push({ role: 'assistant', content: reply })
-          return {}
-        }
-        if (method === 'clarify.respond') {
-          clarifyResponds.push({ ...params })
-          return { ok: true }
-        }
-        if (method === 'approval.respond') {
-          approvalResponds.push({ ...params })
-          return { resolved: true }
-        }
-        return {}
-      },
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } },
-      notify: () => undefined,
-      notifyError: () => undefined
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__gc = { sendToGroupChat, runGroupChatRounds, harvestStrandedGroupReply, resolveGroupResponders, parseGroupChatMentions, rotateGroupSpeakers, isGroupPassText, formatGroupChatLine, groupSpeakerLabel, buildGroupChatTurnPrompt, trimGroupChatLog, groupChatSyncSnapshot, groupChatGatewayJsonSize, mergeGroupChatSyncSnapshots, mergeRemoteGroupChatSnapshotIntoRooms, scheduleGroupChatServerSync, disbandGroupChat, renameGroupChat, updateGroupChat, durableGroupChatRooms, persistGroupChatRooms, ensureGroupChatSession, uniqueGroupChatName, liveGroupChatNames, groupChatNames, openGroupChat, closeGroupChatMainTab, shouldRenderGroupChatInPane, syncGroupClarify, clearGroupClarify, answerGroupClarify, $groupClarify, $groupChats, $groupNeedsYou, $groupChatWorkspace, $groupMainTabsRev, $botMeta, $lastRoster, GROUP_CHAT_MAX_ROUNDS, GROUP_CHAT_MAX_MESSAGES };\n'
-    )
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  const storageWrites = new Map()
-  context.plugin.register({
-    storage: { get: () => null, set: (key, value) => storageWrites.set(key, value) },
-    register: () => undefined
-  })
-  return { ...context.__gc, approvalResponds, calls, clarifyResponds, host: context.host, requests, sessions, storageWrites, sharedUiMeta, uiMetaRevisions }
-}
-
-function roomLog(gc, group) {
-  return (gc.$groupChats.get()[group] || { log: [] }).log
-}
-
-const FRIENDLY = '⚠️ The model returned no response after processing tool results. This can happen with some models — try again or rephrase your question.'
-
-async function drain(gc, group) {
-  for (let i = 0; i < 200 && (gc.$groupChats.get()[group] || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-}
-
-test('(empty) sentinel: a "(empty)" member reply is converted like the gateway, never appended raw', async () => {
-  const gc = load(profile => {
-    if (profile === 'research') return '(empty)'
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Sentinel', [{ name: 'research', title: '' }], '@research thoughts?')
-  await drain(gc, 'Sentinel')
-
-  const memberEntries = roomLog(gc, 'Sentinel').filter(e => e.from.kind === 'member')
-  assert.ok(memberEntries.length === 1, `expected exactly 1 member entry, got ${memberEntries.length}`)
-  assert.equal(memberEntries[0].text, FRIENDLY)
-  assert.equal(memberEntries[0].text.includes('(empty)'), false)
-})
-
-test('(empty) sentinel: normal replies are untouched', async () => {
-  const gc = load(profile => {
-    if (profile === 'research') return 'I am not empty.'
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Sentinel2', [{ name: 'research', title: '' }], '@research hi')
-  await drain(gc, 'Sentinel2')
-
-  const memberEntries = roomLog(gc, 'Sentinel2').filter(e => e.from.kind === 'member')
-  assert.equal(memberEntries.length, 1)
-  assert.equal(memberEntries[0].text, 'I am not empty.')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-chat-identity-edit.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-chat-identity-edit.test.mjs
deleted file mode 100644
index 775c4ae536c1..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-chat-identity-edit.test.mjs
+++ /dev/null
@@ -1,52 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// Group chats have an editable identity: a name (renameable after creation)
-// and a room picture (settable during creation and later via Group settings).
-// Source-contract style, like the sibling group-chat tests.
-
-test('source contract: creation dialog offers a room picture', () => {
-  // Shared picture controls (upload / generate / remove) mount in the create
-  // dialog, and a chosen image lands on the freshly created room record.
-  assert.match(pluginSource, /function GroupImageControls\(/)
-  assert.match(pluginSource, /if \(image\) \{\s*\n\s*room\.image = image/)
-})
-
-test('source contract: settings dialog edits name and picture after creation', () => {
-  assert.match(pluginSource, /function GroupChatSettingsDialog\(/)
-  assert.match(pluginSource, /function renameGroupChat\(/)
-  assert.match(pluginSource, /function setGroupChatImage\(/)
-  // The room header exposes the entry point.
-  assert.match(pluginSource, /Group settings — rename \$\{group\} or set a room picture/)
-})
-
-test('source contract: rename re-keys the room AND local memberships, keeps sessions', () => {
-  // The room record moves wholesale under the new key (sessions included, so
-  // members keep resuming their per-group sessions by stored sid).
-  assert.match(pluginSource, /const room = all\[oldName\][\s\S]{0,320}?delete all\[oldName\]/)
-  // Window-local composer drafts follow the immutable room identity too.
-  assert.match(pluginSource, /migrateGroupComposerDraft\(groupComposerDraftKey\(oldName, room\), groupComposerDraftKey\(next, room\)\)/)
-  // Local members' canonical groups lists swap old → new via ui_meta.
-  assert.match(pluginSource, /botGroups\(meta\)\.map\(g => \(g === oldName \? next : g\)\)/)
-  // Collisions are rejected, not silently suffixed — rename is explicit intent.
-  assert.match(pluginSource, /taken\.delete\(oldName\)/)
-})
-
-test('source contract: room picture persists and hydrates with the room record', () => {
-  // Durable writes carry image; hydration restores only a real string.
-  assert.match(pluginSource, /image: room\.image \|\| null/)
-  assert.match(pluginSource, /image: typeof room\.image === 'string' && room\.image \? room\.image : null/)
-})
-
-test('source contract: room picture shows in the roster row and room header', () => {
-  // Roster row: one room picture wins over a generic room icon when set.
-  const rowSource = pluginSource.slice(pluginSource.indexOf('function GroupRow('), pluginSource.indexOf('function RosterSectionHeader('))
-  assert.match(rowSource, /room\.image\s*\n\s*\? jsx\('img', \{/)
-  assert.match(rowSource, /name: 'organization'/)
-  assert.doesNotMatch(rowSource, /members\.slice\([^)]*\)\.map/)
-  // Header: picture leads the title.
-  assert.match(pluginSource, /Room picture \(set via Group settings\) leads the title when present/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-chat.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-chat.test.mjs
deleted file mode 100644
index e0bfa85836f3..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-chat.test.mjs
+++ /dev/null
@@ -1,2129 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** Load the plugin in a vm with a scripted cli.exec so member turns are
- *  deterministic. `turnScript(profile, prompt)` returns the member's reply
- *  text (or throws to simulate a failed turn). */
-function load(turnScript, { busyUntilResumeCall, clarifyUntilResumeCall, approvalUntilResumeCall, conflictOnce = false, deferredTimers = false } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => {
-      if (process.env.TRACE_ATOM && value && typeof value === 'object' && value.Grind) {
-        console.error('ATOM SET Grind stranded=', JSON.stringify(value.Grind.stranded), new Error().stack.split('\n').slice(2,5).join(' | '))
-      }
-      values.set(slot, value)
-    } }
-    values.set(slot, initial)
-    return slot
-  }
-  const calls = []
-  const clarifyResponds = []
-  const approvalResponds = []
-  const requests = []
-  const sessions = new Map()
-  const runtimeToStored = new Map()
-  const titleToStored = new Map()
-  const sharedUiMeta = {}
-  const uiMetaRevisions = {}
-  let sessionSequence = 0
-  // busyUntilResumeCall[profile] = N: this profile's session.resume reports
-  // inflight/running for its first N calls, then flips to done — simulating
-  // a turn that is genuinely still running when harvested, without an
-  // unbounded real-time wait if a caller polls it (used to exercise the
-  // stranded/busy-responder guard).
-  const resumeCallCounts = new Map()
-  let injectedConflict = false
-
-  const resolveSession = (profile, target) => {
-    const stored = runtimeToStored.get(target) || (sessions.has(target) ? target : titleToStored.get(`${profile}::${target}`))
-    return stored ? sessions.get(stored) : null
-  }
-  const context = {
-    atom,
-    setTimeout: fn => {
-      if (deferredTimers) {
-        setImmediate(fn)
-        return 1
-      }
-      fn()
-      return 0
-    },
-    clearTimeout: () => undefined,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: async (method, params) => {
-        requests.push({ method, params })
-        if (method === 'profiles.list') {
-          return {
-            profiles: [
-              {
-                name: 'default',
-                ui_meta: { ...sharedUiMeta },
-                ui_meta_revisions: { ...uiMetaRevisions }
-              }
-            ]
-          }
-        }
-        if (method === 'profiles.configure') {
-          if (conflictOnce && !injectedConflict) {
-            injectedConflict = true
-            sharedUiMeta['hermes-bots-groups'] = {
-              version: 2,
-              rooms: {
-                Shared: {
-                  revision: 1,
-                  log: [{ id: 'writer-a:1', from: { kind: 'user', name: 'You' }, text: 'alpha', at: 1 }],
-                  members: [{ name: 'alpha' }]
-                }
-              }
-            }
-            uiMetaRevisions['hermes-bots-groups'] = 1
-            return {
-              applied: {
-                ui_meta: false,
-                ui_meta_conflicts: { 'hermes-bots-groups': { expected: 0, actual: 1 } },
-                ui_meta_revisions: { 'hermes-bots-groups': 1 }
-              }
-            }
-          }
-          const expected = params.ui_meta_expected_revisions || null
-          if (expected) {
-            for (const key of Object.keys(params.ui_meta || {})) {
-              if ((uiMetaRevisions[key] || 0) !== expected[key]) {
-                return {
-                  applied: {
-                    ui_meta: false,
-                    ui_meta_conflicts: {
-                      [key]: { expected: expected[key], actual: uiMetaRevisions[key] || 0 }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          for (const [key, value] of Object.entries(params.ui_meta || {})) {
-            if (value === null) {
-              delete sharedUiMeta[key]
-            } else {
-              sharedUiMeta[key] = value
-            }
-            uiMetaRevisions[key] = (uiMetaRevisions[key] || 0) + 1
-          }
-          return { applied: { ui_meta: true, ui_meta_revisions: { ...uiMetaRevisions } } }
-        }
-        if (method === 'session.create') {
-          sessionSequence += 1
-          const stored = `sid-${params.profile}-${sessionSequence}`
-          const runtime = `rt-${params.profile}-${sessionSequence}`
-          const session = { stored, runtime, profile: params.profile, title: params.title, messages: [] }
-          sessions.set(stored, session)
-          runtimeToStored.set(runtime, stored)
-          titleToStored.set(`${params.profile}::${params.title}`, stored)
-          return { session_id: runtime, stored_session_id: stored, message_count: 0, messages: [] }
-        }
-        if (method === 'session.resume') {
-          const session = resolveSession(params.profile, params.session_id)
-          if (!session) {
-            // Shaped like the real gateway's JsonRpcGatewayError (a `.code`
-            // property, per apps/shared/src/json-rpc-gateway.ts) so
-            // ensureGroupChatSession's fail-closed `.code !== 4007` check
-            // exercises the same branch production sees. 4007 mirrors
-            // session.resume's own "session not found" JSON-RPC error code
-            // (tui_gateway/methods_session.py).
-            const err = new Error(`session not found: ${params.session_id}`)
-            err.code = 4007
-            throw err
-          }
-          const profile = params.profile
-          const seen = (resumeCallCounts.get(profile) || 0) + 1
-          resumeCallCounts.set(profile, seen)
-          const limit = busyUntilResumeCall && busyUntilResumeCall[profile]
-          const busy = Boolean(limit && seen <= limit)
-          // clarifyUntilResumeCall[profile] = {payload, until}: the resume
-          // snapshot carries pending_clarify for the first `until` calls —
-          // simulating a member blocked on its clarify tool (#90694).
-          const clarify = clarifyUntilResumeCall && clarifyUntilResumeCall[profile]
-          const pendingClarify = clarify && seen <= clarify.until ? clarify.payload : null
-          // Same window shape for pending command approvals (#90694 class).
-          const approval = approvalUntilResumeCall && approvalUntilResumeCall[profile]
-          const pendingApproval = approval && seen <= approval.until ? approval.payload : null
-          return {
-            session_id: session.runtime,
-            session_key: session.stored,
-            message_count: session.messages.length,
-            messages: [...session.messages],
-            inflight: busy,
-            running: busy,
-            ...(pendingClarify ? { pending_clarify: pendingClarify } : {}),
-            ...(pendingApproval ? { pending_approval: pendingApproval } : {})
-          }
-        }
-        if (method === 'prompt.submit') {
-          const session = resolveSession(null, params.session_id)
-          if (!session) {
-            throw new Error(`runtime session not found: ${params.session_id}`)
-          }
-          session.messages.push({ role: 'user', content: params.text })
-          calls.push({
-            profile: session.profile,
-            prompt: params.text,
-            runtime: session.runtime,
-            stored: session.stored,
-            title: session.title
-          })
-          const reply = turnScript(session.profile, params.text, calls.length, session)
-          session.messages.push({ role: 'assistant', content: reply })
-          return {}
-        }
-        if (method === 'clarify.respond') {
-          clarifyResponds.push({ ...params })
-          return { ok: true }
-        }
-        if (method === 'approval.respond') {
-          approvalResponds.push({ ...params })
-          return { resolved: true }
-        }
-        return {}
-      },
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } },
-      notify: () => undefined,
-      notifyError: () => undefined
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__gc = { sendToGroupChat, runGroupChatRounds, harvestStrandedGroupReply, resolveGroupResponders, parseGroupChatMentions, rotateGroupSpeakers, isGroupPassText, formatGroupChatLine, groupSpeakerLabel, buildGroupChatTurnPrompt, trimGroupChatLog, groupChatSyncSnapshot, groupChatGatewayJsonSize, mergeGroupChatSyncSnapshots, mergeRemoteGroupChatSnapshotIntoRooms, scheduleGroupChatServerSync, disbandGroupChat, renameGroupChat, updateGroupChat, durableGroupChatRooms, persistGroupChatRooms, ensureGroupChatSession, uniqueGroupChatName, liveGroupChatNames, groupChatNames, openGroupChat, closeGroupChatMainTab, shouldRenderGroupChatInPane, syncGroupClarify, clearGroupClarify, answerGroupClarify, $groupClarify, $groupChats, $groupNeedsYou, $groupChatWorkspace, $groupMainTabsRev, $botMeta, $lastRoster, GROUP_CHAT_MAX_ROUNDS, GROUP_CHAT_MAX_MESSAGES };\n'
-    )
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  const storageWrites = new Map()
-  context.plugin.register({
-    storage: { get: () => null, set: (key, value) => storageWrites.set(key, value) },
-    register: () => undefined
-  })
-  return { ...context.__gc, approvalResponds, calls, clarifyResponds, host: context.host, requests, sessions, storageWrites, sharedUiMeta, uiMetaRevisions }
-}
-
-const MEMBERS = [{ name: 'research', title: '' }, { name: 'builder', title: '' }, { name: 'ops', title: 'The Ops' }]
-
-function roomLog(gc, group) {
-  return (gc.$groupChats.get()[group] || { log: [] }).log
-}
-
-test('pass detection: (pass), pass, pass., empty are silence; real text is not', () => {
-  const gc = load(() => '(pass)')
-  assert.equal(gc.isGroupPassText('(pass)'), true)
-  assert.equal(gc.isGroupPassText('pass'), true)
-  assert.equal(gc.isGroupPassText('Pass.'), true)
-  assert.equal(gc.isGroupPassText('  '), true)
-  assert.equal(gc.isGroupPassText('I will pass this to ops'), false)
-})
-
-test('mention routing: only @-mentioned members respond; @everyone or none = all', () => {
-  const gc = load(() => '(pass)')
-  const log = [{ from: { kind: 'user', name: 'You' }, text: '@builder take this one', at: 1 }]
-  const one = gc.resolveGroupResponders(log, MEMBERS)
-  assert.equal(JSON.stringify(one.map(m => m.name)), JSON.stringify(['builder']))
-
-  const all = gc.resolveGroupResponders([{ from: { kind: 'user', name: 'You' }, text: 'hello team', at: 1 }], MEMBERS)
-  assert.equal(all.length, 3)
-
-  const everyone = gc.resolveGroupResponders(
-    [{ from: { kind: 'user', name: 'You' }, text: '@everyone standup', at: 1 }],
-    MEMBERS
-  )
-  assert.equal(everyone.length, 3)
-})
-
-test('mention routing: display titles resolve to the member and @user never matches a bot', () => {
-  const gc = load(() => '(pass)')
-  const parsed = gc.parseGroupChatMentions('@theops please check, then ping @user', MEMBERS)
-  assert.equal(parsed.mentioned.has('ops'), true)
-  assert.equal(parsed.mentioned.size, 1)
-})
-
-test('a member @-mentioned by another bot joins the NEXT round', async () => {
-  const gc = load((profile, prompt) => {
-    if (profile === 'research' && !prompt.includes('(you)')) {
-      return 'Interesting — @builder should own this.'
-    }
-    if (profile === 'builder') {
-      return 'On it. OWNER: @builder.'
-    }
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Core', [{ name: 'research', title: '' }, { name: 'builder', title: '' }], '@research thoughts?')
-  await new Promise(resolve => setTimeout(resolve, 0))
-  await new Promise(resolve => setImmediate(resolve))
-  // Drain the async loop: poll until running flips false.
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Core || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const texts = roomLog(gc, 'Core').map(e => `${e.from.name}: ${e.text}`)
-  assert.equal(texts.some(t => t.startsWith('research:')), true)
-  assert.equal(texts.some(t => t.startsWith('builder: On it')), true)
-})
-
-test('settle: everyone passing ends the room turn with only the user message logged', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Quiet', MEMBERS, 'fyi, deploy went out')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Quiet || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const log = roomLog(gc, 'Quiet')
-  assert.equal(log.length, 1)
-  assert.equal(log[0].from.kind, 'user')
-  // Every member took exactly one turn (round 1), then the settle exit fired.
-  assert.equal(gc.calls.length, 3)
-})
-
-test('hard caps: chatty members stop at GROUP_CHAT_MAX_MESSAGES total', async () => {
-  const gc = load((profile, prompt, n) => `message ${n} — @everyone keep going`)
-
-  gc.sendToGroupChat('Loud', MEMBERS, 'go wild')
-  for (let i = 0; i < 400 && (gc.$groupChats.get().Loud || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const memberMessages = roomLog(gc, 'Loud').filter(e => e.from.kind === 'member')
-  assert.ok(memberMessages.length <= gc.GROUP_CHAT_MAX_MESSAGES, `posted ${memberMessages.length}`)
-})
-
-test('failed member turn is a pass, not a room error', async () => {
-  const gc = load(profile => {
-    if (profile === 'builder') {
-      throw new Error('gateway hiccup')
-    }
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Flaky', MEMBERS, 'anyone around?')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Flaky || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const log = roomLog(gc, 'Flaky')
-  assert.equal(log.length, 1) // just the user message; no error entries
-})
-
-test('delta injection: a second user send only feeds members the NEW messages', async () => {
-  const prompts = []
-  const gc = load((profile, prompt) => {
-    prompts.push({ profile, prompt })
-    return '(pass)'
-  })
-
-  gc.sendToGroupChat('Delta', [{ name: 'research', title: '' }], 'first message')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Delta || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-  const firstCount = prompts.length
-  gc.sendToGroupChat('Delta', [{ name: 'research', title: '' }], 'second message')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Delta || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const second = prompts.slice(firstCount).find(p => p.prompt.includes('second message'))
-  assert.ok(second, 'second turn ran')
-  assert.equal(second.prompt.includes('first message'), false, 'first message was already seen — not re-injected')
-})
-
-test('concurrent groups sharing one member keep sessions, deltas, and context isolated', async () => {
-  const gc = load(() => '(pass)')
-  const sharedMember = [{ name: 'research', title: '' }]
-
-  // Start both rooms without waiting for either drive to finish.
-  gc.sendToGroupChat('Alpha', sharedMember, 'ALPHA_ONLY_1')
-  gc.sendToGroupChat('Beta', sharedMember, 'BETA_ONLY_1')
-  for (let i = 0; i < 400; i++) {
-    const rooms = gc.$groupChats.get()
-    if (!rooms.Alpha?.running && !rooms.Beta?.running) {
-      break
-    }
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const alphaFirst = gc.calls.find(call => call.title === 'Group: Alpha')
-  const betaFirst = gc.calls.find(call => call.title === 'Group: Beta')
-  assert.ok(alphaFirst && betaFirst, 'the shared member took one turn in each room')
-  assert.notEqual(alphaFirst.stored, betaFirst.stored, 'each room owns a distinct stored session')
-  assert.notEqual(alphaFirst.runtime, betaFirst.runtime, 'each room owns a distinct runtime session')
-  assert.equal(alphaFirst.prompt.includes('ALPHA_ONLY_1'), true)
-  assert.equal(alphaFirst.prompt.includes('BETA_ONLY_1'), false)
-  assert.equal(betaFirst.prompt.includes('BETA_ONLY_1'), true)
-  assert.equal(betaFirst.prompt.includes('ALPHA_ONLY_1'), false)
-
-  const roomsAfterFirst = gc.$groupChats.get()
-  assert.equal(roomsAfterFirst.Alpha.sessions.research, alphaFirst.stored)
-  assert.equal(roomsAfterFirst.Beta.sessions.research, betaFirst.stored)
-
-  // Interleave a second pair. Each room resumes its own session and receives
-  // only its unseen room delta, never the sibling room's messages.
-  const firstCallCount = gc.calls.length
-  gc.sendToGroupChat('Alpha', sharedMember, 'ALPHA_ONLY_2')
-  gc.sendToGroupChat('Beta', sharedMember, 'BETA_ONLY_2')
-  for (let i = 0; i < 400; i++) {
-    const rooms = gc.$groupChats.get()
-    if (!rooms.Alpha?.running && !rooms.Beta?.running) {
-      break
-    }
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const secondCalls = gc.calls.slice(firstCallCount)
-  const alphaSecond = secondCalls.find(call => call.title === 'Group: Alpha')
-  const betaSecond = secondCalls.find(call => call.title === 'Group: Beta')
-  assert.ok(alphaSecond && betaSecond, 'both rooms resumed for the second pair')
-  assert.equal(alphaSecond.stored, alphaFirst.stored)
-  assert.equal(betaSecond.stored, betaFirst.stored)
-  assert.equal(alphaSecond.prompt.includes('ALPHA_ONLY_2'), true)
-  assert.equal(alphaSecond.prompt.includes('ALPHA_ONLY_1'), false, 'Alpha first delta was already seen')
-  assert.equal(alphaSecond.prompt.includes('BETA_ONLY_2'), false)
-  assert.equal(betaSecond.prompt.includes('BETA_ONLY_2'), true)
-  assert.equal(betaSecond.prompt.includes('BETA_ONLY_1'), false, 'Beta first delta was already seen')
-  assert.equal(betaSecond.prompt.includes('ALPHA_ONLY_2'), false)
-
-  const alphaSession = gc.sessions.get(alphaFirst.stored)
-  const betaSession = gc.sessions.get(betaFirst.stored)
-  assert.equal(alphaSession.messages.some(message => String(message.content).includes('BETA_ONLY')), false)
-  assert.equal(betaSession.messages.some(message => String(message.content).includes('ALPHA_ONLY')), false)
-})
-
-test('recreating a same-name group after disband mints fresh member sessions', async () => {
-  const gc = load(() => '(pass)')
-  const member = { name: 'research', title: '' }
-
-  // First incarnation of the room.
-  gc.updateGroupChat('Alpha', r => {
-    r.roomId = 'r-one'
-    return r
-  })
-  const first = await gc.ensureGroupChatSession('Alpha', member)
-
-  // Disband: the room record is gone; the member's gateway session survives.
-  const rooms = { ...gc.$groupChats.get() }
-  delete rooms.Alpha
-  gc.$groupChats.set(rooms)
-
-  // Recreate under the same display name with a freshly minted roomId.
-  gc.updateGroupChat('Alpha', r => {
-    r.roomId = 'r-two'
-    return r
-  })
-  const second = await gc.ensureGroupChatSession('Alpha', member)
-
-  assert.notEqual(first.stored, second.stored, 'the recreated room must not resume the old member session')
-  assert.equal(gc.sessions.get(first.stored).title, 'Group: r-one')
-  assert.equal(gc.sessions.get(second.stored).title, 'Group: r-two')
-})
-
-test('a transient resume failure fails closed instead of forking the member session', async () => {
-  // Mirrors findExistingCanonicalChat's fix (87b645f52c): a resume that
-  // fails for any reason OTHER than "genuinely doesn't exist" (JSON-RPC
-  // code 4007) must surface, not be read as "no session, mint a new one" —
-  // that would fork the member's real history and silently overwrite
-  // room.sessions[key] so the old session becomes unreachable.
-  const gc = load(() => '(pass)')
-  const member = { name: 'research', title: '' }
-
-  gc.updateGroupChat('Alpha', r => {
-    r.roomId = 'r-one'
-    return r
-  })
-  const first = await gc.ensureGroupChatSession('Alpha', member)
-  const roomBefore = gc.$groupChats.get().Alpha
-
-  // Simulate a transient failure (backend still warming up after a restart,
-  // a network blip on a cross-connection lookup, ...) on the NEXT resume of
-  // the member's own stored session — a real gateway error, not "not found".
-  const originalRequest = gc.host.request
-  gc.host.request = async (method, params) => {
-    if (method === 'session.resume' && params.session_id === first.stored) {
-      const err = new Error('gateway temporarily unavailable')
-      err.code = 5000
-      throw err
-    }
-    return originalRequest(method, params)
-  }
-
-  await assert.rejects(
-    () => gc.ensureGroupChatSession('Alpha', member),
-    /Could not check .*group session/
-  )
-
-  gc.host.request = originalRequest
-
-  // Nothing was forked: the room's session pointer is untouched, and the
-  // original session is still the only one on record for this member.
-  assert.deepEqual(gc.$groupChats.get().Alpha.sessions, roomBefore.sessions)
-  assert.equal(gc.sessions.size, 1)
-})
-
-test('a genuinely nonexistent stored session (4007) still falls through to the title lookup, then create', async () => {
-  const gc = load(() => '(pass)')
-  const member = { name: 'research', title: '' }
-
-  gc.updateGroupChat('Alpha', r => {
-    r.roomId = 'r-one'
-    return r
-  })
-
-  // A stored sid pointing at a session the gateway no longer has (e.g. an
-  // out-of-band deletion) is a genuine 4007 on the first target — the loop
-  // must still try the title lookup and, finding nothing there either,
-  // create a fresh session rather than throwing.
-  gc.updateGroupChat('Alpha', r => {
-    r.sessions = { research: 'sid-gone' }
-    return r
-  })
-
-  const result = await gc.ensureGroupChatSession('Alpha', member)
-  assert.ok(result.stored, 'a fresh session must be minted when nothing resumable exists')
-  assert.notEqual(result.stored, 'sid-gone')
-})
-
-test('group session titles are pinned to the roomId, with a legacy fallback to the display name', async () => {
-  const gc = load(() => '(pass)')
-
-  // Rooms persisted before roomIds keep name-based titles so their existing
-  // "Group: <name>" sessions keep resolving after an upgrade.
-  gc.updateGroupChat('Legacy', r => r)
-  const legacy = await gc.ensureGroupChatSession('Legacy', { name: 'research', title: '' })
-  assert.equal(gc.sessions.get(legacy.stored).title, 'Group: Legacy')
-
-  // New rooms pin the title to the immutable roomId, never the display name.
-  gc.updateGroupChat('New', r => {
-    r.roomId = 'r-abc'
-    return r
-  })
-  const fresh = await gc.ensureGroupChatSession('New', { name: 'research', title: '' })
-  assert.equal(gc.sessions.get(fresh.stored).title, 'Group: r-abc')
-})
-
-test('same-name group dedup reserves suffix length at the 64-char cap', () => {
-  const gc = load(() => '(pass)')
-
-  assert.equal(gc.uniqueGroupChatName('Team', new Set(['Other'])), 'Team')
-
-  // Slicing the joined string would chop the " 2"/" 3" suffix off a
-  // max-length base and collide with the original forever.
-  const base = 'x'.repeat(64)
-  const taken = new Set([base, `${base.slice(0, 62)} 2`])
-
-  const next = gc.uniqueGroupChatName(base, taken)
-
-  assert.notEqual(next, base)
-  assert.equal(next.length, 64)
-  assert.equal(next, `${base.slice(0, 62)} 3`)
-})
-
-test('roomId persists with the room record and survives disband of other rooms', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.updateGroupChat('Keep', r => {
-    r.roomId = 'r-keep'
-    return r
-  })
-  gc.updateGroupChat('Gone', r => {
-    r.roomId = 'r-gone'
-    return r
-  })
-
-  await gc.disbandGroupChat('Gone', [{ name: 'builder' }])
-
-  const durable = gc.storageWrites.get('group-chats')
-  assert.equal(durable.Keep.roomId, 'r-keep', 'roomId survives disband of another room')
-  assert.ok(!('Gone' in durable), 'disbanded room not persisted')
-})
-
-test('needs-you: a member reply mentioning @user badges the group; user send clears it', async () => {
-  const gc = load(profile => (profile === 'research' ? 'Blocked on billing access — @user which account?' : '(pass)'))
-
-  gc.sendToGroupChat('Escalate', [{ name: 'research', title: '' }], 'sort out the invoices')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Escalate || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-  assert.equal(gc.$groupNeedsYou.get().Escalate, true)
-
-  const gc2 = gc // same room: user reply clears
-  gc2.sendToGroupChat('Escalate', [{ name: 'research', title: '' }], 'use the ops account')
-  assert.equal(gc2.$groupNeedsYou.get().Escalate, false)
-})
-
-test('turn transport is gateway-native (session RPCs) and hostile text rides verbatim', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Rpc', [{ name: 'research', title: '' }], 'hello "there" `whoami` $(id)')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Rpc || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const call = gc.calls[0]
-  assert.equal(call.profile, 'research')
-  // Hostile text is a JSON string in an RPC param — never a shell string.
-  assert.equal(call.prompt.includes('hello "there" `whoami` $(id)'), true)
-  // The per-group session is created with the room title.
-  assert.match(pluginSource, /title,\n/)
-  assert.match(pluginSource, /const title = `Group: \$\{room\.roomId \|\| group\}`/)
-})
-
-test('room plumbing sessions carry the room_plumbing contract', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Rpc', [{ name: 'research', title: '' }], 'hello')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Rpc || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  // The per-group plumbing session must be hidden AND stamped as
-  // room_plumbing so the server rebuilds it from the member profile's
-  // CURRENT config instead of restoring a stale stored provider pin
-  // (GH #89497 — room bots stuck on Nous after a provider switch).
-  assert.match(pluginSource, /hidden: true/)
-  assert.match(pluginSource, /room_plumbing: true/)
-})
-
-test('bot sessions carry the follow-profile-config contract (canonical DM + room)', () => {
-  // Canonical Bot Chat: the ONE forever DM per bot must always follow the
-  // member profile's CURRENT config — never a stale stored model/provider pin
-  // (the "out of Nous credits" DM bug after a profile switch).
-  assert.match(pluginSource, /follow_profile_config: true/)
-  // The contract is sent on session.create for BOTH the canonical chat and
-  // room plumbing sessions, so resume rebuilds from current config.
-  const canonical = pluginSource.slice(pluginSource.indexOf('function createCanonicalChat'))
-  assert.match(canonical, /follow_profile_config: true/)
-  const room = pluginSource.slice(pluginSource.indexOf('async function ensureGroupChatSession'))
-  assert.match(room, /follow_profile_config: true/)
-})
-
-test('log trimming keeps watermarks consistent', () => {
-  const gc = load(() => '(pass)')
-  const log = Array.from({ length: 200 }, (_, i) => ({ from: { kind: 'user', name: 'You' }, text: `m${i}`, at: i }))
-  const { log: trimmed, watermarks } = gc.trimGroupChatLog(log, { research: 150, builder: 10 }, 96)
-  assert.equal(trimmed.length, 96)
-  assert.equal(watermarks.research, 150 - 104)
-  assert.equal(watermarks.builder, 0)
-})
-
-test('group room messages and members mirror through bounded gateway profile metadata', async () => {
-  const gc = load(() => '(pass)')
-  const members = [
-    { name: 'research', handle: 'research' },
-    { name: 'builder', handle: 'builder' }
-  ]
-  gc.sendToGroupChat('Research', members, 'What changed?')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Research || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const configure = gc.requests.filter(call => call.method === 'profiles.configure').at(-1)
-  assert.ok(configure, 'room updates are mirrored to the gateway')
-  assert.equal(configure.params.name, 'default')
-  const envelope = configure.params.ui_meta['hermes-bots-groups']
-  assert.equal(envelope.version, 3)
-  const researchKey = Object.keys(envelope.rooms).find(key => envelope.rooms[key].name === 'Research')
-  assert.ok(researchKey, 'Research room present under its durable key')
-  assert.equal(envelope.rooms[researchKey].log[0].text, 'What changed?')
-  assert.equal(JSON.stringify(envelope.rooms[researchKey].members.map(member => member.name)), JSON.stringify(['research', 'builder']))
-  assert.ok(gc.groupChatGatewayJsonSize(envelope) <= 48000)
-})
-
-test('group gateway mirror is size bounded and favors recent messages', () => {
-  const gc = load(() => '(pass)')
-  const long = 'x'.repeat(5000)
-  const snapshot = gc.groupChatSyncSnapshot({
-    Large: {
-      log: Array.from({ length: 100 }, (_, index) => ({
-        from: { kind: index % 2 ? 'member' : 'user', name: index % 2 ? 'research' : 'You' },
-        text: `${index}:${long}`,
-        at: index
-      }))
-    }
-  })
-
-  assert.ok(gc.groupChatGatewayJsonSize(snapshot) <= 48000)
-  assert.ok(snapshot.rooms['name:Large'].log.length <= 16)
-  assert.match(snapshot.rooms['name:Large'].log.at(-1).text, /^99:/)
-  assert.ok(snapshot.rooms['name:Large'].log.at(-1).text.length <= 1200)
-})
-
-test('group gateway mirror preserves threads and budgets escaped Unicode', () => {
-  const gc = load(() => '(pass)')
-  const snapshot = gc.groupChatSyncSnapshot({
-    Unicode: {
-      log: Array.from({ length: 16 }, (_, index) => ({
-        from: { kind: 'member', name: 'research' },
-        text: `message ${index} ${'🧠'.repeat(1200)}`,
-        at: index,
-        thread: `thread-${index}`
-      }))
-    }
-  })
-
-  assert.ok(gc.groupChatGatewayJsonSize(snapshot) <= 48000)
-  assert.equal(snapshot.rooms['name:Unicode'].log.at(-1).thread, 'thread-15')
-})
-
-test('empty runtime rooms are omitted from the gateway mirror', () => {
-  const gc = load(() => '(pass)')
-  const snapshot = gc.groupChatSyncSnapshot({
-    Disbanded: { log: [], members: [{ name: 'research' }] }
-  })
-
-  assert.deepEqual(Object.keys(snapshot.rooms), [])
-})
-
-test('an empty hydrate cannot erase a shared gateway room mirror', () => {
-  const gc = load(() => '(pass)')
-  const before = gc.requests.length
-
-  gc.scheduleGroupChatServerSync({})
-
-  assert.equal(gc.requests.length, before)
-})
-
-test('an explicit final-room disband may clear the gateway room mirror', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.scheduleGroupChatServerSync({}, { allowEmpty: true, deletedRooms: ['Research'] })
-  await new Promise(resolve => setImmediate(resolve))
-
-  const configure = gc.requests.filter(call => call.method === 'profiles.configure').at(-1)
-  assert.deepEqual(Object.keys(configure.params.ui_meta['hermes-bots-groups'].rooms), [])
-  assert.ok(configure.params.ui_meta['hermes-bots-groups'].deleted['name:Research'] > 0)
-})
-
-test('pull-before-push merge preserves disjoint rooms, messages, and members', () => {
-  const gc = load(() => '(pass)')
-  const merged = gc.mergeGroupChatSyncSnapshots(
-    {
-      version: 1,
-      rooms: {
-        Shared: {
-          log: [{ from: { kind: 'user', name: 'You' }, text: 'remote', at: 1, thread: 'one' }],
-          members: [{ name: 'research', handle: 'research' }]
-        },
-        RemoteOnly: {
-          log: [{ from: { kind: 'member', name: 'ops' }, text: 'kept', at: 2 }],
-          members: [{ name: 'ops' }]
-        }
-      }
-    },
-    {
-      version: 1,
-      rooms: {
-        Shared: {
-          log: [{ from: { kind: 'member', name: 'builder' }, text: 'local', at: 3, thread: 'one' }],
-          members: [{ name: 'builder', handle: 'builder' }]
-        }
-      }
-    }
-  )
-
-  assert.equal(JSON.stringify(merged.rooms['name:Shared'].log.map(entry => entry.text)), JSON.stringify(['remote', 'local']))
-  assert.equal(JSON.stringify(merged.rooms['name:Shared'].members.map(member => member.name)), JSON.stringify(['research', 'builder']))
-  assert.equal(merged.rooms['name:RemoteOnly'].log[0].text, 'kept')
-})
-
-test('gateway projection hydrates a cold Desktop without dropping local runtime fields', () => {
-  const gc = load(() => '(pass)')
-  const merged = gc.mergeRemoteGroupChatSnapshotIntoRooms(
-    {
-      rooms: {
-        Shared: {
-          log: [
-            { from: { kind: 'user', name: 'You' }, text: 'remote question', at: 10, thread: 'thread-1' },
-            { from: { kind: 'member', name: 'research' }, text: 'remote answer', at: 20, thread: 'thread-1' }
-          ],
-          members: [{ name: 'research', connectionId: 'mini', sourceScoped: true }]
-        }
-      }
-    },
-    {
-      Local: {
-        log: [{ from: { kind: 'user', name: 'You' }, text: 'local', at: 5, thread: 'thread-local' }],
-        watermarks: { builder: 1 },
-        sessions: { builder: 'session-1' },
-        members: [{ name: 'builder' }],
-        epoch: 7,
-        running: true
-      }
-    }
-  )
-
-  assert.equal(
-    JSON.stringify(merged.Shared.log.map(entry => entry.text)),
-    JSON.stringify(['remote question', 'remote answer'])
-  )
-  assert.equal(merged.Shared.members[0].remoteSource, true)
-  assert.equal(merged.Local.sessions.builder, 'session-1')
-  assert.equal(merged.Local.epoch, 7)
-  assert.equal(merged.Local.running, true)
-})
-
-test('room deletion tombstone wins over stale history but not a later recreation', () => {
-  const gc = load(() => '(pass)')
-  const stale = gc.mergeGroupChatSyncSnapshots(
-    {
-      version: 2,
-      rooms: { Research: { revision: 1, log: [{ id: 'old', from: { kind: 'user', name: 'You' }, text: 'old', at: 10 }] } }
-    },
-    { version: 2, rooms: {}, deleted: { Research: 2 } }
-  )
-  assert.equal(stale.rooms['name:Research'], undefined)
-  assert.equal(stale.deleted['name:Research'], 2)
-
-  const recreated = gc.mergeGroupChatSyncSnapshots(stale, {
-    version: 2,
-    rooms: { Research: { revision: 3, log: [{ id: 'new', from: { kind: 'user', name: 'You' }, text: 'new', at: 1 }] } }
-  })
-  assert.equal(recreated.rooms['name:Research'].log[0].text, 'new')
-  assert.equal(recreated.deleted, undefined)
-})
-
-test('gateway revisions, not device clocks, order room deletion and recreation', () => {
-  const gc = load(() => '(pass)')
-  const merged = gc.mergeGroupChatSyncSnapshots(
-    {
-      version: 2,
-      rooms: {
-        ClockSkewed: {
-          revision: 8,
-          log: [{ id: 'future-clock', from: { kind: 'user', name: 'You' }, text: 'old', at: 9999999999999 }]
-        }
-      }
-    },
-    { version: 2, rooms: {}, deleted: { ClockSkewed: 9 } }
-  )
-
-  assert.equal(merged.rooms['name:ClockSkewed'], undefined)
-  assert.equal(merged.deleted['name:ClockSkewed'], 9)
-})
-
-test('a conflicting writer can merge the winner and preserve both stable message ids', () => {
-  const gc = load(() => '(pass)')
-  const winner = {
-    version: 2,
-    rooms: {
-      Shared: {
-        revision: 1,
-        log: [{ id: 'writer-a:1', from: { kind: 'user', name: 'You' }, text: 'alpha', at: 100 }],
-        members: [{ name: 'alpha' }]
-      }
-    }
-  }
-  const loserRetry = gc.mergeGroupChatSyncSnapshots(
-    winner,
-    {
-      version: 2,
-      rooms: {
-        Shared: {
-          revision: 0,
-          log: [{ id: 'writer-b:1', from: { kind: 'member', name: 'beta' }, text: 'beta', at: 1 }],
-          members: [{ name: 'beta' }]
-        }
-      }
-    },
-    { changedRooms: ['Shared'], writeRevision: 2 }
-  )
-
-  assert.equal(
-    JSON.stringify(loserRetry.rooms['name:Shared'].log.map(entry => entry.id).sort()),
-    JSON.stringify(['writer-a:1', 'writer-b:1'])
-  )
-  assert.equal(loserRetry.rooms['name:Shared'].revision, 2)
-})
-
-test('sync worker retries a gateway CAS conflict and publishes the merged room', async () => {
-  const gc = load(() => '(pass)', { conflictOnce: true, deferredTimers: true })
-  gc.$groupChats.set({
-    Shared: {
-      log: [{ id: 'writer-b:1', from: { kind: 'member', name: 'beta' }, text: 'beta', at: 2 }],
-      members: [{ name: 'beta' }],
-      watermarks: {},
-      sessions: {},
-      syncRevision: 0
-    }
-  })
-
-  gc.scheduleGroupChatServerSync(gc.$groupChats.get(), { changedRooms: ['Shared'] })
-  for (let i = 0; i < 20 && (gc.uiMetaRevisions['hermes-bots-groups'] || 0) < 2; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const stored = gc.sharedUiMeta['hermes-bots-groups']
-  assert.equal(gc.uiMetaRevisions['hermes-bots-groups'], 2)
-  assert.equal(
-    JSON.stringify(stored.rooms['name:Shared'].log.map(entry => entry.id).sort()),
-    JSON.stringify(['writer-a:1', 'writer-b:1'])
-  )
-  assert.equal(
-    gc.requests.filter(call => call.method === 'profiles.configure').length,
-    2
-  )
-})
-
-test('read-back does not clobber a newer local room edit queued during an in-flight write', () => {
-  const gc = load(() => '(pass)')
-  const merged = gc.mergeRemoteGroupChatSnapshotIntoRooms(
-    {
-      version: 2,
-      rooms: {
-        Shared: {
-          revision: 5,
-          log: [{ id: 'remote', from: { kind: 'user', name: 'You' }, text: 'remote message', at: 1 }],
-          members: [{ name: 'old-member' }],
-          image: 'data:image/png;base64,old'
-        }
-      }
-    },
-    {
-      Shared: {
-        syncRevision: 4,
-        log: [{ id: 'local', from: { kind: 'user', name: 'You' }, text: 'local message', at: 2 }],
-        members: [{ name: 'new-member' }],
-        image: 'data:image/png;base64,new'
-      }
-    },
-    { preserveRooms: ['Shared'] }
-  )
-
-  assert.equal(JSON.stringify(merged.Shared.members.map(member => member.name)), JSON.stringify(['new-member']))
-  assert.equal(merged.Shared.image, 'data:image/png;base64,new')
-  assert.equal(merged.Shared.syncRevision, 4)
-  assert.equal(
-    JSON.stringify(merged.Shared.log.map(entry => entry.id).sort()),
-    JSON.stringify(['local', 'remote'])
-  )
-})
-
-test('rename publishes a new room plus old-name tombstone and cold hydrate cannot resurrect it', () => {
-  const gc = load(() => '(pass)')
-  const before = {
-    version: 2,
-    rooms: {
-      Old: {
-        revision: 4,
-        log: [{ id: 'turn-1', from: { kind: 'user', name: 'You' }, text: 'history', at: 10 }],
-        members: [{ name: 'research' }],
-        image: 'data:image/png;base64,room'
-      }
-    }
-  }
-  const after = gc.mergeGroupChatSyncSnapshots(
-    before,
-    {
-      version: 2,
-      rooms: {
-        New: {
-          revision: 4,
-          log: before.rooms.Old.log,
-          members: before.rooms.Old.members,
-          image: before.rooms.Old.image
-        }
-      }
-    },
-    { changedRooms: ['New'], deletedRooms: ['Old'], writeRevision: 5 }
-  )
-  const hydrated = gc.mergeRemoteGroupChatSnapshotIntoRooms(after, {})
-
-  assert.equal(after.rooms['name:Old'], undefined)
-  assert.equal(after.deleted['name:Old'], 5)
-  assert.equal(after.rooms['name:New'].revision, 5)
-  assert.equal(after.rooms['name:New'].image, 'data:image/png;base64,room')
-  assert.equal(hydrated.Old, undefined)
-  assert.equal(hydrated.New.log[0].text, 'history')
-  assert.equal(hydrated.New.image, 'data:image/png;base64,room')
-})
-
-test('room identity class: rename with a roomId is a same-key field update, never delete+create', () => {
-  const gc = load(() => '(pass)')
-  const before = {
-    version: 3,
-    rooms: {
-      'id:room-42': {
-        name: 'Old',
-        roomId: 'room-42',
-        revision: 4,
-        log: [{ id: 'turn-1', from: { kind: 'user', name: 'You' }, text: 'history', at: 10 }],
-        members: [{ name: 'research' }]
-      }
-    }
-  }
-  const after = gc.mergeGroupChatSyncSnapshots(
-    before,
-    {
-      version: 3,
-      rooms: {
-        'id:room-42': { ...before.rooms['id:room-42'], name: 'New' }
-      }
-    },
-    { changedRooms: ['id:room-42'], writeRevision: 5 }
-  )
-
-  // Same durable key, new display name, no tombstone needed at all.
-  assert.equal(Object.keys(after.rooms).length, 1)
-  assert.equal(after.rooms['id:room-42'].name, 'New')
-  assert.equal(after.rooms['id:room-42'].revision, 5)
-  assert.equal(after.deleted, undefined)
-
-  // A lagging gateway still holding the OLD name under the same id cannot
-  // resurrect it: same key, lower revision, identity follows the winner.
-  const lagged = gc.mergeGroupChatSyncSnapshots(before, after)
-  assert.equal(lagged.rooms['id:room-42'].name, 'New')
-})
-
-test('room identity class: id tombstones are final even against a higher-revision lagging copy', () => {
-  const gc = load(() => '(pass)')
-  const merged = gc.mergeGroupChatSyncSnapshots(
-    {
-      version: 3,
-      // A gateway that was OFFLINE during the disband still carries the room
-      // with a high revision from busy pre-disband traffic.
-      rooms: {
-        'id:room-9': {
-          name: 'Zombie',
-          roomId: 'room-9',
-          revision: 40,
-          log: [{ id: 'stale', from: { kind: 'user', name: 'You' }, text: 'stale', at: 1 }]
-        }
-      }
-    },
-    { version: 3, rooms: {}, deleted: { 'id:room-9': 3 } }
-  )
-
-  assert.equal(merged.rooms['id:room-9'], undefined, 'disbanded id-keyed room stays dead')
-  assert.equal(merged.deleted['id:room-9'], 3, 'tombstone survives for other lagging gateways')
-
-  // Same-name RECREATION is unaffected: the new room minted a fresh id.
-  const recreated = gc.mergeGroupChatSyncSnapshots(merged, {
-    version: 3,
-    rooms: {
-      'id:room-10': {
-        name: 'Zombie',
-        roomId: 'room-10',
-        revision: 1,
-        log: [{ id: 'fresh', from: { kind: 'user', name: 'You' }, text: 'fresh', at: 2 }]
-      }
-    }
-  })
-  assert.equal(recreated.rooms['id:room-10'].log[0].text, 'fresh')
-  assert.equal(recreated.rooms['id:room-9'], undefined)
-})
-
-test('room identity class: cold hydrate follows a remote rename via roomId instead of duplicating', () => {
-  const gc = load(() => '(pass)')
-  const merged = gc.mergeRemoteGroupChatSnapshotIntoRooms(
-    {
-      version: 3,
-      rooms: {
-        'id:room-7': {
-          name: 'Renamed',
-          roomId: 'room-7',
-          revision: 6,
-          log: [{ id: 'm1', from: { kind: 'user', name: 'You' }, text: 'hello', at: 1 }],
-          members: [{ name: 'research' }]
-        }
-      }
-    },
-    {
-      // Local copy still under the pre-rename display name, same roomId.
-      Original: {
-        roomId: 'room-7',
-        syncRevision: 5,
-        log: [{ id: 'm1', from: { kind: 'user', name: 'You' }, text: 'hello', at: 1 }],
-        watermarks: {},
-        sessions: { research: 'sid-1' },
-        members: [{ name: 'research' }]
-      }
-    }
-  )
-
-  assert.equal(merged.Original, undefined, 'old display name is re-keyed, not duplicated')
-  assert.equal(merged.Renamed.roomId, 'room-7')
-  assert.equal(merged.Renamed.sessions.research, 'sid-1', 'runtime fields survive the re-key')
-})
-
-test('room identity class: renaming an id-keyed room via the rename job shape never tombstones it', () => {
-  const gc = load(() => '(pass)')
-  const remote = {
-    version: 3,
-    rooms: {
-      'id:room-3': {
-        name: 'Old',
-        roomId: 'room-3',
-        revision: 2,
-        log: [{ id: 'h1', from: { kind: 'user', name: 'You' }, text: 'history', at: 5 }],
-        members: [{ name: 'research' }]
-      }
-    }
-  }
-  // Exactly what renameGroupChat schedules: changed [new], deleted [old].
-  const after = gc.mergeGroupChatSyncSnapshots(
-    remote,
-    {
-      version: 3,
-      rooms: {
-        'id:room-3': { ...remote.rooms['id:room-3'], name: 'New' }
-      }
-    },
-    { changedRooms: ['New'], deletedRooms: ['Old'], writeRevision: 3 }
-  )
-  assert.ok(after.rooms['id:room-3'], 'renamed room survives its own rename job')
-  assert.equal(after.rooms['id:room-3'].name, 'New')
-  assert.equal(after.deleted?.['id:room-3'], undefined, 'no id tombstone for a same-id rename')
-  // A residual name:Old tombstone is correct — it retires stale v2/legacy
-  // copies of this room that older clients published under the name key.
-  assert.equal(after.deleted?.['name:Old'], 3)
-
-  // Hydrate path: the pull that races the rename write must not delete the
-  // locally re-keyed record just because the remote copy still says Old.
-  const merged = gc.mergeRemoteGroupChatSnapshotIntoRooms(remote, {
-    New: {
-      roomId: 'room-3',
-      syncRevision: 2,
-      log: remote.rooms['id:room-3'].log,
-      watermarks: {},
-      sessions: { research: 'sid-9' },
-      members: [{ name: 'research' }]
-    }
-  }, { preserveRooms: ['New'], deletedRooms: ['Old'] })
-  assert.ok(merged.New, 'locally renamed room survives a stale-name pull')
-  assert.equal(merged.New.sessions.research, 'sid-9')
-  assert.equal(merged.Old, undefined)
-})
-
-test('fan-out class: a room write is mirrored to every reachable default-profile gateway', async () => {
-  const gc = load(() => '(pass)', { deferredTimers: true })
-  const remoteRequests = []
-  gc.host.profileRoutes = async () => [
-    { connectionId: 'gw-a', profile: 'default' },
-    { connectionId: 'gw-b', profile: 'default' },
-    { connectionId: 'gw-b', profile: 'other' }
-  ]
-  gc.host.requestProfile = async (route, method) => {
-    remoteRequests.push({ connectionId: route.connectionId, method })
-    if (method === 'profiles.list') {
-      return { profiles: [{ name: 'default', ui_meta: {}, ui_meta_revisions: {} }] }
-    }
-    if (method === 'profiles.configure') {
-      return { applied: { ui_meta: true, ui_meta_revisions: { 'hermes-bots-groups': 1 } } }
-    }
-    return {}
-  }
-
-  gc.$groupChats.set({
-    Shared: {
-      log: [{ id: 'w1', from: { kind: 'user', name: 'You' }, text: 'hi', at: 1 }],
-      members: [{ name: 'research' }],
-      watermarks: {},
-      sessions: {},
-      syncRevision: 0
-    }
-  })
-  gc.scheduleGroupChatServerSync(gc.$groupChats.get(), { changedRooms: ['Shared'] })
-  for (let i = 0; i < 60 && remoteRequests.filter(r => r.method === 'profiles.configure').length < 2; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const configured = new Set(
-    remoteRequests.filter(r => r.method === 'profiles.configure').map(r => r.connectionId)
-  )
-  assert.ok(configured.has('gw-a'), 'gateway A received the room mirror')
-  assert.ok(configured.has('gw-b'), 'gateway B received the room mirror')
-})
-
-test('source contract: workspace + main-window door + prompt rules are wired', () => {
-  assert.match(pluginSource, /function GroupChatWorkspace\(/)
-  // Group rows open through the main-window door, feature-detected with the
-  // in-panel room as the older-desktop fallback.
-  assert.match(pluginSource, /function openGroupChat\(/)
-  assert.match(pluginSource, /typeof host\.openWorkspace === 'function'/)
-  assert.match(pluginSource, /\$groupChatWorkspace\.set\(group\)/)
-  assert.match(pluginSource, /reply with exactly "\(pass\)"/i)
-  assert.match(pluginSource, /\[Group chat: "\$\{groupName\}"\]/)
-})
-
-test('group selection follows main-window open and close', () => {
-  const gc = load(() => '(pass)')
-  let onClose
-
-  gc.host.openWorkspace = (_id, options) => {
-    onClose = options.onClose
-    return () => onClose()
-  }
-
-  gc.openGroupChat('Core')
-  assert.equal(gc.$groupChatWorkspace.get(), 'Core')
-  // #89788: the main tab owns the room, so the pane keeps its roster.
-  assert.equal(gc.shouldRenderGroupChatInPane('Core'), false)
-
-  onClose()
-  assert.equal(gc.$groupChatWorkspace.get(), null)
-  assert.equal(gc.shouldRenderGroupChatInPane('Core'), true)
-})
-
-test('older and failed workspace hosts keep the in-pane group fallback', () => {
-  const older = load(() => '(pass)')
-
-  older.openGroupChat('Core')
-  assert.equal(older.$groupChatWorkspace.get(), 'Core')
-  assert.equal(older.shouldRenderGroupChatInPane('Core'), true)
-
-  const failed = load(() => '(pass)')
-
-  failed.host.openWorkspace = () => {
-    throw new Error('workspace unavailable')
-  }
-
-  failed.openGroupChat('Ops')
-  assert.equal(failed.$groupChatWorkspace.get(), 'Ops')
-  assert.equal(failed.shouldRenderGroupChatInPane('Ops'), true)
-})
-
-test('main-tab ownership is recorded before the selection atom paints (#89788 follow-up)', () => {
-  const gc = load(() => '(pass)')
-  // Simulate a BotsPane render racing the open: sample the gate at the
-  // moment the selection atom flips. If the tab were recorded after the
-  // atom set, this probe would observe selected-but-unowned and the
-  // in-pane duplicate would paint beside the main tab.
-  let gateAtSelection = null
-  const realSet = gc.$groupChatWorkspace.set
-
-  gc.$groupChatWorkspace.set = value => {
-    if (value === 'Core' && gateAtSelection === null) {
-      gateAtSelection = gc.shouldRenderGroupChatInPane('Core')
-    }
-
-    realSet(value)
-  }
-  gc.host.openWorkspace = () => () => undefined
-
-  gc.openGroupChat('Core')
-  assert.equal(gateAtSelection, false)
-})
-
-test('tab open/close bumps the reactive rev so the pane gate re-evaluates', () => {
-  const gc = load(() => '(pass)')
-  let onClose
-
-  gc.host.openWorkspace = (_id, options) => {
-    onClose = options.onClose
-    return () => onClose()
-  }
-
-  const before = gc.$groupMainTabsRev.get()
-
-  gc.openGroupChat('Core')
-  assert.ok(gc.$groupMainTabsRev.get() > before, 'recording the main tab must bump the rev')
-
-  const afterOpen = gc.$groupMainTabsRev.get()
-
-  onClose()
-  assert.ok(gc.$groupMainTabsRev.get() > afterOpen, 'closing the main tab must bump the rev')
-})
-
-test('closing an older selected group does not clear the newer selection', () => {
-  const gc = load(() => '(pass)')
-
-  gc.host.openWorkspace = () => () => undefined
-  gc.openGroupChat('Core')
-  gc.openGroupChat('Ops')
-  gc.closeGroupChatMainTab('Core')
-
-  assert.equal(gc.$groupChatWorkspace.get(), 'Ops')
-})
-
-test('source contract: active group styling suppresses bot styling', () => {
-  assert.match(pluginSource, /function botRowOwnsWorkspace\([\s\S]*?if \(activeGroup\) \{\s*return false/)
-  assert.match(pluginSource, /active && 'bg-\(--ui-row-active-background\)'/)
-  assert.match(pluginSource, /active: groupChatName === row\.name/)
-})
-
-test('source contract: group roster rows expose a confirmed Delete Group action', () => {
-  assert.match(pluginSource, /function GroupRow\(\{ active, group, members, needsYou, onOpen, onDisband \}\)/)
-  assert.match(pluginSource, /children: 'Delete Group'/)
-  assert.match(pluginSource, /title: 'Delete group chat\?'/)
-  assert.match(pluginSource, /await disbandGroupChat\(deletingGroup\.name, deletingGroup\.members\)/)
-})
-
-test('disband: removes only this membership, room log, workspace, and needs-you state', async () => {
-  const gc = load(() => '(pass)')
-
-  // Two rooms; disband one.
-  gc.sendToGroupChat('Keep', [{ name: 'research', title: '' }], 'hello keepers')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Keep || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-  gc.sendToGroupChat('Gone', [{ name: 'builder', title: '' }], 'hello goners')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Gone || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  const rooms = { ...gc.$groupChats.get() }
-  rooms.Keep = {
-    ...rooms.Keep,
-    members: [{ name: 'remote', remoteSource: true, sourceScoped: true, connectionId: 'remote-1' }]
-  }
-  gc.$groupChats.set(rooms)
-
-  gc.$botMeta.set({
-    builder: { groups: ['Gone', 'Keep'], group: 'Gone' },
-    research: { groups: ['Keep'], group: 'Keep' }
-  })
-  gc.$groupChatWorkspace.set('Gone')
-  gc.$groupNeedsYou.set({ Gone: true, Keep: true })
-
-  await gc.disbandGroupChat('Gone', [{ name: 'builder' }])
-
-  // Room state: gone from the atom (no running drive, so no tombstone).
-  assert.equal(gc.$groupChats.get().Gone, undefined)
-  assert.ok(gc.$groupChats.get().Keep, 'other rooms untouched')
-  // The open room view closed; needs-you cleared for the disbanded room only.
-  assert.equal(gc.$groupChatWorkspace.get(), null)
-  assert.equal(gc.$groupNeedsYou.get().Gone, undefined)
-  assert.equal(gc.$groupNeedsYou.get().Keep, true)
-  // Disband removes only this membership; other groups survive.
-  assert.equal(JSON.stringify(gc.$botMeta.get().builder.groups), JSON.stringify(['Keep']))
-  assert.equal(gc.$botMeta.get().builder.group, 'Keep')
-  assert.equal(JSON.stringify(gc.$botMeta.get().research.groups), JSON.stringify(['Keep']))
-  assert.equal(gc.$botMeta.get().research.group, 'Keep')
-  // Persisted room map no longer carries the room.
-  const durable = gc.storageWrites.get('group-chats')
-  assert.ok(durable && !('Gone' in durable), 'disbanded room not persisted')
-  assert.ok('Keep' in durable, 'surviving room still persisted')
-  assert.equal(durable.Keep.members.length, 1, 'surviving room keeps remote member descriptors')
-  assert.equal(durable.Keep.members[0].connectionId, 'remote-1')
-})
-
-test('disband: an empty rendered roster cannot leave a metadata-only group row', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.$botMeta.set({ builder: { groups: ['Remote'], group: 'Remote' } })
-  gc.$groupChats.set({
-    Remote: { log: [], members: [], watermarks: {}, sessions: {}, running: false }
-  })
-
-  await gc.disbandGroupChat('Remote', [])
-
-  assert.equal(gc.$groupChats.get().Remote, undefined, 'room record is deleted')
-  assert.equal(JSON.stringify(gc.$botMeta.get().builder.groups), JSON.stringify([]))
-  assert.equal(gc.$botMeta.get().builder.group, null)
-  assert.equal(
-    JSON.stringify(gc.groupChatNames(gc.$botMeta.get(), gc.$groupChats.get())),
-    JSON.stringify([]),
-    'stale bot metadata cannot reconstruct a deleted zero-member row'
-  )
-})
-
-test('disband: an empty rendered roster recovers the exact source-qualified metadata owner', async () => {
-  const gc = load(() => '(pass)')
-  const remote = {
-    name: 'builder',
-    connectionId: 'remote-1',
-    connectionKind: 'remote',
-    sourceScoped: true,
-    remoteSource: true,
-    route: {
-      connectionId: 'remote-1',
-      mode: 'remote',
-      profile: 'builder',
-      targetProfile: 'builder'
-    }
-  }
-
-  gc.$lastRoster.set([remote])
-  gc.$botMeta.set({
-    builder: { groups: ['Keep'], group: 'Keep' },
-    'remote-1::builder': { groups: ['Remote'], group: 'Remote' }
-  })
-  gc.$groupChats.set({
-    Remote: { log: [], members: [], watermarks: {}, sessions: {}, running: false }
-  })
-
-  await gc.disbandGroupChat('Remote', [])
-
-  assert.equal(JSON.stringify(gc.$botMeta.get()['remote-1::builder'].groups), JSON.stringify([]))
-  assert.equal(gc.$botMeta.get()['remote-1::builder'].group, null)
-  assert.equal(JSON.stringify(gc.$botMeta.get().builder.groups), JSON.stringify(['Keep']))
-  assert.equal(gc.$botMeta.get().builder.group, 'Keep', 'same-named local metadata is untouched')
-})
-
-test('disband: skips source-qualified remote members instead of mutating same-named local metadata', async () => {
-  const gc = load(() => '(pass)')
-  gc.$botMeta.set({ builder: { groups: ['Keep'], group: 'Keep' } })
-
-  await gc.disbandGroupChat('Remote', [
-    { name: 'builder', remoteSource: true, sourceScoped: true, connectionId: 'remote-1' }
-  ])
-
-  assert.equal(JSON.stringify(gc.$botMeta.get().builder.groups), JSON.stringify(['Keep']))
-  assert.equal(gc.$botMeta.get().builder.group, 'Keep')
-  assert.equal(gc.$botMeta.get()['[object Object]'], undefined)
-})
-
-test('disband: a running room leaves an epoch-bumped empty tombstone so in-flight turns bail', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.sendToGroupChat('Live', [{ name: 'research', title: '' }], 'kick off')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Live || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  // Simulate a drive still in flight at disband time.
-  const rooms = { ...gc.$groupChats.get() }
-  rooms.Live = { ...rooms.Live, running: true, epoch: 3 }
-  gc.$groupChats.set(rooms)
-
-  await gc.disbandGroupChat('Live', [{ name: 'research' }])
-
-  const tomb = gc.$groupChats.get().Live
-  assert.ok(tomb, 'tombstone present while a drive is mid-turn')
-  assert.equal(tomb.log.length, 0)
-  assert.equal(tomb.running, false)
-  assert.equal(tomb.epoch, 4, 'epoch bumped so the loop bails at its member boundary')
-  assert.equal(tomb.tombstone, true, 'flagged so persistence and name-dedup skip it')
-  const durable = gc.storageWrites.get('group-chats')
-  assert.ok(!durable || !('Live' in (durable || {})), 'tombstone is never persisted')
-
-  // Regression (#90028 live E2E): updateGroupChat persists the WHOLE atom
-  // map — an unrelated room write while the tombstone lingers must not
-  // smuggle the tombstone into durable storage, and the disbanded name must
-  // be immediately reusable (uniqueGroupChatName would suffix it otherwise).
-  gc.updateGroupChat('Other', room => {
-    room.log.push({ at: Date.now(), from: { kind: 'user' }, text: 'x', thread: 't' })
-    return room
-  })
-  const durable2 = gc.storageWrites.get('group-chats')
-  assert.ok(durable2 && 'Other' in durable2, 'real room persists')
-  assert.ok(!('Live' in durable2), 'tombstone excluded from later whole-map writes')
-  assert.equal(gc.uniqueGroupChatName('Live', new Set(gc.liveGroupChatNames())), 'Live',
-    'disbanded name is immediately reusable — tombstone does not hold it')
-})
-
-test('source contract: workspace deletion stays behind a ConfirmDialog', () => {
-  assert.match(pluginSource, /function disbandGroupChat\(/)
-  assert.match(pluginSource, /title: 'Delete group chat\?'/)
-  assert.match(pluginSource, /await disbandGroupChat\(deletingGroup\.name, deletingGroup\.members\)/)
-})
-
-test('default profile speaks as Hermes in room transcripts, not @default', () => {
-  const gc = load(() => '(pass)')
-  const line = gc.formatGroupChatLine({ from: { kind: 'member', name: 'default' }, text: 'hello room' }, 'builder')
-  assert.equal(line, 'Hermes: hello room')
-  assert.doesNotMatch(line, /default/)
-
-  // Other members keep their profile name; the (you) suffix survives.
-  const you = gc.formatGroupChatLine({ from: { kind: 'member', name: 'default' }, text: 'hi' }, 'default')
-  assert.equal(you, 'Hermes (you): hi')
-  const plain = gc.formatGroupChatLine({ from: { kind: 'member', name: 'builder' }, text: 'yo' }, 'research')
-  assert.equal(plain, 'builder: yo')
-})
-
-test('speaker labels honor friendly identity: Bot Mode title, then display_name, never a stale Hermes', () => {
-  const gc = load(() => '(pass)')
-
-  // A renamed default (core display_name via `hermes profile rename`) must
-  // read as its new name — the community report was "Lucy" still showing
-  // "Hermes is thinking…" in group rooms.
-  gc.$lastRoster.set([{ name: 'default', display_name: 'Lucy' }])
-  assert.equal(gc.groupSpeakerLabel('default'), 'Lucy')
-  assert.equal(
-    gc.formatGroupChatLine({ from: { kind: 'member', name: 'default' }, text: 'hi' }, 'builder'),
-    'Lucy: hi'
-  )
-
-  // A Bot Mode title outranks display_name (same precedence as displayName).
-  gc.$botMeta.set({ default: { title: 'Moxie' } })
-  assert.equal(gc.groupSpeakerLabel('default'), 'Moxie')
-
-  // Secondary profiles get their title too — the thinking line names the
-  // renamed bot, not the raw profile slug.
-  gc.$botMeta.set({ research: { title: 'Radar' } })
-  gc.$lastRoster.set([])
-  assert.equal(gc.groupSpeakerLabel('research'), 'Radar')
-
-  // Untitled rows keep today's behavior: default → Hermes, others verbatim.
-  gc.$botMeta.set({})
-  assert.equal(gc.groupSpeakerLabel('default'), 'Hermes')
-  assert.equal(gc.groupSpeakerLabel('builder'), 'builder')
-})
-
-test('speaker labels never borrow a remote row\u2019s display_name for a local speaker', () => {
-  const gc = load(() => '(pass)')
-  // Only a remote/thin row named default exists — its display_name belongs
-  // to that connection, not to the active gateway's default.
-  gc.$lastRoster.set([{ name: 'default', display_name: 'HomelabBot', remoteSource: true }])
-  assert.equal(gc.groupSpeakerLabel('default'), 'Hermes')
-})
-
-test('turn prompt addresses the default profile as @hermes', () => {
-  const gc = load(() => '(pass)')
-  const prompt = gc.buildGroupChatTurnPrompt({
-    groupName: 'Core',
-    members: [{ name: 'default', title: '' }, { name: 'builder', title: '' }],
-    viewer: { name: 'default', title: '' },
-    deltaLines: []
-  })
-  assert.match(prompt, /You are @hermes,/)
-  assert.doesNotMatch(prompt, /@default\b/)
-
-  const peerView = gc.buildGroupChatTurnPrompt({
-    groupName: 'Core',
-    members: [{ name: 'default', title: '' }, { name: 'builder', title: '' }],
-    viewer: { name: 'builder', title: '' },
-    deltaLines: []
-  })
-  assert.match(peerView, /group chat with @hermes/)
-})
-
-test('mention routing: @hermes resolves to the default member', () => {
-  const gc = load(() => '(pass)')
-  const members = [{ name: 'default', title: '' }, { name: 'builder', title: '' }]
-  const parsed = gc.parseGroupChatMentions('@hermes take a look', members)
-  assert.equal(parsed.mentioned.has('default'), true)
-  assert.equal(parsed.mentioned.size, 1)
-})
-
-test('source contract: workspace speaker labels use displayName with a click-to-reveal handle', () => {
-  // Speaker labels come from the roster displayName (default → Hermes)…
-  assert.match(pluginSource, /displayName\(member \|\| \{ name: entry\.from\.name \}, meta\)/)
-  // …and clicking a speaker reveals the full disambiguated handle, with the
-  // gateway/device name appended for cross-connection speakers.
-  assert.match(pluginSource, /setRevealedSpeaker\(revealed \? null : entryKey\)/)
-  assert.match(pluginSource, /\$\{display\}\$\{entry\.from\.source \? `-\$\{entry\.from\.source\}` : ''\} \(@\$\{botHandle\(entry\.from\.name, member \|\| undefined\)\}\)/)
-})
-
-test('source contract: room messages carry the speaker avatar via the roster appearance pipeline', () => {
-  const start = pluginSource.indexOf('function GroupChatWorkspace(')
-  const end = pluginSource.indexOf('function BotsPane(')
-  const workspace = pluginSource.slice(start, end === -1 ? undefined : end)
-
-  // Per-message avatar: appearance resolved the same way as BotRow (custom
-  // image/pet honored, backfilled PNG dropped so the math face animates).
-  assert.match(workspace, /botAppearance\(entry\.from\.name, meta\)/)
-  assert.match(workspace, /image && !isBackfilledFacePng\(image\)/)
-  assert.match(workspace, /jsx\(BotFace, \{\s*shape,\s*color,\s*image: photo \? image : null,\s*size: 24,\s*name: entry\.from\.name/)
-
-  // Header stays quiet: member avatars belong to messages, while the header
-  // exposes a concise count instead of an overlapping face stack.
-  assert.doesNotMatch(workspace, /members\.slice\(0, 6\)\.map\(/)
-  assert.match(workspace, /children: members\.length > 0 && availableMembers < members\.length \? availabilityLabel : `\$\{members\.length\} bots`/)
-})
-
-test('stranded harvest: a timed-out turn whose reply landed late posts into the room and clears the marker', async () => {
-  const gc = load(() => '(pass)')
-
-  // Room with a stranded marker for research: baseline 0 messages.
-  gc.updateGroupChat('Late', r => {
-    r.stranded = { research: 0 }
-    r.sessions = { research: 'sid-research' }
-    return r
-  })
-  // The member's session finished after we stopped waiting.
-  gc.sessions.set('sid-research', {
-    stored: 'sid-research',
-    runtime: 'rt-research',
-    profile: 'research',
-    title: 'Group: Late',
-    messages: [
-      { role: 'user', content: 'the turn prompt' },
-      { role: 'assistant', content: 'Here is the full research result, delivered late.' }
-    ]
-  })
-
-  await gc.harvestStrandedGroupReply('Late', { name: 'research', title: '' })
-
-  const log = roomLog(gc, 'Late')
-  assert.equal(log.length, 1)
-  assert.equal(log[0].from.name, 'research')
-  assert.match(log[0].text, /delivered late/)
-  assert.equal(gc.$groupChats.get().Late.stranded.research, undefined, 'marker consumed')
-})
-
-test('stranded harvest: a rescued reply prefers the substantive answer over a trailing synthetic (pass)', async () => {
-  const gc = load(() => '(pass)')
-
-  // #94376 class bug at the second call site: the late-landing turn ends
-  // with a Codex intent-ack continuation nudge that gets a synthetic
-  // "(pass)" — the harvest must still surface the substantive answer that
-  // preceded it, not the trailing pass.
-  gc.updateGroupChat('Rescue', r => {
-    r.stranded = { research: 0 }
-    r.sessions = { research: 'sid-research' }
-    return r
-  })
-  gc.sessions.set('sid-research', {
-    stored: 'sid-research',
-    runtime: 'rt-research',
-    profile: 'research',
-    title: 'Group: Rescue',
-    messages: [
-      { role: 'user', content: 'the turn prompt' },
-      { role: 'assistant', content: 'Here is the full research result, delivered late.' },
-      { role: 'user', content: '[System: Continue now. Execute the required tool calls and only send your final answer after completing the task.]' },
-      { role: 'assistant', content: '(pass)' }
-    ]
-  })
-
-  await gc.harvestStrandedGroupReply('Rescue', { name: 'research', title: '' })
-
-  const log = roomLog(gc, 'Rescue')
-  assert.equal(log.length, 1)
-  assert.equal(log[0].from.name, 'research')
-  assert.match(log[0].text, /delivered late/)
-  assert.equal(gc.$groupChats.get().Rescue.stranded.research, undefined, 'marker consumed')
-})
-
-test('stranded + still busy: the round loop never re-submits into a member whose harvest just confirmed they are still running', async () => {
-  // research is confirmed busy on exactly its first two session.resume
-  // calls — the number of harvest-only touches the FIXED code makes across
-  // two rounds. If the responder guard is missing, research gets re-
-  // selected and picks up two EXTRA resume calls of its own (session
-  // resolution + turn baseline) before its very first post-resubmit poll
-  // — call #4 — which then reports done, so the mutated run still finishes
-  // fast (no real wall-clock wait) while still proving the resubmission
-  // happened.
-  const gc = load(profile => (profile === 'builder' ? 'builder here, all good' : '(pass)'), {
-    busyUntilResumeCall: { research: 2 }
-  })
-
-  // research's session is pre-seeded and resolvable, exactly like the
-  // sibling stranded-harvest test above — its stranded marker is the
-  // pre-thread bare-number shape (still supported: harvestStrandedGroupReply
-  // normalizes both shapes, and presence in `stranded` is what the round-loop
-  // guard checks, not the marker's value shape).
-  gc.sessions.set('sid-research', {
-    stored: 'sid-research',
-    runtime: 'rt-research',
-    profile: 'research',
-    title: 'Group: Grind',
-    messages: []
-  })
-
-  // research is already stranded from an earlier (unmodeled) timeout, and
-  // its session is STILL genuinely running per session.resume. Both members
-  // are mentioned, so without the busy-responder guard both would be
-  // re-selected this round — and resubmitting into research's live session
-  // would trigger the gateway's default busy policy (redirect/hard-
-  // interrupt), destroying the very turn the stranded marker exists to wait
-  // out.
-  gc.updateGroupChat('Grind', r => {
-    r.stranded = { research: 0 }
-    r.sessions = { research: 'sid-research' }
-    r.log = [{ from: { kind: 'user', name: 'You' }, text: '@research @builder status?', at: 1 }]
-    r.watermarks = { 'legacy::research': 0, 'legacy::builder': 0 }
-    return r
-  })
-
-  await gc.runGroupChatRounds('Grind', [{ name: 'research', title: '' }, { name: 'builder', title: '' }], 'legacy')
-
-  assert.equal(
-    gc.calls.filter(c => c.profile === 'research').length,
-    0,
-    'research (still busy) must never receive a new prompt.submit'
-  )
-  assert.equal(
-    gc.$groupChats.get().Grind.stranded.research,
-    0,
-    'marker survives untouched — harvest confirmed research is still running'
-  )
-  assert.equal(gc.calls.filter(c => c.profile === 'builder').length, 1, 'builder (not stranded) still gets its turn')
-})
-
-test('stranded harvest: a late (pass) or no-new-message consumes the marker without posting', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.updateGroupChat('Quiet2', r => {
-    r.stranded = { builder: 2 }
-    r.sessions = { builder: 'sid-builder' }
-    return r
-  })
-  gc.sessions.set('sid-builder', {
-    stored: 'sid-builder',
-    runtime: 'rt-builder',
-    profile: 'builder',
-    title: 'Group: Quiet2',
-    messages: [
-      { role: 'user', content: 'p1' },
-      { role: 'user', content: 'prompt' },
-      { role: 'assistant', content: '(pass)' }
-    ]
-  })
-
-  await gc.harvestStrandedGroupReply('Quiet2', { name: 'builder', title: '' })
-
-  assert.equal(roomLog(gc, 'Quiet2').length, 0)
-  assert.equal(gc.$groupChats.get().Quiet2.stranded.builder, undefined)
-})
-
-test('stranded markers persist so late replies survive a window reload', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.updateGroupChat('Persist', r => {
-    r.stranded = { research: 3 }
-    return r
-  })
-
-  const durable = gc.storageWrites.get('group-chats')
-  assert.ok(durable && durable.Persist, 'room persisted')
-  assert.equal(durable.Persist.stranded.research, 3, 'stranded marker rides the durable map')
-})
-
-test('source contract: long visible turns extend the deadline up to a hard cap', () => {
-  assert.match(pluginSource, /const GROUP_TURN_HARD_CAP_MS = /)
-  assert.match(pluginSource, /deadline = Math\.min\(started \+ GROUP_TURN_HARD_CAP_MS/)
-})
-
-test('source contract: the working line names the member on turn', () => {
-  assert.match(pluginSource, /is thinking…/)
-  assert.match(pluginSource, /r\.turn = member\.name/)
-  assert.match(pluginSource, /r\.turn = null/)
-})
-
-test('source contract: creating a group with a taken name mints a fresh room, never reopens the old log', () => {
-  assert.match(pluginSource, /const taken = new Set\(liveGroupChatNames\(\)\)/)
-  assert.match(pluginSource, /const groupName = uniqueGroupChatName\(base, taken\)/)
-  assert.match(pluginSource, /const roomId = mintGroupRoomId\(\)/)
-  assert.match(pluginSource, /room\.roomId = roomId/)
-})
-
-test('turn prompt: results are full quality — only chatter is asked to stay short', () => {
-  const gc = load(() => '(pass)')
-  const prompt = gc.buildGroupChatTurnPrompt({
-    groupName: 'Core',
-    members: [{ name: 'research', title: '' }, { name: 'builder', title: '' }],
-    viewer: { name: 'research', title: '' },
-    deltaLines: []
-  })
-  assert.match(prompt, /never thin out real content/i)
-  assert.match(prompt, /Keep chatter short/i)
-})
-
-test('threads: room composer mints a new thread; replies land in it', async () => {
-  const gc = load(() => '(pass)')
-
-  const t1 = gc.sendToGroupChat('Rooms', [{ name: 'research', title: '' }], 'first topic')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Rooms || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-  const t2 = gc.sendToGroupChat('Rooms', [{ name: 'research', title: '' }], 'second topic')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Rooms || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  assert.ok(t1 && t2 && t1 !== t2, 'each composer send mints a distinct thread')
-  const log = roomLog(gc, 'Rooms')
-  assert.equal(log[0].thread, t1)
-  assert.equal(log[1].thread, t2)
-})
-
-test('threads: replying with an explicit thread id continues that thread and scopes the member delta to it', async () => {
-  const prompts = []
-  const gc = load((profile, prompt) => {
-    prompts.push(prompt)
-    return prompt.includes('billing') ? 'On the billing fix.' : '(pass)'
-  })
-
-  const billing = gc.sendToGroupChat('Scoped', [{ name: 'research', title: '' }], 'fix the billing bug')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Scoped || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-  gc.sendToGroupChat('Scoped', [{ name: 'research', title: '' }], 'research pricing')
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Scoped || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  // Continue the BILLING thread explicitly.
-  const again = gc.sendToGroupChat('Scoped', [{ name: 'research', title: '' }], 'billing follow-up: ship it', billing)
-  for (let i = 0; i < 200 && (gc.$groupChats.get().Scoped || {}).running; i++) {
-    await new Promise(resolve => setImmediate(resolve))
-  }
-
-  assert.equal(again, billing, 'explicit thread id is reused, not re-minted')
-  const followUpPrompt = prompts.find(p => p.includes('ship it'))
-  assert.ok(followUpPrompt, 'follow-up turn ran')
-  assert.equal(followUpPrompt.includes('research pricing'), false, 'other thread never leaks into the delta')
-
-  // Member replies carry the thread of the turn that produced them.
-  const memberEntries = roomLog(gc, 'Scoped').filter(e => e.from.kind === 'member')
-  assert.ok(memberEntries.length >= 1)
-  assert.ok(memberEntries.every(e => e.thread === billing), 'replies land in the thread that triggered them')
-})
-
-test('threads: hydration assigns legacy thread ids — lull splits, follow-ups stay together', () => {
-  const gc = load(() => '(pass)')
-  assert.match(pluginSource, /function assignLegacyThreads\(log\)/)
-
-  const fn = new Function(
-    `${pluginSource.slice(pluginSource.indexOf('const GROUP_THREAD_GAP_MS'), pluginSource.indexOf('/** Merged room view'))}; return assignLegacyThreads`
-  )()
-  const M = 60000
-  const u = (text, at) => ({ from: { kind: 'user', name: 'You' }, text, at })
-  const m = (name, text, at) => ({ from: { kind: 'member', name }, text, at })
-
-  const log = fn([
-    u('task one', 0),
-    m('a', 'r1', 1 * M),
-    u('quick follow-up', 3 * M), // inside the 15-min window: SAME thread
-    m('a', 'r2', 4 * M),
-    u('new topic much later', 60 * M), // after the lull: new thread
-    m('a', 'r3', 61 * M)
-  ])
-  assert.equal(log[0].thread, log[2].thread, 'follow-up stays in the same thread')
-  assert.equal(log[2].thread, log[3].thread)
-  assert.notEqual(log[0].thread, log[4].thread, 'post-lull message starts a new thread')
-  assert.equal(log[4].thread, log[5].thread)
-  void gc
-})
-
-test('source contract: thread UI — folded rows, per-thread reply box, new-thread composer', () => {
-  assert.match(pluginSource, /Open this thread/)
-  assert.match(pluginSource, /Collapse thread/)
-  assert.match(pluginSource, /Reply in thread…/)
-  assert.match(pluginSource, /children: 'New Thread'/)
-  assert.match(pluginSource, /const markKey = `\$\{thread\}::\$\{memberKey\}`/)
-})
-
-function groupChatWorkspaceSource() {
-  const start = pluginSource.indexOf('function GroupChatWorkspace')
-  const end = pluginSource.indexOf('function closeGroupChatMainTab')
-  assert.ok(start >= 0, 'GroupChatWorkspace is defined')
-  assert.ok(end > start, 'closeGroupChatMainTab follows GroupChatWorkspace')
-  return pluginSource.slice(start, end)
-}
-
-test('source contract: group chat log lines expose CopyButton on the entry body', () => {
-  const src = groupChatWorkspaceSource()
-  assert.match(pluginSource, /CopyButton/)
-  assert.match(src, /CopyButton/)
-  assert.match(src, /text:\s*entry\.text/)
-  assert.match(src, /stopPropagation:\s*true/)
-  assert.match(src, /appearance:\s*['"]icon['"]/)
-  assert.match(src, /buttonSize:\s*['"]icon['"]/)
-  assert.match(src, /['"]group /)
-  assert.doesNotMatch(src, /playSpeechText/)
-  assert.doesNotMatch(src, /RefreshCw/)
-  assert.doesNotMatch(src, /readAloud/)
-  assert.doesNotMatch(src, /ActionBarPrimitive\.Reload/)
-})
-
-test('source contract: group chat message bodies opt back into selectable text', () => {
-  // styles.css sets user-select: none app-wide and re-enables it only for
-  // [data-selectable-text="true"] surfaces. Without this opt-in on the entry
-  // body, drag-select and Cmd/Ctrl+C are dead in group chat logs.
-  const src = groupChatWorkspaceSource()
-  assert.match(src, /'data-selectable-text':\s*'true'/)
-})
-
-test('group room preview renders the bot HANDLE, not the raw profile name', () => {
-  // #89484: the room line read "@default: …" while the bot answers to
-  // @hermes, so users concluded mention routing was broken.
-  assert.match(pluginSource, /const lastHandle = botHandle\(lastFrom \|\| 'bot', members\.find\(/)
-  assert.match(pluginSource, /\? `\$\{last\.from\?\.kind === 'user' \? 'You' : `@\$\{lastHandle\}`\}/)
-  assert.doesNotMatch(pluginSource, /`@\$\{last\.from\?\.name \|\| 'bot'\}`/)
-})
-
-// ── group clarify (#90694): member questions surface in the room ──────────
-
-const CLARIFY_PAYLOAD = {
-  request_id: 'req-clarify-1',
-  question: 'Which env should I target?',
-  choices: ['staging', 'prod'],
-  multi_select: false
-}
-
-test('a member blocked on clarify surfaces its question and holds the turn open', async () => {
-  // research reports pending_clarify on its first two resumes after the
-  // submit; the turn must NOT read it as done/pass while the question waits.
-  const gc = load(() => 'targeting staging', {
-    clarifyUntilResumeCall: { research: { payload: CLARIFY_PAYLOAD, until: 3 } }
-  })
-
-  const thread = gc.sendToGroupChat('Core', [MEMBERS[0]], '@research deploy it', null, [])
-  await new Promise(resolve => setTimeout(resolve, 0))
-  await new Promise(resolve => setTimeout(resolve, 0))
-
-  // Mirrored while blocked, cleared once the resume stops reporting it.
-  const log = gc.$groupChats.get().Core.log.filter(e => e.thread === thread)
-  const replies = log.filter(e => e.from.kind === 'member')
-
-  assert.equal(replies.length, 1, 'the finished reply still lands after the clarify clears')
-  assert.equal(replies[0].text, 'targeting staging')
-  assert.equal(Object.keys(gc.$groupClarify.get()).length, 0, 'the mirrored question is cleared once resolved')
-  // The mirror pass ran while the question was blocking: it badges the room
-  // needs-you. The sabotaged (pre-fix) poll never inspects pending_clarify,
-  // so this stays unset — the observable proof the gate executed.
-  assert.equal(gc.$groupNeedsYou.get().Core, true, 'the blocking question badged the room')
-})
-
-test('syncGroupClarify mirrors, badges needs-you, and is idempotent per request', () => {
-  const gc = load(() => '(pass)')
-  const member = { name: 'research', title: '' }
-
-  const blocked = gc.syncGroupClarify('Core', member, { pending_clarify: CLARIFY_PAYLOAD })
-  assert.equal(blocked, true)
-
-  const mirrored = Object.values(gc.$groupClarify.get())
-  assert.equal(mirrored.length, 1)
-  assert.equal(mirrored[0].requestId, 'req-clarify-1')
-  assert.equal(mirrored[0].question, 'Which env should I target?')
-  assert.equal(JSON.stringify(mirrored[0].choices), JSON.stringify(['staging', 'prod']))
-  assert.equal(gc.$groupNeedsYou.get().Core, true)
-
-  // Same request again: no new entry, identity preserved.
-  const first = mirrored[0]
-  gc.syncGroupClarify('Core', member, { pending_clarify: CLARIFY_PAYLOAD })
-  assert.equal(Object.values(gc.$groupClarify.get())[0], first)
-
-  // Question resolved server-side: the mirror clears.
-  const still = gc.syncGroupClarify('Core', member, {})
-  assert.equal(still, false)
-  assert.equal(Object.keys(gc.$groupClarify.get()).length, 0)
-})
-
-test('older backends without pending_clarify never mirror a question', () => {
-  const gc = load(() => '(pass)')
-
-  assert.equal(gc.syncGroupClarify('Core', { name: 'research' }, { messages: [] }), false)
-  assert.equal(Object.keys(gc.$groupClarify.get()).length, 0)
-})
-
-test('answerGroupClarify routes clarify.respond and clears the mirror', async () => {
-  const gc = load(() => '(pass)')
-  const member = { name: 'research', title: '' }
-
-  gc.syncGroupClarify('Core', member, { pending_clarify: CLARIFY_PAYLOAD })
-  const entry = Object.values(gc.$groupClarify.get())[0]
-
-  await gc.answerGroupClarify(entry, member, 'staging')
-
-  assert.equal(JSON.stringify(gc.clarifyResponds), JSON.stringify([{ request_id: 'req-clarify-1', answer: 'staging' }]))
-  assert.equal(Object.keys(gc.$groupClarify.get()).length, 0)
-})
-
-test('answerGroupClarify sends one respond per batch question, in order', async () => {
-  const gc = load(() => '(pass)')
-  const member = { name: 'research', title: '' }
-  const batch = {
-    request_id: 'req-batch-1',
-    questions: [
-      { qid: 'q0', question: 'Env?', choices: ['staging', 'prod'] },
-      { qid: 'q1', question: 'Region?', choices: [] }
-    ]
-  }
-
-  gc.syncGroupClarify('Core', member, { pending_clarify: batch })
-  const entry = Object.values(gc.$groupClarify.get())[0]
-
-  await gc.answerGroupClarify(entry, member, { q0: 'staging', q1: 'eu-west' })
-
-  assert.equal(
-    JSON.stringify(gc.clarifyResponds),
-    JSON.stringify([
-      { request_id: 'req-batch-1', question_id: 'q0', answer: 'staging' },
-      { request_id: 'req-batch-1', question_id: 'q1', answer: 'eu-west' }
-    ])
-  )
-  assert.equal(Object.keys(gc.$groupClarify.get()).length, 0)
-})
-
-test('disband clears the room mirrored questions', async () => {
-  const gc = load(() => '(pass)')
-
-  gc.syncGroupClarify('Core', { name: 'research' }, { pending_clarify: CLARIFY_PAYLOAD })
-  gc.syncGroupClarify('Other', { name: 'ops' }, { pending_clarify: { ...CLARIFY_PAYLOAD, request_id: 'req-2' } })
-
-  await gc.disbandGroupChat('Core', [])
-
-  const remaining = Object.values(gc.$groupClarify.get())
-  assert.equal(remaining.length, 1)
-  assert.equal(remaining[0].group, 'Other')
-})
-
-test('source contract: room renders clarify cards and the poll gates on them', () => {
-  assert.match(pluginSource, /function GroupClarifyCard\(/)
-  assert.match(pluginSource, /syncGroupClarify\(group, member, state\)/)
-  assert.match(pluginSource, /const done = !busy && !awaitingUser/)
-  assert.match(pluginSource, /busy \|\| awaitingUser/)
-  assert.match(pluginSource, /roomClarifies\.map\(entry =>/)
-  assert.match(pluginSource, /'clarify\.respond'/)
-})
-
-// ── group approvals: same hidden-session class as clarify (#90694) ─────────
-
-const APPROVAL_PAYLOAD = {
-  request_id: 'req-approval-1',
-  command: 'rm -rf ./build',
-  description: 'Clean the build directory',
-  choices: ['once', 'session', 'deny']
-}
-
-test('a member blocked on a command approval surfaces an approval card and holds the turn', async () => {
-  const gc = load(() => 'build cleaned', {
-    approvalUntilResumeCall: { research: { payload: APPROVAL_PAYLOAD, until: 3 } }
-  })
-
-  const thread = gc.sendToGroupChat('Core', [MEMBERS[0]], '@research clean up', null, [])
-  await new Promise(resolve => setTimeout(resolve, 0))
-  await new Promise(resolve => setTimeout(resolve, 0))
-
-  const log = gc.$groupChats.get().Core.log.filter(e => e.thread === thread)
-  const replies = log.filter(e => e.from.kind === 'member')
-
-  assert.equal(replies.length, 1, 'the finished reply still lands after the approval clears')
-  assert.equal(replies[0].text, 'build cleaned')
-  assert.equal(Object.keys(gc.$groupClarify.get()).length, 0)
-  assert.equal(gc.$groupNeedsYou.get().Core, true, 'the blocking approval badged the room')
-})
-
-test('syncGroupClarify mirrors an approval with kind, command, and server choices', () => {
-  const gc = load(() => '(pass)')
-  const member = { name: 'research', title: '' }
-
-  const blocked = gc.syncGroupClarify('Core', member, {
-    session_id: 'rt-research-1',
-    pending_approval: APPROVAL_PAYLOAD
-  })
-  assert.equal(blocked, true)
-
-  const entry = Object.values(gc.$groupClarify.get())[0]
-  assert.equal(entry.kind, 'approval')
-  assert.equal(entry.command, 'rm -rf ./build')
-  assert.equal(entry.question, 'Clean the build directory')
-  assert.equal(JSON.stringify(entry.choices), JSON.stringify(['once', 'session', 'deny']))
-  assert.equal(entry.sessionId, 'rt-research-1')
-})
-
-test('an approval without a server choice set falls back to once/deny', () => {
-  const gc = load(() => '(pass)')
-
-  gc.syncGroupClarify('Core', { name: 'research' }, {
-    pending_approval: { request_id: 'req-a2', command: 'ls' }
-  })
-
-  const entry = Object.values(gc.$groupClarify.get())[0]
-  assert.equal(JSON.stringify(entry.choices), JSON.stringify(['once', 'deny']))
-})
-
-test('answerGroupClarify routes approvals through approval.respond with session + choice', async () => {
-  const gc = load(() => '(pass)')
-  const member = { name: 'research', title: '' }
-
-  gc.syncGroupClarify('Core', member, { session_id: 'rt-research-1', pending_approval: APPROVAL_PAYLOAD })
-  const entry = Object.values(gc.$groupClarify.get())[0]
-
-  await gc.answerGroupClarify(entry, member, 'once')
-
-  assert.equal(
-    JSON.stringify(gc.approvalResponds),
-    JSON.stringify([{ session_id: 'rt-research-1', request_id: 'req-approval-1', choice: 'once' }])
-  )
-  assert.equal(gc.clarifyResponds.length, 0, 'approvals never touch the clarify wire')
-  assert.equal(Object.keys(gc.$groupClarify.get()).length, 0)
-})
-
-test('clarify outranks approval when a snapshot carries both', () => {
-  const gc = load(() => '(pass)')
-
-  gc.syncGroupClarify('Core', { name: 'research' }, {
-    pending_clarify: CLARIFY_PAYLOAD,
-    pending_approval: APPROVAL_PAYLOAD
-  })
-
-  const entry = Object.values(gc.$groupClarify.get())[0]
-  assert.equal(entry.kind, 'clarify')
-  assert.equal(entry.requestId, 'req-clarify-1')
-})
-
-test('source contract: approval card renders the command and routes approval.respond', () => {
-  assert.match(pluginSource, /pending_approval/)
-  assert.match(pluginSource, /'approval\.respond'/)
-  assert.match(pluginSource, /kind: 'approval'/)
-  assert.match(pluginSource, /wants to run a command/)
-})
-
-test('durableGroupChatRooms excludes tombstoned rooms — the remote-merge persist path\'s own durable-map builder, independent of updateGroupChat\'s inline one', () => {
-  const gc = load(() => '(pass)')
-
-  const durable = gc.durableGroupChatRooms({
-    Live: { tombstone: true, log: [], watermarks: {}, epoch: 4, running: false },
-    Keep: { log: [{ from: { kind: 'user' }, text: 'hi', at: 1 }], watermarks: {}, members: [] }
-  })
-
-  assert.ok(!('Live' in durable), 'tombstone excluded from the remote-merge persist path too')
-  assert.ok('Keep' in durable, 'real room still persisted')
-})
-
-test('durableGroupChatRooms carries roomId — omitting it drops the durable id on the next cold hydrate', () => {
-  const gc = load(() => '(pass)')
-
-  const durable = gc.durableGroupChatRooms({
-    Team: {
-      log: [{ from: { kind: 'user' }, text: 'hi', at: 1 }],
-      watermarks: {},
-      members: [],
-      roomId: 'room-abc123'
-    },
-    Legacy: {
-      log: [{ from: { kind: 'user' }, text: 'hi', at: 1 }],
-      watermarks: {},
-      members: []
-    }
-  })
-
-  assert.equal(durable.Team.roomId, 'room-abc123', 'immutable room identity must survive the remote-merge persist path')
-  assert.equal(durable.Legacy.roomId, null, 'a room with no roomId persists an explicit null, not undefined')
-})
-
-test('remote-merge reachability: a disband tombstone that survives a merge (gateway has not received the delete yet) is never written to storage', async () => {
-  const gc = load(() => '(pass)')
-
-  // Simulate a drive still mid-turn at disband time, exactly like the
-  // sibling disband test above — this room is a live tombstone in $groupChats.
-  gc.$groupChats.set({
-    Live: { tombstone: true, log: [], watermarks: {}, epoch: 4, running: false }
-  })
-
-  // The remote gateway has NOT yet received the delete (plausible now that
-  // sync fans out to every reachable default-profile gateway independently)
-  // — its snapshot still carries a live copy of the room under the same
-  // display name.
-  const merged = gc.mergeRemoteGroupChatSnapshotIntoRooms(
-    {
-      rooms: {
-        Live: {
-          log: [{ from: { kind: 'member', name: 'research' }, text: 'still going', at: 1 }],
-          members: [{ name: 'research' }]
-        }
-      }
-    },
-    gc.$groupChats.get()
-  )
-
-  // The merge spreads `...existing` before its explicit field overrides,
-  // none of which touch `tombstone` — so the flag survives into the merged
-  // room. This is the reachability step: without it, durableGroupChatRooms
-  // would never even see a tombstoned room from this path.
-  assert.equal(merged.Live.tombstone, true, 'tombstone forwarded by the merge (reachability precondition)')
-
-  await gc.persistGroupChatRooms(merged)
-
-  const durable = gc.storageWrites.get('group-chats')
-  assert.ok(durable && !('Live' in durable), 'merged tombstone must not resurrect as a persisted room')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-composer-drafts.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-composer-drafts.test.mjs
deleted file mode 100644
index 6c4f0d570671..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-composer-drafts.test.mjs
+++ /dev/null
@@ -1,106 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function between(start, end) {
-  const from = source.indexOf(start)
-  const to = source.indexOf(end, from)
-
-  assert.notEqual(from, -1, `missing ${start}`)
-  assert.notEqual(to, -1, `missing ${end}`)
-
-  return source.slice(from, to)
-}
-
-function load() {
-  const context = { Map, Object }
-  const roomKey = between('function groupChatRoomKey(', '/** Lift any historical projection shape')
-  const drafts = between('const groupComposerDrafts = new Map()', 'function GroupChatWorkspace(')
-
-  vm.runInNewContext(
-    `${roomKey}\n${drafts}\nglobalThis.drafts = {
-      clearGroupComposerDraft,
-      groupComposerDraftKey,
-      groupComposerDraftSnapshot,
-      migrateGroupComposerDraft,
-      restoreGroupComposerDraft,
-      updateGroupComposerDraft
-    }`,
-    context
-  )
-
-  return context.drafts
-}
-
-test('workspace retirement and re-registration restore the exact room draft', () => {
-  const drafts = load()
-  const key = drafts.groupComposerDraftKey('Launch room', { roomId: 'room-1' })
-  const attachment = { data: 'data:image/png;base64,abc', kind: 'image', name: 'plan.png' }
-
-  drafts.updateGroupComposerDraft(key, state => ({
-    ...state,
-    activeReplyThread: 'thread-1',
-    main: 'main draft',
-    pendingAttachments: { main: [attachment], 'thread-1': [attachment] },
-    replies: { 'thread-1': 'reply draft' }
-  }))
-
-  // Dropping the component reference simulates pane retirement. A fresh
-  // registration reads the same module-scope, roomId-qualified snapshot.
-  const remounted = drafts.groupComposerDraftSnapshot(key)
-
-  assert.equal(remounted.main, 'main draft')
-  assert.equal(remounted.replies['thread-1'], 'reply draft')
-  assert.equal(remounted.activeReplyThread, 'thread-1')
-  assert.equal(remounted.pendingAttachments.main[0].name, 'plan.png')
-})
-
-test('legacy name-keyed drafts migrate when an immutable room id appears', () => {
-  const drafts = load()
-  const legacy = drafts.groupComposerDraftKey('Launch room', {})
-  const current = drafts.groupComposerDraftKey('Renamed room', { roomId: 'room-1' })
-
-  drafts.updateGroupComposerDraft(legacy, state => ({ ...state, main: 'keep me' }))
-  drafts.migrateGroupComposerDraft(legacy, current)
-
-  assert.equal(drafts.groupComposerDraftSnapshot(current).main, 'keep me')
-  assert.equal(drafts.groupComposerDraftSnapshot(legacy).main, '')
-})
-
-test('a failed send cannot overwrite text entered after the optimistic clear', () => {
-  const drafts = load()
-  const key = 'id:room-1'
-
-  drafts.updateGroupComposerDraft(key, state => ({ ...state, main: 'send this' }))
-  const before = drafts.groupComposerDraftSnapshot(key)
-  const cleared = drafts.updateGroupComposerDraft(key, state => ({ ...state, main: '' }))
-
-  drafts.updateGroupComposerDraft(key, state => ({ ...state, main: 'newer typing' }))
-
-  assert.equal(drafts.restoreGroupComposerDraft(key, cleared.revision, before), null)
-  assert.equal(drafts.groupComposerDraftSnapshot(key).main, 'newer typing')
-})
-
-test('disband removes only that room draft', () => {
-  const drafts = load()
-
-  drafts.updateGroupComposerDraft('id:a', state => ({ ...state, main: 'a' }))
-  drafts.updateGroupComposerDraft('id:b', state => ({ ...state, main: 'b' }))
-  drafts.clearGroupComposerDraft('id:a')
-
-  assert.equal(drafts.groupComposerDraftSnapshot('id:a').main, '')
-  assert.equal(drafts.groupComposerDraftSnapshot('id:b').main, 'b')
-})
-
-test('GroupChatWorkspace owns composer state through the room draft store', () => {
-  const workspace = between('function GroupChatWorkspace(', '/** Live closers for group-chat MAIN-window tabs')
-
-  assert.match(workspace, /groupComposerDraftKey\(group, room\)/)
-  assert.match(workspace, /restoreGroupComposerDraft\(composerKeyRef\.current, cleared\.revision, before\)/)
-  assert.match(workspace, /clearGroupComposerDraft\(composerKeyRef\.current\)/)
-  assert.doesNotMatch(workspace, /useState\(''\).*?draft/)
-  assert.doesNotMatch(workspace, /useState\(\{\}\).*?replyDrafts/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-member-hold.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-member-hold.test.mjs
deleted file mode 100644
index 490152d8fed9..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-member-hold.test.mjs
+++ /dev/null
@@ -1,128 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #93129: a bot told to stop must STAY stopped. The hold helpers are pure and
-// vm-sliced out of plugin.js exactly like group-turn-races.test.mjs does for
-// the #93127 helpers. NOTE: vm-realm arrays/objects fail strict deepEqual
-// against host literals (different realm prototypes) — normalize with spread
-// or JSON round-trip before comparing.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadHelpers() {
-  const start = pluginSource.indexOf('// --- member-hold helpers (#93129)')
-  const end = pluginSource.indexOf('// --- end member-hold helpers ---', start)
-  assert.notEqual(start, -1, 'plugin carries the member-hold helper block')
-  assert.notEqual(end, -1, 'member-hold helper block has a stable end marker')
-  const context = {}
-  vm.runInNewContext(
-    `${pluginSource.slice(start, end)}
-globalThis.classifyGroupHoldDirective = classifyGroupHoldDirective
-globalThis.applyGroupHoldDirective = applyGroupHoldDirective
-globalThis.heldMemberWatermarkAdvance = heldMemberWatermarkAdvance`,
-    context
-  )
-  return context
-}
-
-// ── stop detection ───────────────────────────────────────────────────────────
-
-test('explicit stop with a mention holds the mentioned member', () => {
-  const { classifyGroupHoldDirective } = loadHelpers()
-  for (const text of ['stop @impl', '@impl stop', '@impl please halt', 'pause @impl for now']) {
-    const action = classifyGroupHoldDirective(text, ['impl'], false)
-    assert.deepEqual([...action.hold], ['impl'], `"${text}" should hold`)
-    assert.deepEqual([...action.release], [])
-  }
-})
-
-test('stop word without any mention holds nobody', () => {
-  const { classifyGroupHoldDirective } = loadHelpers()
-  const action = classifyGroupHoldDirective('stop', [], false)
-  assert.deepEqual([...action.hold], [])
-})
-
-test('conservative choice: "don\'t stop @x" still holds (documented trade-off)', () => {
-  const { classifyGroupHoldDirective } = loadHelpers()
-  const action = classifyGroupHoldDirective("don't stop @impl", ['impl'], false)
-  assert.deepEqual([...action.hold], ['impl'])
-})
-
-test('"stopped" as part of another word does not trigger a hold', () => {
-  const { classifyGroupHoldDirective } = loadHelpers()
-  // \b(stop|halt|pause)\b — "stopped" is a different token
-  const action = classifyGroupHoldDirective('@impl unstoppable work ahead', ['impl'], false)
-  assert.deepEqual([...action.hold], [])
-  // a plain non-stop mention releases instead (direct address overrides hold)
-  assert.deepEqual([...action.release], ['impl'])
-})
-
-// ── hold lifecycle ───────────────────────────────────────────────────────────
-
-test('stop sets a hold; resume for the same member clears it', () => {
-  const { applyGroupHoldDirective } = loadHelpers()
-  const stamp = { at: 1000, byMessageId: 'm1', thread: 't1' }
-  const held = applyGroupHoldDirective({}, { mentioned: ['impl'], everyone: false }, 'stop @impl', stamp)
-  assert.ok(held.impl)
-  assert.equal(held.impl.at, 1000)
-  const released = applyGroupHoldDirective(held, { mentioned: ['impl'], everyone: false }, '@impl resume', stamp)
-  assert.equal(released.impl, undefined)
-})
-
-test('a direct non-stop mention of a held member releases the hold', () => {
-  const { applyGroupHoldDirective } = loadHelpers()
-  const held = { impl: { at: 1, byMessageId: null, thread: null } }
-  const next = applyGroupHoldDirective(held, { mentioned: ['impl'], everyone: false }, '@impl what is your status?', {})
-  assert.equal(next.impl, undefined)
-})
-
-test('@all resume releases every hold', () => {
-  const { applyGroupHoldDirective } = loadHelpers()
-  const held = { impl: { at: 1 }, docs: { at: 2 } }
-  const next = applyGroupHoldDirective(held, { mentioned: [], everyone: true }, '@all resume', {})
-  assert.deepEqual(JSON.parse(JSON.stringify(next)), {})
-})
-
-test('@all stop holds every member — symmetric with @all resume', () => {
-  const { applyGroupHoldDirective } = loadHelpers()
-  const next = applyGroupHoldDirective(
-    {},
-    { mentioned: [], everyone: true },
-    '@all stop',
-    { at: 5 },
-    ['impl', 'docs']
-  )
-  assert.ok(next.impl)
-  assert.ok(next.docs)
-  assert.equal(next.impl.at, 5)
-})
-
-test('an unrelated room message leaves holds untouched (same object back)', () => {
-  const { applyGroupHoldDirective } = loadHelpers()
-  const held = { impl: { at: 1 } }
-  const next = applyGroupHoldDirective(held, { mentioned: [], everyone: false }, 'receipt round complete', {})
-  assert.equal(next, held)
-})
-
-test('holding one member does not disturb another\'s hold', () => {
-  const { applyGroupHoldDirective } = loadHelpers()
-  const held = { impl: { at: 1 } }
-  const next = applyGroupHoldDirective(held, { mentioned: ['docs'], everyone: false }, 'stop @docs', { at: 2 })
-  assert.ok(next.impl)
-  assert.ok(next.docs)
-})
-
-// ── skip must not spin ───────────────────────────────────────────────────────
-
-test('held skip consumes the delta exactly once', () => {
-  const { heldMemberWatermarkAdvance } = loadHelpers()
-  // fresh delta → advance to log length
-  assert.equal(heldMemberWatermarkAdvance(3, 7), 7)
-  // already consumed → no write, no spin
-  assert.equal(heldMemberWatermarkAdvance(7, 7), null)
-  assert.equal(heldMemberWatermarkAdvance(9, 7), null)
-  // unset watermark treated as 0
-  assert.equal(heldMemberWatermarkAdvance(undefined, 2), 2)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-mention-composer.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-mention-composer.test.mjs
deleted file mode 100644
index f792b3f68d12..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-mention-composer.test.mjs
+++ /dev/null
@@ -1,69 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Group-composer mentions (#89049): the room's "new thread" composer and the
-// reply-in-thread box mount a member-scoped @-mention popover instead of a
-// dead plain Input. Source-shape assertions plus a functional check of the
-// caret tokenizer, extracted and run in isolation.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('group room composers mount GroupMentionInput, not bare Input', () => {
-  // Main composer (new thread) and thread reply box both use the wrapper.
-  const mainComposer = source.match(/jsx\(GroupMentionInput, \{\s*'aria-label': `Message \$\{group\}`/)
-  const replyComposer = source.match(/jsx\(GroupMentionInput, \{\s*'aria-label': 'Reply in thread'/)
-  assert.ok(mainComposer, 'main group composer must render GroupMentionInput')
-  assert.ok(replyComposer, 'thread reply box must render GroupMentionInput')
-
-  // Neither composer renders a dead plain Input anymore.
-  assert.ok(!/jsx\(Input, \{\s*'aria-label': `Message \$\{group\}`/.test(source))
-  assert.ok(!/jsx\(Input, \{\s*'aria-label': 'Reply in thread'/.test(source))
-
-  // Both receive the seated members for the popover scope (onSubmitDraft
-  // rides along so Enter submits from the multi-line textarea, #89884).
-  assert.ok(/GroupMentionInput\(\{ members, onChange, onSubmitDraft, value/.test(source))
-})
-
-test('popover offers @everyone/@all and inserts parser-compatible strings', () => {
-  const component = source.slice(
-    source.indexOf('function GroupMentionInput'),
-    source.indexOf('function GroupChatWorkspace')
-  )
-  assert.ok(component.includes("['everyone', 'all']"), 'quick picks for the room-wide broadcast')
-  // Insertion writes exactly "@handle " — the shape parseGroupChatMentions resolves.
-  assert.ok(component.includes('`${value.slice(0, token.start)}@${handle} ${value.slice(caret)}`'))
-  // Member handles come from the same botHandle used by the parser.
-  assert.ok(component.includes('botHandle(member.name, member)'))
-  // mousedown insertion must preventDefault so the input keeps focus.
-  assert.ok(/onMouseDown: event => \{\s*event\.preventDefault\(\)/.test(component))
-})
-
-test('mentionTokenAt finds the active @-token at the caret', () => {
-  const start = source.indexOf('function mentionTokenAt')
-  const end = source.indexOf('function GroupMentionInput')
-  assert.ok(start > 0 && end > start, 'mentionTokenAt must precede GroupMentionInput')
-
-  const ctx = {}
-  vm.createContext(ctx)
-  vm.runInContext(source.slice(start, end) + '\nthis.fn = mentionTokenAt', ctx)
-  const fn = ctx.fn
-
-  // Mid-word @ tokens resolve with the right query + start offset.
-  // (Field-wise compare: vm-context objects have a foreign Object prototype,
-  // which strict deepEqual rejects.)
-  const eq = (actual, expected) => {
-    assert.equal(actual?.query, expected?.query)
-    assert.equal(actual?.start, expected?.start)
-  }
-  eq(fn('hey @al', 7), { query: 'al', start: 4 })
-  eq(fn('@', 1), { query: '', start: 0 })
-  eq(fn('ping @every', 11), { query: 'every', start: 5 })
-
-  // Not a mention context: no token → popover stays closed.
-  assert.equal(fn('email me a@b', 12), null)
-  assert.equal(fn('plain text', 10), null)
-  // Caret before the @ is not inside the token.
-  assert.equal(fn('hey @al', 3), null)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-room-ux.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-room-ux.test.mjs
deleted file mode 100644
index c52ede26d588..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-room-ux.test.mjs
+++ /dev/null
@@ -1,98 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// Room UX cluster (Aug 2026 desktop audit): three confirmed defects in the
-// group-chat surface, fixed together.
-//
-//   #89884 — the composer was a single-line Input; Enter always submitted and
-//            multi-line prompts were impossible.
-//   #89835 — rooms opened at scroll position 0 with no anchoring; new replies
-//            streamed in below the fold.
-//   #89545 — a member whose reply outlived the turn loop stayed stranded
-//            until the user's NEXT send (harvest only ran inside the loop).
-
-test('room composer is a textarea with Enter=submit, Shift+Enter=newline (#89884)', () => {
-  // Slice ONLY GroupMentionInput — functions merged between it and
-  // GroupChatWorkspace (e.g. GroupClarifyCard) legitimately use Input.
-  const start = source.indexOf('function GroupMentionInput')
-  const nextFn = source.indexOf('\nfunction ', start + 1)
-  const component = source.slice(start, nextFn)
-
-  // The control is the SDK Textarea, not the single-line Input.
-  assert.match(component, /jsx\(Textarea, \{/)
-  assert.doesNotMatch(component, /jsx\(Input, \{/)
-  // Enter (no Shift) submits through the injected handler...
-  assert.match(component, /event\.key === 'Enter' && !event\.shiftKey/)
-  assert.match(component, /onSubmitDraft\?\.\(\)/)
-  // ...and the popover branch still owns Enter while it is open.
-  assert.match(component, /insert\(options\[active\]\.handle\)/)
-})
-
-test('room composer swallows IME composition Enters before submit/mention (#93528)', () => {
-  // macOS Chinese IME: Enter that confirms a candidate word fires a keydown
-  // the composer mistook for a send — the message went out mid-composition.
-  // The guard must run BEFORE the popover branch AND the submit branch, and
-  // cover both Chromium's isComposing flag and the keyCode 229 legacy
-  // VK_PROCESSKEY that macOS IMEs emit after compositionend.
-  const start = source.indexOf('function GroupMentionInput')
-  const nextFn = source.indexOf('\nfunction ', start + 1)
-  const component = source.slice(start, nextFn)
-
-  const guard = component.indexOf('event.nativeEvent?.isComposing || event.keyCode === 229')
-  assert.ok(guard >= 0, 'IME guard present in GroupMentionInput')
-  const afterGuard = component.slice(guard)
-  // Guard returns immediately (no mention insert, no submit)...
-  assert.match(afterGuard.slice(0, 80), /return/)
-  // ...and it sits before both the popover branch and the submit branch.
-  assert.ok(afterGuard.indexOf('if (open) {') > 0, 'guard precedes popover branch')
-  assert.ok(component.indexOf("event.key === 'Enter' && !event.shiftKey") > guard, 'guard precedes submit branch')
-})
-
-test('clarify free-text input swallows IME composition Enters (#93528)', () => {
-  const clarify = source.slice(source.indexOf('function GroupClarifyCard'), source.indexOf('function openGroupChat'))
-  const guard = clarify.indexOf('event.nativeEvent?.isComposing || event.keyCode === 229')
-  assert.ok(guard >= 0, 'IME guard present in GroupClarifyCard')
-  assert.ok(clarify.indexOf("event.key === 'Enter' && questions.length === 1") > guard, 'guard precedes submit branch')
-})
-
-test('both room composers wire onSubmitDraft (#89884)', () => {
-  assert.match(source, /onSubmitDraft: submit,/)
-  assert.match(source, /onSubmitDraft: \(\) => submitReply\(id\),/)
-})
-
-test('room log anchors to the bottom with a user-scroll guard (#89835)', () => {
-  const workspace = source.slice(source.indexOf('function GroupChatWorkspace'))
-  assert.match(workspace, /bottomSentinelRef/)
-  assert.match(workspace, /stickToBottomRef/)
-  // Effect keys on log growth; the guard keeps history reading stable.
-  assert.match(workspace, /\[room\.log\.length, room\.running\]/)
-  assert.match(workspace, /scrollIntoView/)
-})
-
-test('retained-pane reopen re-anchors to the bottom (#89835 follow-up)', () => {
-  // A hot-mounted room pane never remounts when the user tabs back to it, so
-  // the workspace re-anchors on the hidden → visible edge, fed by the
-  // feature-detected host.paneVisibility authority (always-visible fallback
-  // keeps older SDKs on the previous behavior).
-  const workspace = source.slice(source.indexOf('function GroupChatWorkspace'))
-  assert.match(workspace, /visible = true/)
-  assert.match(workspace, /wasVisibleRef/)
-  assert.match(workspace, /\[visible\]/)
-  const mainView = source.slice(source.indexOf('function GroupChatMainView'), source.indexOf('function openGroupChat'))
-  assert.match(mainView, /typeof host\.paneVisibility === 'function'/)
-  assert.match(mainView, /plugin-workspace:\$\{ID\}:group:\$\{slugify\(group\)\}/)
-  assert.match(mainView, /atom\(true\)/)
-})
-
-test('stranded replies get a bounded background harvest after the loop settles (#89545)', () => {
-  assert.match(source, /function harvestStrandedUntilSettled\(/)
-  // The loop's finally block kicks it off only when members remain stranded.
-  assert.match(source, /strandedLeft\.length/)
-  // Bounded: interval + max tries, and it yields to a live loop.
-  const harvester = source.slice(source.indexOf('async function harvestStrandedUntilSettled'))
-  assert.match(harvester.slice(0, 1600), /HARVEST_MAX_TRIES/)
-  assert.match(harvester.slice(0, 1600), /room\.running/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-stop-thread.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-stop-thread.test.mjs
deleted file mode 100644
index 37bf1365f660..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-stop-thread.test.mjs
+++ /dev/null
@@ -1,308 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #91868/#94569: a REAL stop path for group-chat rounds. Before
-// stopGroupThread, the loop's only cancellation primitives were the epoch
-// bump (checked at member boundaries only) and #93129 holds (skip FUTURE
-// turns) — the plugin issued ZERO session.interrupt RPCs, so "stop" meant
-// "wait for the in-flight member to finish its whole model turn". The
-// primitive bumps the epoch, holds every member, interrupts the member ON
-// TURN, and the runGroupChatMemberTurnLeased poll loop abandons a turn whose
-// epoch went stale while its member is held.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** Harness mirroring group-turn-lease.test.mjs: run plugin.js in a vm with a
- *  scripted gateway. `busyPolls` makes session.resume report the member as
- *  inflight for the first N polls, so a stop can land mid-turn. */
-function load({ reply = 'long answer', busyPolls = 0, onResumePoll = null } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-
-  const sessions = new Map()
-  const runtimeToStored = new Map()
-  const titleToStored = new Map()
-  let sessionSequence = 0
-  const rpcLog = []
-  let resumePolls = 0
-
-  const resolveSession = (profile, target) =>
-    (stored => (stored ? sessions.get(stored) : null))(
-      runtimeToStored.get(target) || (sessions.has(target) ? target : titleToStored.get(`${profile}::${target}`))
-    )
-
-  const handle = async (method, params) => {
-    rpcLog.push({ method, params })
-
-    if (method === 'session.create') {
-      sessionSequence += 1
-      const stored = `sid-${sessionSequence}`
-      const runtime = `rt-${sessionSequence}`
-      const session = { stored, runtime, profile: params.profile, title: params.title, messages: [] }
-      sessions.set(stored, session)
-      runtimeToStored.set(runtime, stored)
-      titleToStored.set(`${params.profile}::${params.title}`, stored)
-      return { session_id: runtime, stored_session_id: stored, message_count: 0, messages: [] }
-    }
-
-    if (method === 'session.resume') {
-      const session = resolveSession(params.profile, params.session_id)
-
-      if (!session) {
-        const err = new Error(`session not found: ${params.session_id}`)
-        err.code = 4007
-        throw err
-      }
-
-      sessionSequence += 1
-      const runtime = `rt-${sessionSequence}`
-      session.runtime = runtime
-      runtimeToStored.set(runtime, session.stored)
-
-      // Post-submit polls: stay "busy" for the first `busyPolls` polls so a
-      // stop can land mid-turn, then settle. `onResumePoll` lets a test fire
-      // the stop from inside the poll cadence.
-      const submitted = session.messages.length > 0
-      let busy = false
-
-      if (submitted) {
-        resumePolls += 1
-        busy = resumePolls <= busyPolls
-
-        if (typeof onResumePoll === 'function') {
-          onResumePoll(resumePolls)
-        }
-      }
-
-      return {
-        session_id: runtime,
-        session_key: session.stored,
-        message_count: busy ? 0 : session.messages.length,
-        messages: busy ? [] : [...session.messages],
-        inflight: busy,
-        running: false
-      }
-    }
-
-    if (method === 'prompt.submit') {
-      const session = resolveSession(null, params.session_id)
-
-      if (!session) {
-        const err = new Error(`session-scoped RPC rejected: ${params.session_id} not in memory`)
-        err.code = 4001
-        throw err
-      }
-
-      session.messages.push({ role: 'user', content: params.text })
-      session.messages.push({ role: 'assistant', content: reply })
-      return {}
-    }
-
-    if (method === 'session.interrupt') {
-      return { interrupted: true }
-    }
-
-    return {}
-  }
-
-  const context = {
-    atom,
-    setTimeout: fn => {
-      fn()
-      return 0
-    },
-    clearTimeout: () => undefined,
-    Date,
-    console,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: async (method, params) => handle(method, params),
-      requestProfile: async (route, method, params) => handle(method, params),
-      retainProfile: async () => () => undefined,
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } },
-      notify: () => undefined,
-      notifyError: () => undefined
-    }
-  }
-
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__stop = { stopGroupThread, runGroupChatMemberTurn, $groupChats, $groupActivity, currentGroupActivity, updateGroupChat, GROUP_ACTIVITY_LABELS, GROUP_ACTIVITY_GLYPHS };\n'
-    )
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  context.plugin.register({
-    storage: { get: () => null, set: () => undefined },
-    register: () => undefined
-  })
-  return {
-    ...context.__stop,
-    context,
-    rpcLog,
-    calls: method => rpcLog.filter(entry => entry.method === method)
-  }
-}
-
-const MEMBERS = [
-  { name: 'alpha', title: '' },
-  { name: 'beta', title: '' },
-  { name: 'gamma', title: '' }
-]
-
-/** Seed a room mid-round: epoch 3, running, alpha on turn with a live
- *  session id, nobody held yet. */
-function seedRoom(gc, { turn = 'alpha' } = {}) {
-  gc.$groupChats.set({
-    Room: {
-      log: [],
-      watermarks: {},
-      sessions: { alpha: 'live-alpha-sid' },
-      epoch: 3,
-      running: true,
-      turn,
-      holds: {},
-      members: MEMBERS
-    }
-  })
-}
-
-test('stopGroupThread bumps the epoch, clears running/turn, and holds every member', async () => {
-  const gc = load()
-  seedRoom(gc)
-
-  await gc.stopGroupThread('Room', 't1', MEMBERS)
-
-  const room = gc.$groupChats.get().Room
-  assert.equal(room.epoch, 4, 'epoch bumped — the driving loop bails at its next boundary')
-  assert.equal(room.running, false)
-  assert.equal(room.turn, null)
-
-  for (const member of MEMBERS) {
-    assert.ok(room.holds[member.name], `${member.name} is held — no future turn until an explicit release`)
-    assert.equal(room.holds[member.name].thread, 't1')
-  }
-})
-
-test('stopGroupThread interrupts the member ON TURN via its live session', async () => {
-  const gc = load()
-  seedRoom(gc, { turn: 'alpha' })
-
-  await gc.stopGroupThread('Room', 't1', MEMBERS)
-
-  const interrupts = gc.calls('session.interrupt')
-  assert.equal(interrupts.length, 1, 'exactly one interrupt — the serial loop has one member in flight')
-  assert.equal(interrupts[0].params.session_id, 'live-alpha-sid')
-})
-
-test('stopGroupThread with nobody on turn stops the room without any interrupt RPC', async () => {
-  const gc = load()
-  seedRoom(gc, { turn: null })
-
-  await gc.stopGroupThread('Room', 't1', MEMBERS)
-
-  assert.equal(gc.calls('session.interrupt').length, 0)
-  assert.equal(gc.$groupChats.get().Room.running, false)
-  assert.equal(gc.$groupChats.get().Room.epoch, 4)
-})
-
-test('stopGroupThread records a stopped activity event visible in the CURRENT run', async () => {
-  const gc = load()
-  seedRoom(gc)
-
-  await gc.stopGroupThread('Room', 't1', MEMBERS)
-
-  const events = gc.currentGroupActivity('Room')
-  const stopped = events.find(event => event.kind === 'stopped')
-  assert.ok(stopped, 'stopped event is tagged with the POST-bump epoch, so it survives the epoch filter')
-  assert.equal(stopped.member, 'You')
-  assert.equal(stopped.thread, 't1')
-  // The label comes from the shared GROUP_ACTIVITY_LABELS map (the plugin's
-  // label pattern) — and stays plain English, no hardcoded localized text.
-  assert.ok(gc.GROUP_ACTIVITY_LABELS.stopped)
-  assert.ok(gc.GROUP_ACTIVITY_GLYPHS.stopped)
-})
-
-test('stopGroupThread falls back to the durable room roster when called without members', async () => {
-  const gc = load()
-  seedRoom(gc)
-
-  await gc.stopGroupThread('Room', 't1')
-
-  const room = gc.$groupChats.get().Room
-  assert.equal(Object.keys(room.holds).length, MEMBERS.length)
-  assert.equal(gc.calls('session.interrupt').length, 1)
-})
-
-test('poll loop abandons an in-flight turn once a stop bumps the epoch and holds the member', async () => {
-  let gcRef = null
-  const gc = load({
-    busyPolls: 50,
-    onResumePoll: polls => {
-      // Fire the stop from inside the poll cadence, after the second
-      // busy poll — exactly the mid-turn click the Stop button produces.
-      if (polls === 2) {
-        void gcRef.stopGroupThread('Room', 't1', [{ name: 'helper', title: '' }])
-      }
-    }
-  })
-  gcRef = gc
-
-  const reply = await gc.runGroupChatMemberTurn('Room', { name: 'helper', title: '' }, 'long task', 't1', [])
-
-  assert.equal(reply, null, 'abandoned turn yields no reply')
-  const postStopPolls = gc.calls('session.resume').length
-  assert.ok(postStopPolls <= 6, `poll loop exited promptly after the stop, not at the deadline (${postStopPolls} resumes)`)
-  assert.equal(gc.$groupChats.get().Room.running, false)
-})
-
-test('an ordinary newer-send epoch bump WITHOUT a hold does not abandon the poll — late work still lands', async () => {
-  let gcRef = null
-  const gc = load({
-    reply: 'finished anyway',
-    busyPolls: 3,
-    onResumePoll: polls => {
-      if (polls === 1) {
-        // A newer user send bumps the epoch but holds nobody. The in-flight
-        // poll must keep going so the finished reply can still be delivered
-        // (the #93127 commit check decides its fate at the boundary).
-        gcRef.updateGroupChat('Room', r => {
-          r.epoch = (r.epoch || 0) + 1
-          return r
-        })
-      }
-    }
-  })
-  gcRef = gc
-
-  const reply = await gc.runGroupChatMemberTurn('Room', { name: 'helper', title: '' }, 'long task', 't1', [])
-
-  assert.equal(reply, 'finished anyway', 'epoch churn alone never abandons a live turn')
-})
-
-test('Stop button: workspace renders it while the room is running and wires it to stopGroupThread', () => {
-  const workspace = pluginSource.slice(pluginSource.indexOf('function GroupChatWorkspace'))
-  // Visible while a round is running…
-  assert.match(workspace, /room\.running\s*\?\s*jsx\('button'/, 'Stop button is gated on room.running')
-  // …and wired to the real primitive, not a per-member interrupt spray.
-  assert.match(workspace, /stopGroupThread\(/, 'button calls the stopGroupThread primitive')
-  assert.doesNotMatch(workspace, /stopAllBots/, 'the #94570 interrupt-only shell was rewired, not kept')
-})
-
-test('no hardcoded CJK label in the room workspace (the #94570 shell shipped a localized 停止)', () => {
-  const workspace = pluginSource.slice(pluginSource.indexOf('function GroupChatWorkspace'))
-  assert.doesNotMatch(workspace, /停止/, 'the #94570 hardcoded label must not survive the salvage')
-  assert.doesNotMatch(workspace, /[\u4e00-\u9fff]/, 'labels stay in the plugin label pattern — plain English strings')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-to-local-bot-handoff.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-to-local-bot-handoff.test.mjs
deleted file mode 100644
index 8feedb4a20d0..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-to-local-bot-handoff.test.mjs
+++ /dev/null
@@ -1,120 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-const atom = initial => {
-  let value = initial
-  return { get: () => value, set: next => { value = typeof next === 'function' ? next(value) : next }, listen: () => () => {} }
-}
-const jsx = (type, props = {}) => ({ type, props })
-const find = (tree, predicate) => {
-  if (tree == null || typeof tree !== 'object') return null
-  if (Array.isArray(tree)) {
-    for (const child of tree) { const match = find(child, predicate); if (match) return match }
-    return null
-  }
-  return predicate(tree) ? tree : find(tree.props?.children, predicate)
-}
-
-function load({ rejectOpen = false, rejectPrepare = false } = {}) {
-  const timeline = []
-  const host = {
-    state: {
-      profile: { get: () => 'default', listen: () => {} },
-      gateway: { get: () => 'open', listen: () => {} },
-      connectionId: { get: () => 'local', listen: () => {} }
-    },
-    request: async () => ({ profiles: [], sessions: [] }),
-    notify: () => {}, notifyError: error => timeline.push({ type: 'error', error }),
-    openSession: async () => {}, ensureAgent: async () => {}, requestProfile: async () => ({}),
-    activeConnectionId: () => 'local', warmAgent: () => {}, warmProfile: () => {},
-    newChat: () => timeline.push({ type: 'newChat' }), navigate: () => {}
-  }
-  const ui = 'Button Checkbox Codicon ConfirmDialog ContextMenu ContextMenuContent ContextMenuItem ContextMenuSeparator ContextMenuTrigger CopyButton Dialog DialogContent DialogDescription DialogFooter DialogHeader DialogTitle DropdownMenu DropdownMenuContent DropdownMenuItem DropdownMenuTrigger EmptyState GlyphSpinner Input ScrollArea SearchField Select SelectContent SelectItem SelectTrigger SelectValue Switch Textarea Tip'.split(' ')
-  const context = {
-    atom, jsx, jsxs: jsx, cn: (...values) => values.filter(Boolean).join(' '), haptic: () => {},
-    useEffect: () => {}, useMemo: fn => fn(), useRef: value => ({ current: typeof value === 'function' ? value() : value }),
-    useState: value => [typeof value === 'function' ? value() : value, () => {}],
-    useValue: store => store?.get ? store.get() : store,
-    useQuery: () => ({ data: [], isLoading: false, isFetching: false, refetch: () => {} }),
-    ...Object.fromEntries(ui.map(name => [name, name])),
-    PALETTE_AREA: 'palette', COMPOSER_AREAS: { middleware: 'middleware' },
-    profileColor: () => '#000', queryClient: { invalidateQueries: () => {} }, relativeTime: () => 'now',
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => {} } },
-    setTimeout, clearTimeout, console, Date, Math, JSON, Promise, Map, Set, URL, Error,
-    Array, Object, String, Boolean, Number, RegExp, host
-  }
-  const code = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__h={BotRow,BotsPane,openRosterBot,openGroupChat,groupChatMainTabs,$groupChatWorkspace,$groupChats};')
-  vm.runInNewContext(code, context, { filename: 'plugin.js' })
-  context.openBotCanonicalChat = async bot => {
-    timeline.push({ type: 'canonicalOpen', bot })
-    if (rejectOpen) throw new Error('canonical open failed')
-    return { registryId: 'stored-chat', openedId: 'stored-chat' }
-  }
-  if (rejectPrepare) context.prepareBotSource = async () => { throw new Error('source preparation failed') }
-  const api = context.__h
-  const registerGroup = group => {
-    api.$groupChats.set({ ...api.$groupChats.get(), [group]: { log: [], watermarks: {}, sessions: {}, stranded: {} } })
-    host.openWorkspace = id => () => timeline.push({ type: 'workspaceClose', id })
-    api.openGroupChat(group)
-    return { closed: () => timeline.filter(event => event.type === 'workspaceClose' && event.id.includes(':group:')).length }
-  }
-  const botRow = bot => {
-    const tree = api.BotRow({ bot, onEdit: () => {} })
-    return tree.type === 'button' ? tree : tree.props.children[0].props.children
-  }
-  const activeOnOpen = find(api.BotsPane(), node => node?.props && typeof node.props.onOpen === 'function' && 'roster' in node.props).props.onOpen
-  return { api, timeline, registerGroup, botRow, activeOnOpen }
-}
-
-const drain = async () => { await new Promise(resolve => setImmediate(resolve)); await new Promise(resolve => setImmediate(resolve)) }
-const bot = { name: 'alpha', title: 'Alpha' }
-const assertCloseBeforeOpen = runtime => {
-  const closed = runtime.timeline.findIndex(event => event.type === 'workspaceClose' && event.id.includes(':group:'))
-  const opened = runtime.timeline.findIndex(event => event.type === 'canonicalOpen')
-  assert.ok(closed >= 0 && opened >= 0 && closed < opened)
-}
-
-test('central owner open closes the registered group tab before canonical open', async () => {
-  const runtime = load(), tab = runtime.registerGroup('Core')
-  assert.equal(await runtime.api.openRosterBot(bot), true)
-  assert.equal(tab.closed(), 1)
-  assert.equal(runtime.api.groupChatMainTabs.has('Core'), false)
-  assertCloseBeforeOpen(runtime)
-})
-
-test('BotRow and Active Now both delegate through the central owner open', async () => {
-  for (const invoke of [runtime => runtime.botRow(bot).props.onClick(), runtime => runtime.activeOnOpen(bot)]) {
-    const runtime = load(); runtime.registerGroup('Core'); invoke(runtime); await drain(); assertCloseBeforeOpen(runtime)
-  }
-})
-
-test('failed canonical open restores the group fallback and surfaces an error', async () => {
-  const runtime = load({ rejectOpen: true }), tab = runtime.registerGroup('Core')
-  assert.equal(await runtime.api.openRosterBot(bot), false)
-  assert.equal(tab.closed(), 1)
-  assert.equal(runtime.api.$groupChatWorkspace.get(), 'Core')
-  assert.equal(runtime.api.groupChatMainTabs.has('Core'), true)
-  assert.ok(runtime.timeline.some(event => event.type === 'error'))
-})
-
-test('failed source preparation restores the group fallback', async () => {
-  const runtime = load({ rejectPrepare: true }); runtime.registerGroup('Core')
-  assert.equal(await runtime.api.openRosterBot({ ...bot, sourceScoped: true, connectionId: 'local' }), false)
-  assert.equal(runtime.api.$groupChatWorkspace.get(), 'Core')
-})
-
-test('owner open with no selected group is safe', async () => {
-  const runtime = load()
-  assert.equal(await runtime.api.openRosterBot(bot), true)
-  assert.equal(runtime.timeline.some(event => event.type === 'workspaceClose' && event.id.includes(':group:')), false)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-turn-lease.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-turn-lease.test.mjs
deleted file mode 100644
index 446611e4f51d..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-turn-lease.test.mjs
+++ /dev/null
@@ -1,303 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #93602: sub-profile bot silent in a group room. A member turn is a
-// session-scoped RPC sequence (resume → attach → prompt.submit → poll) issued
-// with the runtime id its FIRST rpc minted, but every requestForBot call rides
-// its own request-scoped socket lease — at refcount 0 the leased secondary is
-// disposed, the gateway detaches the runtime session on WS disconnect, the
-// orphan reaper frees it, and the next RPC dies 4001 "not in memory" with no
-// reply in the room. The fix holds a retained per-turn lease
-// (host.retainProfile) across the whole sequence and adds a one-shot
-// catch-and-retry on prompt.submit that re-resumes via the STORED id.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** Harness mirroring group-chat-attachments.test.mjs, extended with a
- *  refcounted host.requestProfile/host.retainProfile pair so socket lease
- *  lifetimes are assertable. */
-function load({ failFirstSubmitWith = null, failEverySubmitWith = null, reply = 'hello from turn', replyMessages = null } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-
-  const sessions = new Map()
-  const runtimeToStored = new Map()
-  const titleToStored = new Map()
-  let sessionSequence = 0
-  let submits = 0
-  const rpcLog = []
-
-  // Mock socket-pool refcount for the member's route: every RPC takes a
-  // per-request lease (acquire → handle → release), exactly like
-  // requestGatewayForAgent in store/gateway.ts. `disposals` counts every time
-  // the refcount hits 0 — each one is a socket close that reaps the runtime
-  // session in production.
-  let refcount = 0
-  let disposals = 0
-  const timeline = []
-
-  const acquire = () => {
-    refcount += 1
-  }
-  const release = () => {
-    refcount -= 1
-    if (refcount === 0) {
-      disposals += 1
-    }
-  }
-
-  const resolveSession = (profile, target) =>
-    (stored => (stored ? sessions.get(stored) : null))(
-      runtimeToStored.get(target) || (sessions.has(target) ? target : titleToStored.get(`${profile}::${target}`))
-    )
-
-  const handle = async (method, params) => {
-    if (method === 'session.create') {
-      sessionSequence += 1
-      const stored = `sid-${sessionSequence}`
-      const runtime = `rt-${sessionSequence}`
-      const session = { stored, runtime, profile: params.profile, title: params.title, messages: [] }
-      sessions.set(stored, session)
-      runtimeToStored.set(runtime, stored)
-      titleToStored.set(`${params.profile}::${params.title}`, stored)
-      return { session_id: runtime, stored_session_id: stored, message_count: 0, messages: [] }
-    }
-    if (method === 'session.resume') {
-      const session = resolveSession(params.profile, params.session_id)
-      if (!session) {
-        const err = new Error(`session not found: ${params.session_id}`)
-        err.code = 4007
-        throw err
-      }
-      // Every resume mints a FRESH runtime id — the stored id is the durable
-      // identity, mirroring the gateway's resume contract.
-      sessionSequence += 1
-      const runtime = `rt-${sessionSequence}`
-      session.runtime = runtime
-      runtimeToStored.set(runtime, session.stored)
-      return {
-        session_id: runtime,
-        session_key: session.stored,
-        message_count: session.messages.length,
-        messages: params.omit_messages ? [] : [...session.messages],
-        inflight: false,
-        running: false
-      }
-    }
-    if (method === 'image.attach_bytes' || method === 'pdf.attach' || method === 'file.attach') {
-      const session = resolveSession(null, params.session_id)
-      if (!session) {
-        const err = new Error(`session-scoped RPC rejected: ${params.session_id} not in memory`)
-        err.code = 4001
-        throw err
-      }
-      return { attached: true }
-    }
-    if (method === 'prompt.submit') {
-      submits += 1
-      if (failEverySubmitWith) {
-        throw failEverySubmitWith
-      }
-      if (submits === 1 && failFirstSubmitWith) {
-        throw failFirstSubmitWith
-      }
-      const session = resolveSession(null, params.session_id)
-      if (!session) {
-        const err = new Error(`session-scoped RPC rejected: ${params.session_id} not in memory`)
-        err.code = 4001
-        throw err
-      }
-      session.messages.push({ role: 'user', content: params.text })
-      if (replyMessages) {
-        for (const msg of replyMessages) {
-          session.messages.push(msg)
-        }
-      } else {
-        session.messages.push({ role: 'assistant', content: reply })
-      }
-      return {}
-    }
-    return {}
-  }
-
-  const context = {
-    atom,
-    setTimeout: fn => {
-      fn()
-      return 0
-    },
-    clearTimeout: () => undefined,
-    Date,
-    console,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: async (method, params) => handle(method, params),
-      requestProfile: async (route, method, params) => {
-        acquire()
-        try {
-          return await handle(method, params)
-        } finally {
-          release()
-          rpcLog.push({ method, refcountAfter: refcount })
-          timeline.push(method)
-        }
-      },
-      retainProfile: async () => {
-        timeline.push('retain')
-        acquire()
-        let released = false
-        return () => {
-          if (!released) {
-            released = true
-            timeline.push('release')
-            release()
-          }
-        }
-      },
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } },
-      notify: () => undefined,
-      notifyError: () => undefined
-    }
-  }
-
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__lease = { runGroupChatMemberTurn, submitGroupTurnPrompt, isSessionGoneError, $groupChats };\n'
-    )
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  context.plugin.register({
-    storage: { get: () => null, set: () => undefined },
-    register: () => undefined
-  })
-  return {
-    ...context.__lease,
-    context,
-    rpcLog,
-    timeline,
-    stats: () => ({ refcount, disposals, submits })
-  }
-}
-
-const LOCAL_MEMBER = { name: 'helper', title: '' }
-const ROUTED_MEMBER = { name: 'helper', connectionId: 'mini', remoteSource: true }
-const IMG = { name: 'shot.png', data: 'data:image/png;base64,iVBORw0KGgo=' }
-
-test('isSessionGoneError: 4001 and "not in memory" are recoverable, 4007 is not', () => {
-  const gc = load()
-  const gone = new Error('x')
-  gone.code = 4001
-  assert.equal(gc.isSessionGoneError(gone), true)
-  assert.equal(gc.isSessionGoneError(new Error('session_id=rt-1 not in memory')), true)
-  const missing = new Error('session not found')
-  missing.code = 4007
-  assert.equal(gc.isSessionGoneError(missing), false)
-  assert.equal(gc.isSessionGoneError(null), false)
-  assert.equal(gc.isSessionGoneError(new Error('network blip')), false)
-})
-
-test('a 4001 on the first prompt.submit recovers via session.resume on the STORED id and delivers', async () => {
-  const reaped = new Error("session-scoped RPC rejected: session_id='rt-1' not in memory")
-  reaped.code = 4001
-  const gc = load({ failFirstSubmitWith: reaped, reply: 'recovered reply' })
-
-  const reply = await gc.runGroupChatMemberTurn('Room', LOCAL_MEMBER, 'hi there', 't1', [])
-
-  assert.equal(reply, 'recovered reply')
-  // One failed submit + exactly one retry — never more.
-  assert.equal(gc.stats().submits, 2)
-  // The recovery re-resumed the durable stored id, not the dead runtime id.
-  const room = gc.$groupChats.get().Room
-  assert.ok(room.sessions.helper, 'stored session id survives in the room record')
-})
-
-test('a persistent non-4001 submit failure is NOT retried and still surfaces', async () => {
-  const fatal = new Error('backend exploded')
-  const gc = load({ failEverySubmitWith: fatal })
-
-  await assert.rejects(() => gc.runGroupChatMemberTurn('Room', LOCAL_MEMBER, 'hi', 't1', []), /backend exploded/)
-  assert.equal(gc.stats().submits, 1)
-})
-
-test('the per-turn lease is acquired before any session RPC and held across attach+submit', async () => {
-  const gc = load({ reply: 'routed reply' })
-
-  const reply = await gc.runGroupChatMemberTurn('Room', ROUTED_MEMBER, 'look at this', 't1', [IMG])
-
-  assert.equal(reply, 'routed reply')
-  // The retain landed before the first session-scoped RPC on the route.
-  assert.equal(gc.timeline[0], 'retain')
-  // The socket was NEVER disposed mid-turn: after every per-request lease
-  // released, the turn lease still held the refcount above zero.
-  for (const rpc of gc.rpcLog) {
-    assert.ok(rpc.refcountAfter >= 1, `${rpc.method} left refcount ${rpc.refcountAfter} — socket disposed mid-turn`)
-  }
-  // Exactly one disposal, and only via the turn lease's own release at the end.
-  assert.equal(gc.stats().disposals, 1)
-  assert.equal(gc.timeline[gc.timeline.length - 1], 'release')
-})
-
-test('the per-turn lease is released after the turn — refcount returns to zero', async () => {
-  const gc = load({ reply: 'done' })
-
-  await gc.runGroupChatMemberTurn('Room', ROUTED_MEMBER, 'hi', 't1', [])
-
-  assert.equal(gc.stats().refcount, 0)
-  assert.equal(gc.stats().disposals, 1)
-})
-
-test('the per-turn lease is released even when the turn fails', async () => {
-  const fatal = new Error('backend exploded')
-  const gc = load({ failEverySubmitWith: fatal })
-
-  await assert.rejects(() => gc.runGroupChatMemberTurn('Room', ROUTED_MEMBER, 'hi', 't1', []))
-
-  assert.equal(gc.stats().refcount, 0)
-})
-
-test('hosts without retainProfile still run the turn (feature detection)', async () => {
-  const gc = load({ reply: 'legacy ok' })
-  delete gc.context.host.retainProfile
-
-  const reply = await gc.runGroupChatMemberTurn('Room', ROUTED_MEMBER, 'hi', 't1', [])
-
-  assert.equal(reply, 'legacy ok')
-})
-
-// #94376: a Codex intent-ack continuation nudge can land a substantive
-// answer, then get a synthetic "(pass)" reply to the nudge itself. The
-// substantive answer must still surface, not the trailing pass.
-test('a substantive answer followed by a synthetic continuation (pass) still surfaces the answer', async () => {
-  const gc = load({
-    replyMessages: [
-      { role: 'assistant', content: "Yes. I welcomed them, and I'll review their first assignments with them." },
-      { role: 'user', content: '[System: Continue now. Execute the required tool calls and only send your final answer after completing the task.]' },
-      { role: 'assistant', content: '(pass)' }
-    ]
-  })
-
-  const reply = await gc.runGroupChatMemberTurn('Room', LOCAL_MEMBER, 'Did you welcome the new teammate?', 't1', [])
-
-  assert.equal(reply, "Yes. I welcomed them, and I'll review their first assignments with them.")
-})
-
-test('a genuine pass-only turn (no prior substantive answer) still reads as silent', async () => {
-  const gc = load({ reply: '(pass)' })
-
-  const reply = await gc.runGroupChatMemberTurn('Room', LOCAL_MEMBER, 'anything new?', 't1', [])
-
-  assert.equal(reply, '(pass)')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/group-turn-races.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/group-turn-races.test.mjs
deleted file mode 100644
index 391da6b7b109..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/group-turn-races.test.mjs
+++ /dev/null
@@ -1,105 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #93127: duplicate room delivery. Two raceable paths existed:
-//   1. a member turn mid-flight when the room epoch bumps still commits its
-//      reply + watermark when it returns (the stale loop only noticed
-//      supersession at the NEXT member boundary), and
-//   2. the stale loop and the fresh loop can both append the same reply.
-// The fix re-checks the epoch after the turn returns (shouldCommitMemberTurn)
-// and drops adjacent byte-identical member echoes (isDuplicateGroupAppend).
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadHelpers() {
-  const start = pluginSource.indexOf('// --- room-turn decision helpers (#93127)')
-  const end = pluginSource.indexOf('// --- end room-turn decision helpers ---', start)
-  assert.notEqual(start, -1, 'plugin carries the room-turn helper block')
-  assert.notEqual(end, -1, 'room-turn helper block has a stable end marker')
-  const context = {}
-  vm.runInNewContext(
-    `${pluginSource.slice(start, end)}
-globalThis.shouldCommitMemberTurn = shouldCommitMemberTurn
-globalThis.isDuplicateGroupAppend = isDuplicateGroupAppend`,
-    context
-  )
-  return context
-}
-
-const memberEntry = (name, text, thread = 't1', at = Date.now(), source) => ({
-  id: 'x',
-  at,
-  from: { kind: 'member', name, ...(source ? { source } : {}) },
-  text,
-  thread
-})
-
-test('a superseded turn is discarded — epoch moved on while the turn ran', () => {
-  const { shouldCommitMemberTurn } = loadHelpers()
-  assert.equal(shouldCommitMemberTurn(3, 4), false)
-  assert.equal(shouldCommitMemberTurn(3, 7), false)
-  // explicit same-thread supersession
-  assert.equal(shouldCommitMemberTurn(3, 4, true), false)
-})
-
-test('a current turn commits — epoch unchanged since dispatch', () => {
-  const { shouldCommitMemberTurn } = loadHelpers()
-  assert.equal(shouldCommitMemberTurn(3, 3), true)
-  assert.equal(shouldCommitMemberTurn(0, 0), true)
-})
-
-test('a cross-thread epoch bump does NOT discard finished work (no fresh loop re-drives it)', () => {
-  const { shouldCommitMemberTurn } = loadHelpers()
-  // Epoch moved, but no newer user entry landed in THIS thread: the
-  // superseding send lives in another thread whose loop filters this one
-  // out — dropping the reply would lose completed work forever.
-  assert.equal(shouldCommitMemberTurn(3, 4, false), true)
-})
-
-test('adjacent identical member reply is a duplicate append', () => {
-  const { isDuplicateGroupAppend } = loadHelpers()
-  const last = memberEntry('impl', 'Stopped. Standing by.')
-  const dup = isDuplicateGroupAppend(last, { kind: 'member', name: 'impl' }, 'Stopped. Standing by.', 't1')
-  assert.equal(dup, true)
-})
-
-test('identical text from a DIFFERENT member is not a duplicate', () => {
-  const { isDuplicateGroupAppend } = loadHelpers()
-  const last = memberEntry('impl', 'Confirmed.')
-  assert.equal(isDuplicateGroupAppend(last, { kind: 'member', name: 'reviewer' }, 'Confirmed.', 't1'), false)
-})
-
-test('identical text from the same member on another SOURCE is not a duplicate', () => {
-  const { isDuplicateGroupAppend } = loadHelpers()
-  const last = memberEntry('impl', 'Confirmed.', 't1', Date.now(), 'laptop')
-  assert.equal(isDuplicateGroupAppend(last, { kind: 'member', name: 'impl' }, 'Confirmed.', 't1'), false)
-})
-
-test('same text after an intervening entry is not a duplicate — only the LAST entry is checked', () => {
-  const { isDuplicateGroupAppend } = loadHelpers()
-  // The helper only ever receives the immediately-preceding entry; an
-  // intervening entry means lastEntry is the interloper, not the echo.
-  const intervening = memberEntry('reviewer', 'ack')
-  assert.equal(isDuplicateGroupAppend(intervening, { kind: 'member', name: 'impl' }, 'Confirmed.', 't1'), false)
-})
-
-test('identical text in a DIFFERENT thread is not a duplicate', () => {
-  const { isDuplicateGroupAppend } = loadHelpers()
-  const last = memberEntry('impl', 'Confirmed.', 'thread-a')
-  assert.equal(isDuplicateGroupAppend(last, { kind: 'member', name: 'impl' }, 'Confirmed.', 'thread-b'), false)
-})
-
-test('identical text outside the recency window is not a duplicate', () => {
-  const { isDuplicateGroupAppend } = loadHelpers()
-  const hourAgo = Date.now() - 60 * 60 * 1000
-  const last = memberEntry('impl', 'Done.', 't1', hourAgo)
-  assert.equal(isDuplicateGroupAppend(last, { kind: 'member', name: 'impl' }, 'Done.', 't1'), false)
-})
-
-test('user entries are never deduped', () => {
-  const { isDuplicateGroupAppend } = loadHelpers()
-  const last = { id: 'x', at: Date.now(), from: { kind: 'user', name: 'You' }, text: 'stop', thread: 't1' }
-  assert.equal(isDuplicateGroupAppend(last, { kind: 'user', name: 'You' }, 'stop', 't1'), false)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/hide-bot-chats.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/hide-bot-chats.test.mjs
deleted file mode 100644
index 9a3aca0d2fe4..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/hide-bot-chats.test.mjs
+++ /dev/null
@@ -1,318 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Bot Mode sessions are ALWAYS hidden from the global Sessions sidebar
-// (canonical Bot Chats and group-chat member sessions alike) via the core
-// generic `hidden` session flag. There is no user pref: session.create
-// passes hidden:true unconditionally, and hideOwnedBotSessions() sweeps
-// every known plugin-owned session id through session.set_hidden so rows
-// born visible under the old pref get reconciled.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadCreate() {
-  const start = source.indexOf('const canonicalCreations = new Map()')
-  const end = source.indexOf('function displayName(', start)
-  const created = []
-  const context = {
-    host: {
-      openSession: async () => {},
-      request: async (method, params) => {
-        if (method === 'session.create') {
-          created.push(params)
-          return { stored_session_id: 'sid-1', session_id: 'rt-1' }
-        }
-        return {}
-      }
-    },
-    saveBotMeta: () => {},
-    backendTargetProfile: (route, name) => route?.targetProfile || name,
-    botOwner: name => ({ bot: { name }, key: name, name, route: null }),
-    requestForBot: (_bot, method, params) => context.host.request(method, params),
-    window: { setTimeout: cb => cb() }
-  }
-  const section = source.slice(start, end).concat('\nglobalThis.__c = { createCanonicalChat };\n')
-  vm.runInNewContext(section, context, { filename: 'c.js' })
-  return { create: context.__c.createCanonicalChat, created }
-}
-
-test('createCanonicalChat always passes hidden:true — no pref gate', async () => {
-  const { create, created } = loadCreate()
-  await create('alpha')
-  assert.equal(created.length, 1)
-  assert.equal(created[0].hidden, true)
-  assert.equal(created[0].title, 'Bot Chat')
-})
-
-test('group member session.create is unconditionally hidden too', () => {
-  // Source contract on ensureGroupChatSession: the create carries a literal
-  // hidden:true, with no $hideBotChats conditional anywhere in the plugin.
-  const fn = source.slice(source.indexOf('async function ensureGroupChatSession('), source.indexOf('const GROUP_TURN_TIMEOUT_MS'))
-  assert.match(fn, /hidden: true/)
-  assert.equal(source.includes('$hideBotChats'), false, 'the old pref atom must be gone')
-})
-
-test('hideOwnedBotSessions sweeps room member sessions by id', async () => {
-  const start = source.indexOf('function hideOwnedBotSessions()')
-  const end = source.indexOf('/** Fetch server-side avatars', start)
-  const calls = []
-  const context = {
-    host: {
-      setPersistedSessionHidden: async (_route, options) => {
-        calls.push({ method: 'session.set_hidden', params: { session_id: options.sessionId, hidden: options.hidden } })
-      },
-      request: async (method, params) => {
-        calls.push({ method, params })
-        return {}
-      }
-    },
-    $botMeta: { get: () => ({}) },
-    $lastRoster: { get: () => [] },
-    backendTargetProfile: (route, name) => route?.targetProfile || name,
-    botConnectionRoute: () => null,
-    botMetaKey: bot => bot.name,
-    requestForBot: (_bot, method, params) => context.host.request(method, params),
-    $groupChats: {
-      get: () => ({
-        Core: { sessions: { alpha: 'room-core-a', beta: 'room-core-b' } },
-        Quiet: { sessions: { alpha: 'room-core-a' } }, // duplicate id — must dedupe
-        Legacy: {} // pre-sessions room shape
-      })
-    },
-    sweepBotProfileSessions: async () => undefined
-  }
-  const section = source.slice(start, end).concat('\nglobalThis.__h = { hideOwnedBotSessions };\n')
-  vm.runInNewContext(section, context, { filename: 'h.js' })
-  await context.__h.hideOwnedBotSessions()
-
-  const ids = calls.filter(c => c.method === 'session.set_hidden').map(c => c.params.session_id).sort()
-  assert.deepEqual(ids, ['room-core-a', 'room-core-b'])
-  const hiddenCalls = calls.filter(c => c.method === 'session.set_hidden')
-  assert.ok(hiddenCalls.every(c => c.params.hidden === true))
-})
-
-test('hideOwnedBotSessions never consults stored canonical pointers', () => {
-  // Canonical Bot Chats are hidden by the TITLE sweep (they are identified by
-  // name, not by pointer) — the load-time reconciliation must not read
-  // $botMeta chat ids or verify them via profiles.list.
-  const start = source.indexOf('function hideOwnedBotSessions()')
-  const end = source.indexOf('// Titles Bot Mode itself mints', start)
-  const section = source.slice(start, end)
-  assert.doesNotMatch(section, /botMeta/)
-  assert.doesNotMatch(section, /profiles\.list/)
-})
-
-test('remote group member sessions derive their immutable owner from persisted room members', async () => {
-  const start = source.indexOf('function hideOwnedBotSessions()')
-  const end = source.indexOf('/** Fetch server-side avatars', start)
-  const ambient = []
-  const routed = []
-  const owner = {
-    name: 'worker',
-    sourceScoped: true,
-    route: {
-      connectionId: 'source-a',
-      mode: 'remote',
-      profile: 'worker',
-      targetProfile: 'backend-worker'
-    }
-  }
-  const context = {
-    host: {
-      request: async (method, params) => ambient.push({ method, params }),
-      setPersistedSessionHidden: async (route, options) => routed.push({ route, options })
-    },
-    $botMeta: { get: () => ({}) },
-    $lastRoster: { get: () => [] },
-    $groupChats: {
-      get: () => ({
-        Core: {
-          sessions: { 'source-a::worker': 'remote-room-1' },
-          members: [owner]
-        }
-      })
-    },
-    groupMemberKey: member => `${member.route.connectionId}::${member.name}`,
-    botConnectionRoute: bot => bot.route || null,
-    backendTargetProfile: (route, fallback) => route?.targetProfile || fallback,
-    requestForBot: async () => {
-      throw new Error('gateway RPC must not be used')
-    },
-    sweepBotProfileSessions: async () => undefined
-  }
-  const section = source.slice(start, end).concat('\nglobalThis.__h = { hideOwnedBotSessions };\n')
-  vm.runInNewContext(section, context, { filename: 'h-remote.js' })
-
-  await context.__h.hideOwnedBotSessions()
-
-  assert.equal(ambient.some(call => call.method === 'session.set_hidden'), false)
-  assert.equal(routed.length, 1)
-  assert.equal(routed[0].route.connectionId, 'source-a')
-  assert.equal(routed[0].route.targetProfile, 'backend-worker')
-  assert.equal(routed[0].options.sessionId, 'remote-room-1')
-})
-
-test('same session id on two remote group owners never hides an ambient collision', async () => {
-  const start = source.indexOf('function hideOwnedBotSessions()')
-  const end = source.indexOf('/** Fetch server-side avatars', start)
-  const ambient = []
-  const routed = []
-  const owner = connectionId => ({
-    name: 'worker',
-    sourceScoped: true,
-    route: { connectionId, mode: 'remote', profile: 'worker', targetProfile: 'backend-worker' }
-  })
-  const ownerA = owner('source-a')
-  const ownerB = owner('source-b')
-  const context = {
-    host: {
-      request: async (method, params) => ambient.push({ method, params }),
-      setPersistedSessionHidden: async (route, options) => routed.push({ route, options })
-    },
-    $botMeta: { get: () => ({}) },
-    $lastRoster: { get: () => [] },
-    $groupChats: {
-      get: () => ({
-        A: { sessions: { 'source-a::worker': 'same-id' }, sessionOwners: { 'source-a::worker': ownerA } },
-        B: { sessions: { 'source-b::worker': 'same-id' }, sessionOwners: { 'source-b::worker': ownerB } }
-      })
-    },
-    groupMemberKey: member => `${member.route.connectionId}::${member.name}`,
-    botConnectionRoute: bot => bot.route || null,
-    backendTargetProfile: (route, fallback) => route?.targetProfile || fallback,
-    requestForBot: async () => {
-      throw new Error('gateway RPC must not be used')
-    },
-    sweepBotProfileSessions: async () => undefined
-  }
-  const section = source.slice(start, end).concat('\nglobalThis.__h = { hideOwnedBotSessions };\n')
-  vm.runInNewContext(section, context, { filename: 'h-collision.js' })
-
-  await context.__h.hideOwnedBotSessions()
-
-  assert.equal(ambient.some(call => call.method === 'session.set_hidden'), false)
-  assert.deepEqual(routed.map(call => call.route.connectionId).sort(), ['source-a', 'source-b'])
-  assert.ok(routed.every(call => call.options.sessionId === 'same-id'))
-})
-
-test('malformed persisted owner for a source-qualified group session fails closed', async () => {
-  const start = source.indexOf('function hideOwnedBotSessions()')
-  const end = source.indexOf('/** Fetch server-side avatars', start)
-  const ambient = []
-  const routed = []
-  const context = {
-    host: { request: async (method, params) => ambient.push({ method, params }) },
-    $botMeta: { get: () => ({}) },
-    $lastRoster: { get: () => [] },
-    $groupChats: {
-      get: () => ({
-        LegacyRemote: {
-          sessions: { 'source-a::worker': 'same-id' },
-          sessionOwners: { 'source-a::worker': { name: 'worker' } }
-        }
-      })
-    },
-    groupMemberKey: member => member?.name,
-    requestForBot: async (bot, method, params) => routed.push({ bot, method, params }),
-    sweepBotProfileSessions: async () => undefined
-  }
-  const section = source.slice(start, end).concat('\nglobalThis.__h = { hideOwnedBotSessions };\n')
-  vm.runInNewContext(section, context, { filename: 'h-malformed-owner.js' })
-
-  await context.__h.hideOwnedBotSessions()
-
-  assert.equal(ambient.some(call => call.method === 'session.set_hidden'), false)
-  assert.equal(routed.length, 0)
-})
-
-test('sweepBotProfileSessions hides Bot-Mode-titled rows per roster bot, and only those', async () => {
-  // Ownership-based half of the sweep: CLI-born "Agent Inbox" / extra
-  // "Bot Chat" rows live in bot profiles but are unknown to $botMeta /
-  // $groupChats, so the id-based sweep never reaches them. This sweep lists
-  // each roster bot's own sessions and hides rows by exact plumbing title
-  // ('Bot Chat', 'Agent Inbox', 'Group: …' prefix) — never a user-titled row.
-  const start = source.indexOf('function hideOwnedBotSessions()')
-  const end = source.indexOf('/** Fetch server-side avatars', start)
-  const calls = []
-  const nowSeconds = 1_000
-  const rowsByProfile = {
-    alpha: [
-      { id: 'a-1', title: 'Bot Chat', started_at: 1 },
-      { id: 'a-2', title: 'Agent Inbox', started_at: 1 },
-      { id: 'a-3', title: 'Group: Core', started_at: 1 },
-      { id: 'a-4', title: 'My real conversation', started_at: 1 },
-      { id: 'a-5', title: 'Bot Chat notes', started_at: 1 }, // not an exact title — kept
-      { id: 'a-6', title: 'Bot Chat', started_at: nowSeconds - 299 }, // live draft — kept
-      { id: 'a-7', title: 'Agent Inbox' }, // missing age metadata — kept fail-closed
-      { id: 'a-8', title: 'Bot Chat', started_at: nowSeconds - 300 } // boundary reached — hidden
-    ],
-    remy: [{ id: 'r-1', title: 'Agent Inbox', started_at: 1 }]
-  }
-  const context = {
-    host: {
-      request: async () => ({}),
-      listPersistedSessions: async (route, options) => {
-        calls.push({ bot: options.profile, method: 'persisted.list', params: options, route })
-        return { sessions: rowsByProfile[options.profile] || [] }
-      },
-      setPersistedSessionHidden: async (route, options) => {
-        calls.push({ bot: options.profile, method: 'persisted.set_hidden', params: options, route })
-      }
-    },
-    $botMeta: { get: () => ({}) },
-    $groupChats: { get: () => ({}) },
-    $lastRoster: { get: () => [{ name: 'alpha' }, { name: 'remy', remoteSource: true, connectionId: 'mini' }] },
-    PROFILE_SESSION_LIST_LIMIT: 200,
-    botConnectionRoute: bot =>
-      bot.remoteSource
-        ? { connectionId: bot.connectionId, mode: 'remote', profile: bot.name, targetProfile: bot.name }
-        : null,
-    backendTargetProfile: (route, fallback) => route?.targetProfile || fallback,
-    requestForBot: async (bot, method, params) => {
-      calls.push({ bot: bot.name, method, params })
-      if (method === 'session.list') {
-        return { sessions: rowsByProfile[params.profile] || [] }
-      }
-      return {}
-    }
-  }
-  const section = source.slice(start, end).concat('\nglobalThis.__h = { hideOwnedBotSessions, sweepBotProfileSessions };\n')
-  vm.runInNewContext(section, context, { filename: 's.js' })
-  await context.__h.sweepBotProfileSessions(nowSeconds)
-
-  const lists = calls.filter(c => c.method === 'persisted.list')
-  assert.deepEqual(lists.map(c => c.params.profile).sort(), ['alpha', 'remy'])
-  // Visible-rows-only listing keeps the sweep idempotent.
-  assert.ok(lists.every(c => !c.params.include_hidden))
-
-  const hidden = calls.filter(c => c.method === 'persisted.set_hidden')
-  assert.deepEqual(
-    hidden.map(c => c.params.sessionId).sort(),
-    ['a-1', 'a-2', 'a-3', 'a-8', 'r-1'],
-    'exact plumbing titles only — user-titled and brand-new rows stay visible'
-  )
-  assert.ok(hidden.every(c => c.params.hidden === true))
-  // Remote-source rows keep their immutable source owner on the REST route.
-  assert.equal(hidden.find(c => c.params.sessionId === 'r-1').route.connectionId, 'mini')
-})
-
-test('hideOwnedBotSessions chains the ownership sweep and survives its absence of context', async () => {
-  // The load/reconnect entrypoint runs BOTH halves: known ids first, then
-  // the roster-wide title sweep (best-effort — a throwing sweep never
-  // breaks the id half).
-  assert.match(source, /return Promise\.all\(\[known, sweepBotProfileSessions\(\)\.catch\(\(\) => undefined\)\]\)/)
-})
-
-test('the canonical-chat adoption scan lists with include_hidden', () => {
-  // The one session.list consumer that must see the always-hidden rows:
-  // findExistingCanonicalChat (the registry lookup) — canonical Bot Chats
-  // are born hidden, so a visible-only scan would miss the very row that IS
-  // the bot's identity. The lookup rides the bot's own source (requestForBot)
-  // and fails CLOSED: a thrown lookup never falls through to minting.
-  assert.match(
-    source,
-    /requestForBot\(bot, 'session\.list', \{\s*profile: backendTargetProfile\(route, name\),\s*title: CANONICAL_CHAT_TITLE,[\s\S]{0,200}?include_hidden: true\s*\}\)\s*\} catch \(error\) \{[\s\S]{0,800}?const rows = res\?\.sessions \?\? \[\]\s*return rows\.find\(row => isCanonicalBotChatHistory\(row\)\)/
-  )
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/hide-bots.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/hide-bots.test.mjs
deleted file mode 100644
index 2f2289210164..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/hide-bots.test.mjs
+++ /dev/null
@@ -1,222 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Per-bot Hide/Unhide: right-click → Hide Bot persists `hidden: true` in bot
-// meta (local ctx.storage + server ui_meta via saveBotMeta), hidden bots drop
-// out of the roster list, and a header eye toggle — rendered only while at
-// least one bot is hidden — reveals them dimmed for right-click → Unhide.
-// Hiding is a roster-DISPLAY concern only: mentions, group chats, and the
-// name-collision check keep the full roster.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load({ toastsOn = false } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const notifications = []
-  const requests = []
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      state: {
-        profile: { get: () => 'default', listen: () => undefined },
-        gateway: { get: () => 'open', listen: () => undefined }
-      },
-      request: (method, params) => {
-        requests.push({ method, params })
-        return Promise.resolve({ applied: { ui_meta: true } })
-      },
-      notify: params => notifications.push(params)
-    },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-globalThis.__hide = {
-  isBotHidden,
-  fallbackSelectionAfterHide,
-  mergeServerMeta,
-  saveBotMeta,
-  trackInboundActivity,
-  $botMeta,
-  $botUnread,
-  $selectedBot,
-  $lastRoster,
-  $showHiddenBots,
-  $activityToasts,
-  setPluginCtx: value => { pluginCtx = value }
-};
-`)
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  if (toastsOn) {
-    context.__hide.$activityToasts.set(true)
-  }
-  return { ...context.__hide, notifications, requests }
-}
-
-test('hide: saveBotMeta persists hidden:true locally and ships it in server ui_meta', async () => {
-  const t = load()
-  const writes = []
-  t.setPluginCtx({ storage: { set: (key, value) => writes.push({ key, value }) } })
-
-  await t.saveBotMeta('default', { hidden: true })
-
-  assert.equal(t.$botMeta.get().default.hidden, true)
-  assert.equal(writes.at(-1).key, 'bot-meta')
-  assert.equal(writes.at(-1).value.default.hidden, true)
-  const configure = t.requests.find(r => r.method === 'profiles.configure')
-  assert.equal(configure.params.ui_meta['hermes-bots'].hidden, true)
-})
-
-test('roster: hidden bots are filtered out; remote-source rows of the same name stay visible', () => {
-  const t = load()
-  t.$botMeta.set({ ghost: { hidden: true } })
-  const roster = [
-    { name: 'default' },
-    { name: 'ghost' },
-    { name: 'ghost', remoteSource: true, connectionId: 'mini' }
-  ]
-  const meta = t.$botMeta.get()
-  const visible = roster.filter(bot => !t.isBotHidden(bot, meta))
-
-  assert.equal(JSON.stringify(visible.map(b => `${b.remoteSource ? 'r:' : ''}${b.name}`)), JSON.stringify(['default', 'r:ghost']))
-})
-
-test('unhide: hidden:false clears locally AND survives a mergeServerMeta round-trip', async () => {
-  const t = load()
-  const writes = []
-  t.setPluginCtx({ storage: { set: (key, value) => writes.push({ key, value }) } })
-  t.$botMeta.set({ ghost: { hidden: true, title: 'Ghost' } })
-
-  await t.saveBotMeta('ghost', { hidden: false })
-  assert.equal(t.$botMeta.get().ghost.hidden, false, 'local merge must clear the flag')
-  const configure = t.requests.find(r => r.method === 'profiles.configure')
-  assert.equal(configure.params.ui_meta['hermes-bots'].hidden, false, 'server copy carries the literal false')
-
-  // Machine B: its stale local copy still says hidden:true; the server
-  // overlay (which merges OVER local) must win with the false.
-  t.$botMeta.set({ ghost: { hidden: true, title: 'Ghost' } })
-  t.mergeServerMeta([{ name: 'ghost', ui_meta: { 'hermes-bots': { hidden: false, title: 'Ghost' } } }])
-  assert.equal(t.$botMeta.get().ghost.hidden, false, 'server false must beat stale local true')
-})
-
-test('cross-machine: a hide done elsewhere lands via mergeServerMeta and persists to storage', () => {
-  const t = load()
-  const writes = []
-  t.setPluginCtx({ storage: { set: (key, value) => writes.push({ key, value }) } })
-  t.$botMeta.set({ ghost: { title: 'Ghost' } })
-
-  t.mergeServerMeta([{ name: 'ghost', ui_meta: { 'hermes-bots': { hidden: true, title: 'Ghost' } } }])
-
-  assert.equal(t.$botMeta.get().ghost.hidden, true)
-  assert.equal(writes.at(-1).value.ghost.hidden, true)
-})
-
-test('selection: hiding the selected bot falls back to the first visible bot', () => {
-  const t = load()
-  t.$selectedBot.set('ghost')
-  t.$botMeta.set({ ghost: { hidden: true } })
-  t.$lastRoster.set([{ name: 'ghost' }, { name: 'scribe' }, { name: 'default' }])
-
-  t.fallbackSelectionAfterHide('ghost')
-
-  assert.equal(t.$selectedBot.get(), 'scribe')
-})
-
-test('selection: falls back to default when nothing else is visible', () => {
-  const t = load()
-  t.$selectedBot.set('ghost')
-  t.$botMeta.set({ ghost: { hidden: true } })
-  t.$lastRoster.set([{ name: 'ghost' }])
-
-  t.fallbackSelectionAfterHide('ghost')
-
-  assert.equal(t.$selectedBot.get(), 'default')
-})
-
-test('selection: hiding default with nothing else visible keeps the selection (Routines must not chase a ghost)', () => {
-  const t = load()
-  t.$selectedBot.set('default')
-  t.$botMeta.set({ default: { hidden: true } })
-  t.$lastRoster.set([{ name: 'default' }])
-
-  t.fallbackSelectionAfterHide('default')
-
-  assert.equal(t.$selectedBot.get(), 'default')
-})
-
-test('selection: hiding an unselected bot never moves the selection', () => {
-  const t = load()
-  t.$selectedBot.set('scribe')
-  t.$botMeta.set({ ghost: { hidden: true } })
-  t.$lastRoster.set([{ name: 'ghost' }, { name: 'scribe' }])
-
-  t.fallbackSelectionAfterHide('ghost')
-
-  assert.equal(t.$selectedBot.get(), 'scribe')
-})
-
-test('activity: a hidden bot accumulates unread silently but never toasts, even with toasts on', () => {
-  const t = load({ toastsOn: true })
-  t.$botMeta.set({ ghost: { hidden: true } })
-  t.$selectedBot.set('default')
-
-  const rosterAt = ts => [{ name: 'ghost', last_session: { last_active: ts, preview: 'Message from writer: hi' } }]
-  t.trackInboundActivity(rosterAt(100)) // seeding poll
-  t.trackInboundActivity(rosterAt(200)) // activity past the watermark
-
-  assert.equal(t.$botUnread.get().ghost, true, 'unread must accumulate while hidden')
-  assert.equal(t.notifications.length, 0, 'hidden bots never toast')
-})
-
-// ── source shape ─────────────────────────────────────────────────────────────
-
-test('shape: visible and hidden bots render through separate recoverable sections', () => {
-  assert.match(
-    pluginSource,
-    /const visibleRoster = roster\.filter\(bot => !isBotHidden\(bot, allMeta\)\)/
-  )
-  assert.match(pluginSource, /const matchingHiddenBots = rowKindFilter === 'groups' \? \[\] : filteredHiddenBots/)
-})
-
-test('shape: Hidden section renders only when recovery is relevant', () => {
-  assert.match(pluginSource, /const showHiddenSection = hiddenBots\.length > 0/)
-  assert.match(pluginSource, /onClick: \(\) => \$showHiddenBots\.set\(!hiddenExpanded\)/)
-})
-
-test('shape: revealed hidden rows are flagged and can be restored', () => {
-  const botRow = pluginSource.slice(pluginSource.indexOf('function BotRow('), pluginSource.indexOf('// ── model picker'))
-  assert.match(botRow, /name: 'eye-closed'/)
-  assert.match(botRow, /children: hidden \? 'Unhide' : 'Hide'/)
-  assert.match(botRow, /saveBotMeta\(bot, \{ hidden: !hidden \}\)/)
-})
-
-test('shape: hiding never filters mentions, group flows, or the meta/activity sweeps', () => {
-  // The full-roster consumers keep the FULL roster: mergeServerMeta,
-  // avatar pulls, and activity tracking all run on activeSourceRoster —
-  // which is derived from the unfiltered roster, not visibleRoster.
-  assert.match(pluginSource, /const activeSourceRoster = roster\.filter\(bot => !bot\.remoteSource\)/)
-  assert.match(pluginSource, /mergeServerMeta\(activeSourceRoster, data\?\.fetchedAt \|\| 0\)/)
-  assert.match(pluginSource, /trackInboundActivity\(roster\)/)
-  // Mention resolution never consults the hidden flag.
-  const mentions = pluginSource.slice(
-    pluginSource.indexOf('function resolveRosterMentions('),
-    pluginSource.indexOf('/** Source-qualified identity for a roster row')
-  )
-  assert.doesNotMatch(mentions, /hidden/i)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/hub-picker-guard.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/hub-picker-guard.test.mjs
deleted file mode 100644
index de484a1d0809..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/hub-picker-guard.test.mjs
+++ /dev/null
@@ -1,27 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// The Skills Hub picker embed posts {type:'hermes-skill-pick'} messages and
-// the plugin installs via skills.manage. The handler checked only
-// event.origin — any window on the hub origin (e.g. an OAuth popup returned
-// to the hub) could trigger an install while the picker is open, and any
-// string reached skills.manage as the install identifier. Picks are now
-// pinned to OUR iframe's contentWindow and the identifier is charset-checked.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-const start = source.indexOf('function HubSkillsSection(')
-assert.notEqual(start, -1, 'HubSkillsSection is missing')
-const section = source.slice(start, source.indexOf('function emptyAdvancedState', start))
-
-test('regression: hub pick messages are pinned to the embedded frame', () => {
-  assert.ok(section.includes('const frameRef = useRef(null)'))
-  assert.ok(section.includes('event.source !== frameRef.current.contentWindow'))
-  assert.ok(section.includes('ref: frameRef'))
-})
-
-test('regression: hub pick identifiers are charset-checked before install', () => {
-  assert.ok(section.includes("if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(target)) {"))
-  assert.ok(section.includes('const target = String(data.identifier || data.name)'))
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/legacy-member-normalize.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/legacy-member-normalize.test.mjs
deleted file mode 100644
index fefbbd396534..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/legacy-member-normalize.test.mjs
+++ /dev/null
@@ -1,138 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #92794: older builds persisted group members with a FRIENDLY name as
-// `name` (e.g. `name: '大司命'` for the profile slug `taiyi`). Key matching
-// alone seats such a descriptor as a ghost NEXT TO its own live roster row
-// ("4 bots" in a 2-bot room — reproduced live), and any path that passes the
-// ghost's identity onward targets a profile that does not exist on disk.
-// resolveLegacyMemberDescriptor() re-tries an unmatched descriptor by
-// friendly name against same-connection roster rows before seating.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-const NL = String.fromCharCode(10)
-
-function stripImports(source) {
-  const out = []
-  let inImportBlock = false
-  for (const line of source.split(NL)) {
-    if (inImportBlock) {
-      if (line.includes(' from ')) inImportBlock = false
-      continue
-    }
-    if (line.startsWith('import ')) {
-      if (!line.includes(' from ')) inImportBlock = true
-      continue
-    }
-    out.push(line)
-  }
-  return out.join(NL)
-}
-
-function load({ groups, meta = {} }) {
-  const start = pluginSource.indexOf('function groupChatMemberBots(')
-  const end = pluginSource.indexOf('/** Persist source-qualified identities', start)
-  assert.notEqual(start, -1)
-  assert.notEqual(end, -1)
-
-  const context = {
-    $groupChats: { get: () => groups },
-    $botMeta: { get: () => meta },
-    botGroups: m => (m && Array.isArray(m.groups) ? m.groups : []),
-    botRosterMeta: (bot, metaByName) => metaByName?.[bot?.name] || null,
-    botRosterKey: bot => `${bot?.connectionId || 'legacy'}::${bot?.name || 'default'}`,
-    botFriendlyNames: bot => [
-      bot?.ui_meta?.['hermes-bots']?.title,
-      // localTitle: the real impl reads the Bot Mode title from $botMeta for
-      // local rows — mirror that so meta-titled bots resolve like production.
-      !bot?.remoteSource ? context.$botMeta.get()?.[bot?.name]?.title : null,
-      bot?.title,
-      bot?.display_name
-    ]
-  }
-  const section = stripImports(pluginSource.slice(start, end))
-    .concat(NL + 'globalThis.__m = { groupChatMemberBots, resolveLegacyMemberDescriptor };' + NL)
-  vm.runInNewContext(section, context, { filename: 'member-seat.js' })
-  return context.__m
-}
-
-const TAIYI = {
-  connectionId: 'local',
-  name: 'taiyi',
-  display_name: '大司命',
-  remoteSource: false
-}
-const TESTBOT = { connectionId: 'local', name: 'testbot', display_name: '', remoteSource: false }
-
-test('legacy display-name descriptors seat their live row once, not as extra ghosts', () => {
-  const { groupChatMemberBots } = load({
-    groups: {
-      room: {
-        // The legacy shape: friendly names persisted as `name`.
-        members: [
-          { connectionId: 'local', name: '大司命', handle: '大司命' },
-          { connectionId: 'local', name: 'Testbot', handle: 'Testbot' }
-        ]
-      }
-    },
-    roster: [TAIYI, TESTBOT],
-    meta: {
-      taiyi: { groups: ['room'] },
-      testbot: { groups: ['room'], title: 'Testbot' }
-    }
-  })
-
-  const seated = groupChatMemberBots('room', [TAIYI, TESTBOT], {
-    taiyi: { groups: ['room'] },
-    testbot: { groups: ['room'], title: 'Testbot' }
-  })
-
-  // Two members, not four: each legacy descriptor resolved to its live row.
-  // (vm-realm arrays fail assert.deepEqual on prototype identity — compare
-  // via JSON, per the harness contract in the field notes.)
-  assert.equal(seated.length, 2, `seated ${seated.map(b => b.name)}`)
-  assert.equal(JSON.stringify(seated.map(b => b.name).sort()), JSON.stringify(['taiyi', 'testbot']))
-})
-
-test('a genuinely unknown descriptor still seats as a degraded ghost', () => {
-  const { groupChatMemberBots } = load({
-    groups: { room: { members: [{ connectionId: 'gone', name: 'vanished' }] } },
-    roster: [TAIYI],
-    meta: { taiyi: { groups: ['room'] } }
-  })
-
-  const seated = groupChatMemberBots('room', [TAIYI], { taiyi: { groups: ['room'] } })
-  assert.equal(seated.length, 2)
-  assert.ok(seated.some(b => b.name === 'vanished'), 'orphan ghost preserved')
-})
-
-test('a connectionless pre-scoping descriptor resolves against local rows', () => {
-  // The oldest legacy shape: no connectionId at all (pre-connection-scoping
-  // rooms only ever held this machine's bots). Reproduced live: such ghosts
-  // keyed as legacy::<display-name> and doubled the seated roster.
-  const { resolveLegacyMemberDescriptor } = load({ groups: {}, roster: [] })
-  const resolved = resolveLegacyMemberDescriptor({ name: '大司命' }, [TAIYI])
-  assert.equal(resolved.name, 'taiyi')
-})
-
-test('friendly-name matching never crosses connections', () => {
-  const remoteTwin = { connectionId: 'other-box', name: 'shadow', display_name: '大司命', remoteSource: true }
-  const { resolveLegacyMemberDescriptor } = load({ groups: {}, roster: [] })
-
-  const resolved = resolveLegacyMemberDescriptor(
-    { connectionId: 'local', name: '大司命' },
-    [remoteTwin]
-  )
-  // Same friendly name on ANOTHER connection must not capture the member.
-  assert.equal(resolved.name, '大司命')
-  assert.equal(resolved.connectionId, 'local')
-})
-
-test('exact slug descriptors pass through untouched', () => {
-  const { resolveLegacyMemberDescriptor } = load({ groups: {}, roster: [] })
-  const descriptor = { connectionId: 'local', name: 'taiyi', route: { targetProfile: 'taiyi' } }
-  assert.equal(resolveLegacyMemberDescriptor(descriptor, [TAIYI]), descriptor)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/legacy-sdk-compat.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/legacy-sdk-compat.test.mjs
deleted file mode 100644
index 8add88a4f35b..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/legacy-sdk-compat.test.mjs
+++ /dev/null
@@ -1,91 +0,0 @@
-import assert from 'node:assert/strict'
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import test from 'node:test'
-import { pathToFileURL } from 'node:url'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-const OPTIONAL_CAPABILITY_EXPORTS = new Set(['McpTab', 'ToolsetConfigPanel', 'SkillsView'])
-
-function sdkNamedImports(source) {
-  const match = source.match(/import\s+\{([\s\S]*?)\}\s+from '@hermes\/plugin-sdk'/)
-
-  assert.ok(match, 'plugin.js must retain the mandatory named SDK import')
-
-  return match[1]
-    .split(',')
-    .map(name => name.trim())
-    .filter(Boolean)
-    .map(name => name.split(/\s+as\s+/)[0])
-}
-
-function proxyModule(exportNames) {
-  const exports = exportNames.map(name => `  proxy as ${name}`).join(',\n')
-
-  return `const proxy = new Proxy(function () { return proxy }, {
-  apply: () => proxy,
-  get: (_target, key) => {
-    if (key === Symbol.iterator) return function * () {}
-    if (key === Symbol.toPrimitive) return () => 0
-    if (key === 'then') return undefined
-    return proxy
-  }
-})
-
-export {
-${exports}
-}
-`
-}
-
-function writeLegacySdk(root) {
-  const packageRoot = join(root, 'node_modules', '@hermes', 'plugin-sdk')
-  const exportNames = sdkNamedImports(pluginSource).filter(
-    name => !OPTIONAL_CAPABILITY_EXPORTS.has(name)
-  )
-
-  mkdirSync(packageRoot, { recursive: true })
-  writeFileSync(
-    join(packageRoot, 'package.json'),
-    `${JSON.stringify({ name: '@hermes/plugin-sdk', type: 'module', exports: './index.js' }, null, 2)}\n`
-  )
-  writeFileSync(join(packageRoot, 'index.js'), proxyModule(exportNames))
-}
-
-function writeReactStubs(root) {
-  const packageRoot = join(root, 'node_modules', 'react')
-
-  mkdirSync(packageRoot, { recursive: true })
-  writeFileSync(
-    join(packageRoot, 'package.json'),
-    `${JSON.stringify(
-      {
-        name: 'react',
-        type: 'module',
-        exports: { '.': './index.js', './jsx-runtime': './jsx-runtime.js' }
-      },
-      null,
-      2
-    )}\n`
-  )
-  writeFileSync(join(packageRoot, 'index.js'), proxyModule(['useEffect', 'useMemo', 'useRef', 'useState']))
-  writeFileSync(join(packageRoot, 'jsx-runtime.js'), proxyModule(['jsx', 'jsxs']))
-}
-
-test('legacy SDK without optional capability exports still links Bot Mode', async t => {
-  const root = mkdtempSync(join(tmpdir(), 'hermes-bot-mode-legacy-sdk-'))
-  const pluginPath = join(root, 'plugin.js')
-
-  t.after(() => rmSync(root, { recursive: true, force: true }))
-
-  writeFileSync(join(root, 'package.json'), '{"type":"module"}\n')
-  writeFileSync(pluginPath, pluginSource)
-  writeLegacySdk(root)
-  writeReactStubs(root)
-
-  const loaded = await import(pathToFileURL(pluginPath).href)
-
-  assert.equal(loaded.default.id, 'hermes-bots')
-  assert.equal(typeof loaded.default.register, 'function')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/mention-completions.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/mention-completions.test.mjs
deleted file mode 100644
index 71120fd77da8..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/mention-completions.test.mjs
+++ /dev/null
@@ -1,146 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// The mention-completions source (#88060): typing @ offers roster handles.
-// Extract the registered provide() by running plugin registration with a
-// stubbed ctx/queryClient and exercising the captured contribution.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadProvide({ roster, active = 'default', focused = active, meta = {} } = {}) {
-  const registrations = []
-  const atom = value => {
-    let current = value
-
-    return { get: () => current, set: next => (current = next), listen: () => () => undefined }
-  }
-  const jsx = (type, props = {}) => ({ type, props })
-  const context = {
-    atom,
-    jsx,
-    jsxs: jsx,
-    useQuery: () => ({}),
-    useValue: v => (v?.get ? v.get() : v),
-    useState: v => [v, () => undefined],
-    setTimeout,
-    clearTimeout,
-    performance,
-    window: {
-      setTimeout,
-      clearTimeout,
-      performance,
-      requestAnimationFrame: () => 0,
-      cancelAnimationFrame: () => undefined,
-      addEventListener: () => undefined,
-      removeEventListener: () => undefined
-    },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    queryClient: {
-      // Key-exact semantics like the real QueryClient (v5): a 2-element
-      // ROSTER_KEY lookup MUST miss the 3-element cache keys useRoster
-      // writes — the bug behind issue #89303 was invisible under the old
-      // key-ignoring mock.
-      getQueryData: key =>
-        key.length === 3 && key[0] === 'hermes-bots' && key[1] === 'roster'
-          ? roster
-          : undefined,
-      getQueriesData: () => (Array.isArray(roster?.profiles) ? [[['hermes-bots', 'roster', 'local'], roster]] : []),
-      invalidateQueries: () => undefined,
-      setQueryData: () => undefined
-    },
-    host: {
-      state: {
-        profile: { get: () => active, listen: () => () => undefined },
-        focusedSessionProfile: { get: () => focused, listen: () => () => undefined },
-        gateway: { get: () => null, listen: () => () => undefined },
-        connectionId: { get: () => 'local', listen: () => () => undefined }
-      },
-      request: async () => ({}),
-      onEvent: () => () => undefined
-    },
-    COMPOSER_AREAS: { middleware: 'composer.middleware', atCompletions: 'composer.atCompletions' },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const code = source
-    .replace(/^import \* as sdk from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__botMeta = $botMeta;')
-  vm.runInNewContext(code, context)
-  context.__botMeta.set(meta)
-
-  const ctx = {
-    register: c => registrations.push(c),
-    storage: { get: async () => undefined, set: async () => undefined }
-  }
-
-  try {
-    context.plugin.register(ctx)
-  } catch {
-    /* registration walks UI surfaces the stub doesn't fully model — the
-       contributions registered before any throw are what we assert on */
-  }
-
-  const contribution = registrations.find(c => c.area === 'composer.atCompletions')
-  assert.ok(contribution, 'mention-completions contribution registered')
-
-  return contribution.data.provide
-}
-
-const ROSTER = {
-  profiles: [
-    { name: 'default' },
-    { name: 'researcher' },
-    { name: 'writer', connectionLabel: 'Homelab', handle: 'writer-homelab' }
-  ]
-}
-
-test('offers roster handles for a matching prefix, excluding the active profile', () => {
-  const provide = loadProvide({ roster: ROSTER, active: 'researcher' })
-  const all = provide('')
-  const inserts = all.map(i => i.insert)
-
-  assert.ok(inserts.includes('@hermes'), 'default surfaces as @hermes')
-  assert.ok(inserts.includes('@writer-homelab'), 'multi-source handle used')
-  assert.ok(!inserts.includes('@researcher'), 'active profile excluded')
-})
-
-test('prefix-filters against the handle', () => {
-  const provide = loadProvide({ roster: ROSTER, active: 'default' })
-
-  assert.deepStrictEqual([...provide('wri').map(i => i.insert)], ['@writer-homelab'])
-  assert.strictEqual(provide('zzz').length, 0)
-})
-
-test('filters self by the focused Bot Chat owner, not the gateway socket profile', () => {
-  const provide = loadProvide({
-    active: 'default',
-    focused: 'renametest',
-    roster: {
-      profiles: [
-        { name: 'default', display_name: 'Lucy' },
-        { name: 'renametest' }
-      ]
-    }
-  })
-
-  const inserts = provide('').map(item => item.insert)
-  assert.ok(
-    inserts.includes('@lucy'),
-    'renamed default profile remains mentionable from the focused bot chat'
-  )
-  assert.ok(
-    !inserts.includes('@renametest'),
-    'focused bot excludes itself even when the socket stays on default'
-  )
-})
-
-test('empty roster cache yields no rows (never throws)', () => {
-  const provide = loadProvide({ roster: undefined })
-
-  assert.strictEqual(provide('a').length, 0)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/mention-identification.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/mention-identification.test.mjs
deleted file mode 100644
index f3baf159640a..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/mention-identification.test.mjs
+++ /dev/null
@@ -1,155 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// The @mention middleware is IDENTIFICATION-ONLY (Aug 2026 redesign): it
-// resolves the user's @tags against the live roster and annotates the draft
-// with who they refer to. It never delivers anything — the agent owns
-// messaging via its Bot-Chat message_agent tool, so there is exactly one
-// send path, no renderer-side shellout instructions, and no verbatim
-// forwarding of the user's text (the class behind #91397/#91304/#91339).
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load({
-  activeProfile = 'research',
-  focusedProfile = activeProfile,
-  profiles = ['research', 'ops'],
-  title = null,
-  unionProfiles = null,
-  requestProfileSpy = null
-} = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: async method => {
-        if (method === 'profiles.list') {
-          return {
-            profiles: profiles.map(profile =>
-              typeof profile === 'string' ? { name: profile } : profile
-            )
-          }
-        }
-        return {}
-      },
-      ...(requestProfileSpy ? { requestProfile: requestProfileSpy } : {}),
-      state: {
-        profile: { get: () => activeProfile, listen: () => undefined },
-        focusedSessionProfile: { get: () => focusedProfile, listen: () => undefined },
-        connectionId: { get: () => 'local', listen: () => undefined },
-        gateway: { listen: () => undefined }
-      }
-    },
-    ...(unionProfiles
-      ? { queryClient: { getQueryData: () => ({ profiles: unionProfiles }) } }
-      : {})
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__mention = { $botMeta };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  context.__mention.$botMeta.set(title ? { [activeProfile]: { title } } : {})
-
-  const registered = []
-  context.plugin.register({ storage: { get: () => null }, register: entry => registered.push(entry) })
-  const middleware = registered.find(entry => entry.id === 'mention-middleware')
-  assert.ok(middleware, 'mention middleware did not register')
-  return { handler: middleware.data.handler }
-}
-
-test('identification: a local mention annotates who the user means', async () => {
-  const { handler } = load()
-  const result = await handler({ text: 'please @ops review the diff' })
-  assert.match(result.text, /@mentions resolved from the Bot Mode roster/)
-  assert.match(result.text, /@ops = agent profile "ops"/)
-  assert.match(result.text, /message_agent/)
-})
-
-test('containment: the note never teaches a shellout and never forwards a command', async () => {
-  const { handler } = load()
-  const result = await handler({ text: 'ask @ops to summarize' })
-  assert.doesNotMatch(result.text, /hermes -p/)
-  assert.doesNotMatch(result.text, /terminal call/i)
-  assert.doesNotMatch(result.text, /background=true/)
-})
-
-test('containment: the note tells the agent to compose, never forward verbatim', async () => {
-  const { handler } = load()
-  const result = await handler({ text: '@ops handle this' })
-  assert.match(result.text, /compose your own message/i)
-  assert.match(result.text, /never forward/i)
-})
-
-test('security: a poisoned bot title stays inert prose (no shell context exists)', async () => {
-  const title = 'Evil" ; touch /tmp/pwned ; echo "$(touch /tmp/pwned2)"'
-  const { handler } = load({
-    activeProfile: 'ops',
-    focusedProfile: 'ops',
-    profiles: [{ name: 'ops' }, { name: 'research', display_name: title }]
-  })
-  const result = await handler({ text: 'ping @research please' })
-  // The note is plain prose fed to the model — there is no command to break
-  // out of. The only invariant left: no hermes command is ever emitted.
-  assert.doesNotMatch(result.text, /`hermes/)
-})
-
-test('remote mentions: identified with their device, never delivered by the renderer', async () => {
-  const delivered = []
-  const { handler } = load({
-    activeProfile: 'default',
-    focusedProfile: 'default',
-    unionProfiles: [
-      { name: 'default', connectionId: 'local' },
-      {
-        name: 'dixie',
-        connectionId: 'mac-mini',
-        connectionLabel: 'Mac Mini',
-        handle: 'dixie',
-        remoteSource: true
-      }
-    ],
-    requestProfileSpy: async (...args) => {
-      delivered.push(args)
-      return {}
-    }
-  })
-
-  const result = await handler({ text: '@dixie what is the disk space?' })
-  assert.match(result.text, /@dixie = agent profile "dixie"/)
-  assert.match(result.text, /on Mac Mini/)
-  // The renderer must NOT deliver: no requestProfile traffic at all.
-  await new Promise(resolve => setTimeout(resolve, 50))
-  assert.equal(delivered.length, 0, 'middleware must never deliver over Connections')
-})
-
-test('unknown @ and emails pass through untouched', async () => {
-  const { handler } = load()
-  const untouched = 'mail user@example.com and ping @nosuchbot'
-  const result = await handler({ text: untouched })
-  assert.equal(result.text, untouched)
-})
-
-test('source contract: the delivery machinery is gone from plugin.js', () => {
-  assert.doesNotMatch(pluginSource, /deliverRemoteRosterMentions/)
-  assert.doesNotMatch(pluginSource, /pollRemoteDmReply/)
-  assert.doesNotMatch(pluginSource, /ensureRemoteCanonicalChat/)
-  assert.doesNotMatch(pluginSource, /REMOTE_DM_TIMEOUT_MS/)
-  // The middleware must not know how to build a bot-to-bot hermes command.
-  assert.doesNotMatch(pluginSource, /\[@mention handoff/)
-  assert.doesNotMatch(pluginSource, /Desktop is delivering/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/mention-renamed-bots.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/mention-renamed-bots.test.mjs
deleted file mode 100644
index afa10e474622..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/mention-renamed-bots.test.mjs
+++ /dev/null
@@ -1,188 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Renamed bots stay taggable (Discord report, Aug 2026): renaming a bot —
-// Bot Mode title or `hermes profile rename` display_name — must update what
-// the user can @-tag it with, in the mention middleware, group rooms, and
-// the composer autocomplete. Old profile handles keep resolving.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function runtime({ meta } = {}) {
-  const context = {
-    console,
-    setTimeout,
-    clearTimeout,
-    Date,
-    URL,
-    atom: initial => {
-      let value = initial
-      return { get: () => value, set: next => (value = next), listen: () => () => undefined }
-    },
-    host: {
-      request: async () => ({}),
-      requestProfile: async () => ({}),
-      state: {
-        profile: { get: () => 'default', listen: () => undefined },
-        connectionId: { get: () => 'local', listen: () => undefined },
-        gateway: { listen: () => undefined }
-      }
-    },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } }
-  }
-  const code = source
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__x = { mentionNameForms, botFriendlyNames, botMentionTag, resolveRosterMentions, parseGroupChatMentions, groupMemberKey, durableGroupChatMembers, $botMeta };\n'
-    )
-  vm.runInNewContext(code, context, { filename: 'plugin.js' })
-  if (meta) {
-    context.__x.$botMeta.set(meta)
-  }
-  return context.__x
-}
-
-test('mentionNameForms: slugged + collapsed, reserved tokens dropped', () => {
-  const { mentionNameForms } = runtime()
-
-  assert.deepEqual(JSON.parse(JSON.stringify(mentionNameForms('Research Buddy'))), ['research-buddy', 'researchbuddy'])
-  assert.deepEqual(JSON.parse(JSON.stringify(mentionNameForms('Ops'))), ['ops'])
-  // A bot renamed "Hermes" or "everyone" cannot hijack reserved tags.
-  assert.equal(mentionNameForms('Hermes').length, 0)
-  assert.equal(mentionNameForms('@everyone').length, 0)
-  assert.equal(mentionNameForms('').length, 0)
-})
-
-test('botMentionTag: renamed slug wins, profile handle is the fallback', () => {
-  const { botMentionTag } = runtime({ meta: { writer: { title: 'Research Buddy' } } })
-
-  assert.equal(botMentionTag({ name: 'writer' }), 'research-buddy')
-  assert.equal(botMentionTag({ name: 'ops' }), 'ops')
-  assert.equal(botMentionTag({ name: 'default' }), 'hermes')
-  // display_name (hermes profile rename) drives the tag too.
-  assert.equal(botMentionTag({ name: 'scout', display_name: 'Deal Finder' }), 'deal-finder')
-})
-
-test('resolveRosterMentions: renamed bots resolve by friendly tag AND old handle', () => {
-  const { resolveRosterMentions } = runtime({ meta: { writer: { title: 'Research Buddy' } } })
-  const roster = [{ name: 'default' }, { name: 'writer' }, { name: 'scout', display_name: 'Deal Finder' }]
-  const live = { name: 'default', connectionId: 'local' }
-
-  const byTitle = resolveRosterMentions('hey @research-buddy check this', roster, live)
-  assert.deepEqual(JSON.parse(JSON.stringify(byTitle.map(b => b.name))), ['writer'])
-
-  const byDisplayName = resolveRosterMentions('ping @dealfinder please', roster, live)
-  assert.deepEqual(JSON.parse(JSON.stringify(byDisplayName.map(b => b.name))), ['scout'])
-
-  // The profile name keeps working after a rename.
-  const byName = resolveRosterMentions('hey @writer', roster, live)
-  assert.deepEqual(JSON.parse(JSON.stringify(byName.map(b => b.name))), ['writer'])
-})
-
-test('parseGroupChatMentions: display_name and ui_meta title forms address a member', () => {
-  const { parseGroupChatMentions, groupMemberKey } = runtime()
-  const members = [
-    { name: 'research', title: '' },
-    { name: 'builder', title: '', display_name: 'Site Smith' },
-    { name: 'ops', title: '', ui_meta: { 'hermes-bots': { title: 'Night Watch' } } }
-  ]
-
-  const bySlug = parseGroupChatMentions('@site-smith and @night-watch please', members)
-  assert.equal(bySlug.mentioned.has(groupMemberKey(members[1])), true)
-  assert.equal(bySlug.mentioned.has(groupMemberKey(members[2])), true)
-  assert.equal(bySlug.mentioned.has(groupMemberKey(members[0])), false)
-
-  const collapsed = parseGroupChatMentions('@sitesmith take a look', members)
-  assert.equal(collapsed.mentioned.has(groupMemberKey(members[1])), true)
-})
-
-test('durableGroupChatMembers persists the friendly identity for renamed-tag mentions', () => {
-  const { durableGroupChatMembers, $botMeta } = runtime()
-  $botMeta.set({ writer: { title: 'Research Buddy' } })
-
-  const [stored] = durableGroupChatMembers([{ name: 'writer', connectionId: 'local' }])
-  assert.equal(stored.title, 'Research Buddy')
-
-  const [remote] = durableGroupChatMembers([
-    { name: 'scout', display_name: 'Deal Finder', connectionId: 'mac-mini', remoteSource: true }
-  ])
-  assert.equal(remote.display_name, 'Deal Finder')
-})
-
-test('composer autocomplete offers the renamed tag and matches on the display name', () => {
-  const registrations = []
-  const atom = value => {
-    let current = value
-    return { get: () => current, set: next => (current = next), listen: () => () => undefined }
-  }
-  const jsx = (type, props = {}) => ({ type, props })
-  const roster = { profiles: [{ name: 'default' }, { name: 'writer' }, { name: 'ops' }] }
-  const context = {
-    atom,
-    jsx,
-    jsxs: jsx,
-    useQuery: () => ({}),
-    useValue: v => (v?.get ? v.get() : v),
-    useState: v => [v, () => undefined],
-    setTimeout,
-    clearTimeout,
-    performance,
-    window: {
-      setTimeout,
-      clearTimeout,
-      performance,
-      requestAnimationFrame: () => 0,
-      cancelAnimationFrame: () => undefined,
-      addEventListener: () => undefined,
-      removeEventListener: () => undefined
-    },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    queryClient: { getQueryData: () => roster, invalidateQueries: () => undefined, setQueryData: () => undefined },
-    host: {
-      state: { profile: { get: () => 'default', listen: () => () => undefined }, gateway: { get: () => null, listen: () => () => undefined } },
-      request: async () => ({}),
-      onEvent: () => () => undefined
-    },
-    COMPOSER_AREAS: { middleware: 'composer.middleware', atCompletions: 'composer.atCompletions' },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const code = source
-    .replace(/^import \* as sdk from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__botMeta = $botMeta;')
-  vm.runInNewContext(code, context)
-  context.__botMeta.set({ writer: { title: 'Research Buddy' } })
-
-  try {
-    context.plugin.register({
-      register: c => registrations.push(c),
-      storage: { get: async () => undefined, set: async () => undefined }
-    })
-  } catch {
-    /* registration walks UI surfaces the stub doesn't fully model */
-  }
-
-  const provide = registrations.find(c => c.area === 'composer.atCompletions').data.provide
-
-  // The renamed bot completes under its friendly prefix and inserts the tag.
-  const renamed = provide('rese')
-  assert.deepEqual(JSON.parse(JSON.stringify(renamed.map(i => i.insert))), ['@research-buddy'])
-
-  // Old profile-handle muscle memory still finds it (insert is the new tag).
-  const byHandle = provide('wri')
-  assert.deepEqual(JSON.parse(JSON.stringify(byHandle.map(i => i.insert))), ['@research-buddy'])
-
-  // Un-renamed bots keep their plain handle.
-  const plain = provide('op')
-  assert.deepEqual(JSON.parse(JSON.stringify(plain.map(i => i.insert))), ['@ops'])
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/mention-roster-cache-key.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/mention-roster-cache-key.test.mjs
deleted file mode 100644
index b76bd18e88f5..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/mention-roster-cache-key.test.mjs
+++ /dev/null
@@ -1,208 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// useRoster() keys its query on [...ROSTER_KEY, connectionId] — one cache
-// entry per connection the window has been on. The imperative roster readers
-// (the @mention completions and the mention middleware) used to call
-// getQueryData(ROSTER_KEY) with the BARE key, which is an exact-key match in
-// TanStack Query and therefore matched NOTHING: completions offered no
-// roster handles and remote @name-device mentions passed through the
-// middleware unhandled (the local profiles.list fallback only knows bare
-// local names). Reproduced on a two-source install where the same profile
-// name exists locally and on an SSH connection ("Vera"): typing
-// `@default-vera` did nothing. These tests model the REAL cache semantics —
-// entries stored under the suffixed key, exact-key reads missing them,
-// prefix reads finding them — so the key-shape regression is pinned.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-/** Faithful-enough TanStack Query v5 cache: getQueryData matches ONLY the
- *  exact key, getQueriesData prefix-matches a key family. */
-function makeQueryClient() {
-  const entries = new Map()
-  const keyOf = key => JSON.stringify(key)
-
-  return {
-    setQueryData: (key, value) => {
-      entries.set(keyOf(key), { key, value })
-    },
-    getQueryData: key => entries.get(keyOf(key))?.value,
-    getQueriesData: ({ queryKey }) =>
-      [...entries.values()]
-        .filter(({ key }) => queryKey.every((part, index) => key[index] === part))
-        .map(({ key, value }) => [key, value]),
-    invalidateQueries: () => undefined
-  }
-}
-
-// One profile name on two sources: locally and on the SSH connection "vera".
-// The union roster disambiguates the remote row as @default-vera.
-const ROSTER = {
-  profiles: [
-    { name: 'default', connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device' },
-    {
-      name: 'default',
-      handle: 'default-vera',
-      connectionId: 'vera',
-      connectionKind: 'ssh',
-      connectionLabel: 'Vera',
-      remoteSource: true,
-      sourceScoped: true
-    }
-  ]
-}
-
-function load({ cacheKeyConnection = 'local' } = {}) {
-  const registrations = []
-  const delivered = []
-  let submitted = false
-  const atom = value => {
-    let current = value
-
-    return { get: () => current, set: next => (current = next), listen: () => () => undefined }
-  }
-  const jsx = (type, props = {}) => ({ type, props })
-  const queryClient = makeQueryClient()
-
-  // Exactly where useRoster writes it: suffixed with the connection id.
-  queryClient.setQueryData(['hermes-bots', 'roster', cacheKeyConnection], ROSTER)
-
-  const context = {
-    atom,
-    jsx,
-    jsxs: jsx,
-    useQuery: () => ({}),
-    useValue: v => (v?.get ? v.get() : v),
-    useState: v => [v, () => undefined],
-    setTimeout,
-    clearTimeout,
-    performance,
-    window: {
-      setTimeout,
-      clearTimeout,
-      performance,
-      requestAnimationFrame: () => 0,
-      cancelAnimationFrame: () => undefined,
-      addEventListener: () => undefined,
-      removeEventListener: () => undefined
-    },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    queryClient,
-    host: {
-      state: {
-        profile: { get: () => 'default', listen: () => () => undefined },
-        connectionId: { get: () => 'local', listen: () => () => undefined },
-        gateway: { get: () => null, listen: () => () => undefined }
-      },
-      request: async () => ({}),
-      requestProfile: async (route, method, params) => {
-        delivered.push([route?.connectionId, route?.profile, method])
-
-        if (method === 'profiles.list') {
-          return {
-            profiles: [{ name: 'default', ui_meta: { 'hermes-bots': { chat: 'remote-pin' } } }]
-          }
-        }
-
-        if (method === 'session.resume') {
-          if (params?.omit_messages) {
-            return { session_id: 'remote-1', session_key: 'remote-pin' }
-          }
-
-          // Baseline read before the submit, then the reply poll after it:
-          // once the submit happened, hand back an assistant message so the
-          // bounded reply poll terminates on its first pass (~2s) instead of
-          // idling until the 180s timeout.
-          if (!submitted) {
-            return { messages: [] }
-          }
-
-          return {
-            messages: [
-              { role: 'user', content: 'ping' },
-              { role: 'assistant', content: 'first' },
-              { role: 'assistant', content: 'ok' }
-            ]
-          }
-        }
-
-        if (method === 'prompt.submit') {
-          submitted = true
-        }
-
-        return {}
-      },
-      onEvent: () => () => undefined
-    },
-    COMPOSER_AREAS: { middleware: 'composer.middleware', atCompletions: 'composer.atCompletions' },
-    PALETTE_AREA: 'palette',
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const code = pluginSource
-    .replace(/^import \* as sdk from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__botMeta = $botMeta;')
-  vm.runInNewContext(code, context)
-  context.__botMeta.set({})
-
-  const ctx = {
-    register: c => registrations.push(c),
-    storage: { get: async () => undefined, set: async () => undefined }
-  }
-
-  try {
-    context.plugin.register(ctx)
-  } catch {
-    /* registration walks UI surfaces the stub doesn't fully model — the
-       contributions registered before any throw are what we assert on */
-  }
-
-  const completions = registrations.find(c => c.id === 'mention-completions')
-  const middleware = registrations.find(c => c.id === 'mention-middleware')
-  assert.ok(completions, 'mention-completions contribution registered')
-  assert.ok(middleware, 'mention middleware registered')
-
-  return { provide: completions.data.provide, handler: middleware.data.handler, delivered, queryClient }
-}
-
-test('the roster cache entry lives under the connection-suffixed key, invisible to the bare-key read', () => {
-  // Documents the regression's shape: the entry useRoster writes is NOT
-  // reachable through an exact getQueryData(ROSTER_KEY).
-  const { queryClient } = load()
-
-  assert.equal(queryClient.getQueryData(['hermes-bots', 'roster']), undefined)
-  assert.equal(queryClient.getQueriesData({ queryKey: ['hermes-bots', 'roster'] }).length, 1)
-})
-
-test('mention completions offer remote @name-device handles from the suffixed cache entry', () => {
-  const { provide } = load()
-  const inserts = provide('').map(item => item.insert)
-
-  assert.ok(inserts.includes('@default-vera'), `expected @default-vera in ${JSON.stringify(inserts)}`)
-})
-
-test('the middleware identifies a remote @name-device mention without delivering (identification-only)', async () => {
-  const { handler, delivered } = load()
-  const result = await handler({ text: '@default-vera what is the disk space on the server?' })
-
-  assert.match(result.text, /@mentions resolved from the Bot Mode roster/)
-  assert.match(result.text, /@default-vera/)
-  // No CLI handoff is composed and the renderer performs NO delivery — the
-  // agent owns messaging via its message_agent tool.
-  assert.doesNotMatch(result.text, /hermes -p '?default/)
-  await new Promise(resolve => setTimeout(resolve, 0))
-  assert.equal(delivered.length, 0, 'middleware must not deliver over Connections')
-})
-
-test('a roster cached under another connection id still resolves (fallback entry)', () => {
-  // The window moved connections; the stale entry is the only one cached.
-  const { provide } = load({ cacheKeyConnection: 'vera' })
-  const inserts = provide('').map(item => item.insert)
-
-  assert.ok(inserts.includes('@default-vera'), `expected @default-vera in ${JSON.stringify(inserts)}`)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/model-inherit.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/model-inherit.test.mjs
deleted file mode 100644
index 1e539cdd5433..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/model-inherit.test.mjs
+++ /dev/null
@@ -1,96 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadApplyAdvancedConfig(request) {
-  const start = source.indexOf('async function applyAdvancedConfig(')
-  const end = source.indexOf('// ── edit profile dialog', start)
-  const context = {
-    host: { request },
-    requestForBot: (_bot, method, params) => request(method, params),
-    ensureMessagingProtocol: soul => soul,
-    $lastRoster: { get: () => [] }
-  }
-  const section = source
-    .slice(start, end)
-    .concat('\nglobalThis.__advanced = { applyAdvancedConfig };\n')
-
-  assert.notEqual(start, -1, 'applyAdvancedConfig is missing')
-  assert.notEqual(end, -1, 'advanced-config section delimiter is missing')
-  vm.runInNewContext(section, context, { filename: 'advanced-config.js' })
-  return context.__advanced.applyAdvancedConfig
-}
-
-function state(patch = {}) {
-  return {
-    provider: '',
-    model: '',
-    soul: '',
-    skills: [],
-    toolsets: [],
-    dirtyModel: false,
-    dirtySoul: false,
-    dirtySkills: false,
-    dirtyToolsets: false,
-    ...patch
-  }
-}
-
-test('regression: selecting Inherit explicitly clears the profile model assignment', async () => {
-  const calls = []
-  const apply = loadApplyAdvancedConfig(async (method, params) => {
-    calls.push({ method, params })
-    return { code: 0, blocked: false, output: 'Unset model' }
-  })
-
-  const result = await apply({ name: 'ops' }, state({ dirtyModel: true }))
-
-  assert.deepEqual(JSON.parse(JSON.stringify(calls)), [
-    {
-      method: 'cli.exec',
-      params: { argv: ['--profile', 'ops', 'config', 'unset', 'model'] }
-    }
-  ])
-  assert.deepEqual(JSON.parse(JSON.stringify(result)), { ok: true, applied: { model: true } })
-})
-
-test('integration: model clearing and other dirty sections report a merged result', async () => {
-  const calls = []
-  const apply = loadApplyAdvancedConfig(async (method, params) => {
-    calls.push({ method, params })
-    if (method === 'cli.exec') return { code: 0, blocked: false, output: 'Unset model' }
-    return { ok: true, applied: { soul: true } }
-  })
-
-  const result = await apply({ name: 'ops' }, state({ dirtyModel: true, dirtySoul: true, soul: '# Ops' }))
-
-  assert.equal(calls[0].method, 'cli.exec')
-  assert.deepEqual(JSON.parse(JSON.stringify(calls[1])), {
-    method: 'profiles.configure',
-    params: { name: 'ops', soul: '# Ops' }
-  })
-  assert.deepEqual(JSON.parse(JSON.stringify(result)), {
-    ok: true,
-    applied: { model: true, soul: true }
-  })
-})
-
-test('regression: a rejected model clear is reported as a failed section', async () => {
-  const apply = loadApplyAdvancedConfig(async () => ({ code: 1, blocked: false, output: 'Config key not set' }))
-
-  const result = await apply({ name: 'ops' }, state({ dirtyModel: true }))
-
-  assert.deepEqual(JSON.parse(JSON.stringify(result)), { ok: false, applied: { model: false } })
-})
-
-test('regression: an advanced-section failure suppresses the contradictory success toast', () => {
-  const start = source.indexOf('function EditProfileDialog(')
-  const end = source.indexOf('function CreateAgentDialog(', start)
-  const dialog = source.slice(start, end)
-
-  assert.match(dialog, /let advancedFailed = false/)
-  assert.match(dialog, /if \(!advancedFailed && !lookFailed\) \{\s*host\.notify\(\{ kind: 'success'/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/model-picker-settle.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/model-picker-settle.test.mjs
deleted file mode 100644
index 95949339ad9d..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/model-picker-settle.test.mjs
+++ /dev/null
@@ -1,175 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #95279 regression: the Bot Mode model picker's catalog read must always
-// SETTLE and must not churn the network on every surface remount.
-//
-// The picker's query rides the BOT's own socket (a second, lazily dialed pool
-// backend — exactly the Bots-only context of #95279). Two defects there left
-// the picker unusable while Bots was active:
-//
-//   1. The RPC promise had NO deadline. A wedged dial left it pending forever
-//      → the spinner never settled and the picker was dead ("model picker
-//      never settles").
-//   2. Every fetch forced `refresh: true`, bypassing react-query's cache, so
-//      each Bots view remount (tab re-front, dialog reopen, pane visibility
-//      flip) knocked the picker back into its loading state and discarded the
-//      staged selection mid-edit.
-//
-// These tests pin the contract: bounded settlement (reject → free-text
-// fallback) and a cached, unforced catalog read.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadPickerHarness({ requestProfile } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = {
-      get: () => values.get(slot),
-      set: value => values.set(slot, value),
-      listen: () => undefined
-    }
-    values.set(slot, initial)
-    return slot
-  }
-  const jsx = (type, props = {}) => ({ type, props })
-  const routed = []
-  let query
-  const stateValues = [true, false, '']
-  const context = {
-    atom,
-    Checkbox: 'Checkbox',
-    GlyphSpinner: 'GlyphSpinner',
-    Input: 'Input',
-    ScrollArea: 'ScrollArea',
-    Textarea: 'Textarea',
-    document: { createElement: () => ({}), getElementById: () => null, head: { appendChild: () => undefined } },
-    host: {
-      getGateway: () => 'ambient-gateway',
-      requestProfile: async (...args) => {
-        routed.push(args)
-
-        return requestProfile ? requestProfile(...args) : new Promise(() => {})
-      },
-      request: async (...args) => {
-        routed.push(['ambient', ...args])
-
-        return requestProfile ? requestProfile(...args) : new Promise(() => {})
-      },
-      state: {
-        gateway: { get: () => 'open', listen: () => undefined },
-        profile: { get: () => 'default', listen: () => undefined }
-      }
-    },
-    jsx,
-    jsxs: jsx,
-    queryClient: { invalidateQueries: () => undefined },
-    sdk: {},
-    useQuery: options => {
-      query = options
-
-      return { data: undefined, isLoading: false, error: null }
-    },
-    useState: initial => [stateValues.length ? stateValues.shift() : initial, () => undefined],
-    window: { setTimeout, clearTimeout }
-  }
-  const code = source
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__useModelOptions = useModelOptions;')
-  vm.runInNewContext(code, context, { filename: 'plugin.js' })
-
-  return { context, query: () => query, routed }
-}
-
-const remoteBot = {
-  connectionId: 'remote-a',
-  name: 'default',
-  remoteSource: true,
-  route: {
-    connectionId: 'remote-a',
-    mode: 'remote',
-    profile: 'default',
-    targetProfile: 'backend-default'
-  },
-  sourceScoped: true,
-  targetProfile: 'backend-default'
-}
-
-test('#95279: the picker catalog query settles when the bot gateway never answers', async t => {
-  // Fake clocks: tick past the settle budget without waiting real time. The
-  // harness captured the mocked setTimeout above (enable runs first).
-  t.mock.timers.enable({ apis: ['setTimeout'] })
-
-  const runtime = loadPickerHarness({ requestProfile: () => new Promise(() => {}) })
-  runtime.context.__useModelOptions(remoteBot)
-  const query = runtime.query()
-
-  assert.equal(typeof query.queryFn, 'function')
-
-  let settled = false
-
-  query.queryFn().then(
-    () => {
-      settled = 'resolved'
-    },
-    () => {
-      settled = 'rejected'
-    }
-  )
-
-  // Past the settle budget the bounded fetch must have rejected (the picker
-  // then renders its free-text fallback). A macrotask boundary drains every
-  // microtask hop of the rejection chain before we look.
-  t.mock.timers.tick(30_000)
-  await new Promise(resolve => setImmediate(resolve))
-
-  assert.equal(settled, 'rejected')
-})
-
-test('#95279: the picker catalog read is cached, not force-refreshed on every mount', async () => {
-  const runtime = loadPickerHarness({
-    requestProfile: async () => ({ providers: [{ models: ['m1'], name: 'Prov', slug: 'prov' }] })
-  })
-  runtime.context.__useModelOptions(remoteBot)
-  const query = runtime.query()
-
-  // Same bot + route ⇒ one stable cache key, so Bots view remounts reuse the
-  // fetched catalog instead of knocking the picker back into its spinner.
-  assert.deepEqual(query.queryKey[1], 'model-options')
-  assert.deepEqual(query.queryKey[2], 'remote-a::default')
-
-  const data = await query.queryFn()
-
-  assert.deepEqual(JSON.parse(JSON.stringify(data)), {
-    providers: [{ models: ['m1'], name: 'Prov', slug: 'prov' }]
-  })
-
-  // No forced refresh: the read participates in the staleTime cache. A forced
-  // refresh here is what made every remount re-enter the loading state and
-  // wipe the user's in-progress pick (#95279).
-  assert.deepEqual(JSON.parse(JSON.stringify(runtime.routed)), [
-    [remoteBot.route, 'model.options', { include_unconfigured: true, explicit_only: false }]
-  ])
-})
-
-test('#95279: picker query stays disabled for orphaned rows and keyed active for local bots', () => {
-  const runtime = loadPickerHarness()
-
-  // An orphaned row must not dispatch at all (renders free-text fallback).
-  runtime.context.__useModelOptions({ name: 'ghost', remoteSource: true })
-  const orphanQuery = runtime.query()
-  assert.equal(orphanQuery.enabled, false)
-
-  // A local (non source-scoped) bot reads the ambient gateway under the
-  // stable 'active' key.
-  runtime.context.__useModelOptions({ name: 'default' })
-  const localQuery = runtime.query()
-  assert.equal(localQuery.enabled, true)
-  assert.deepEqual(localQuery.queryKey[2], 'active')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/model-switch-confirm.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/model-switch-confirm.test.mjs
deleted file mode 100644
index 1ae57f0966d2..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/model-switch-confirm.test.mjs
+++ /dev/null
@@ -1,188 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #95293 remainder: a GUARDED model switch made from the Bots surface must
-// surface the SAME confirm flow the core picker uses, then resend with
-// `confirm_expensive_model: true` once the user confirms.
-//
-// The Bots editor's switch path is `applyAdvancedConfig` → `profiles.configure`
-// (it does NOT route through use-model-controls). The gateway now answers
-// `confirm_required` + `confirm_message` for guarded picks on this surface too
-// (same handshake as `config.set model`); the plugin must:
-//
-//   1. route that response through the shared confirm handler
-//      (`surfaceModelSwitchConfirm` from the plugin SDK — one applier, no
-//      forked confirm logic per surface),
-//   2. NOT count the pending model section as a failed section, and
-//   3. resend ONLY the model section with `confirm_expensive_model: true`
-//      when the user clicks Confirm.
-//
-// Pre-fix, the confirm_required response matched no branch: the pick silently
-// dropped (no confirm, no resend) — exactly issue #95293 on the Bots surface.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadHarness({ request }) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = {
-      get: () => values.get(slot),
-      set: value => values.set(slot, value),
-      listen: () => undefined
-    }
-    values.set(slot, initial)
-    return slot
-  }
-  const jsx = (type, props = {}) => ({ type, props })
-  const routed = []
-  const confirms = []
-  const invalidated = []
-  const context = {
-    atom,
-    Checkbox: 'Checkbox',
-    GlyphSpinner: 'GlyphSpinner',
-    Input: 'Input',
-    ScrollArea: 'ScrollArea',
-    Textarea: 'Textarea',
-    document: { createElement: () => ({}), getElementById: () => null, head: { appendChild: () => undefined } },
-    host: {
-      getGateway: () => 'ambient-gateway',
-      request: async (method, params) => {
-        routed.push([method, params])
-
-        return request(method, params)
-      },
-      requestProfile: async (route, method, params) => {
-        routed.push([method, params])
-
-        return request(method, params)
-      },
-      state: {
-        gateway: { get: () => 'open', listen: () => undefined },
-        profile: { get: () => 'default', listen: () => undefined }
-      }
-    },
-    jsx,
-    jsxs: jsx,
-    queryClient: { invalidateQueries: key => invalidated.push(key) },
-    sdk: {},
-    // The shared confirm handler the core picker uses, exported through the
-    // plugin SDK. The stub records the options so the test can drive the
-    // Confirm action exactly like a user click would.
-    surfaceModelSwitchConfirm: options => {
-      confirms.push(options)
-
-      return 'notification-1'
-    },
-    useQuery: () => ({ data: undefined, isLoading: false, error: null }),
-    useState: initial => [initial, () => undefined],
-    window: { setTimeout, clearTimeout }
-  }
-  const code = source
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__applyAdvancedConfig = applyAdvancedConfig;')
-  vm.runInNewContext(code, context, { filename: 'plugin.js' })
-
-  return { applyAdvancedConfig: context.__applyAdvancedConfig, confirms, invalidated, routed }
-}
-
-const bot = { name: 'zeta' }
-
-const dirtyModelState = {
-  loaded: true,
-  provider: 'opencode-go',
-  model: 'muse-spark-1.2-contributor',
-  soul: '',
-  skills: [],
-  toolsets: [],
-  mcp: [],
-  dirtyModel: true,
-  dirtySoul: false,
-  dirtySkills: false,
-  dirtyToolsets: false,
-  dirtyMcp: false
-}
-
-test('guarded Bots-mode switch surfaces the shared confirm flow instead of silently dropping', async () => {
-  const { applyAdvancedConfig, confirms, routed } = loadHarness({
-    request: async () => ({
-      ok: true,
-      applied: {},
-      confirm_required: true,
-      confirm_message: 'CONTRIBUTOR TIER: this model may train on your data.'
-    })
-  })
-
-  const res = await applyAdvancedConfig(bot, { ...dirtyModelState })
-
-  // The first request is the normal (unconfirmed) configure call.
-  assert.equal(routed.length, 1)
-  assert.equal(routed[0][0], 'profiles.configure')
-  assert.equal(routed[0][1].model, 'muse-spark-1.2-contributor')
-  assert.ok(!routed[0][1].confirm_expensive_model, 'first attempt must NOT pre-confirm')
-
-  // The confirm flow was surfaced through the SHARED handler with the
-  // gateway's message — not swallowed, not a forked local dialog.
-  assert.equal(confirms.length, 1, 'confirm_required must surface the shared confirm handler')
-  assert.match(String(confirms[0].confirmMessage || ''), /CONTRIBUTOR TIER/)
-
-  // Pending-confirmation is NOT a failed section: the editor must not toast
-  // "Some sections failed: model" while the confirm toast is up.
-  assert.notEqual(res?.applied?.model, false)
-  assert.equal(res?.ok, true)
-})
-
-test('Confirm resends ONLY the model section with confirm_expensive_model: true', async () => {
-  let calls = 0
-  const { applyAdvancedConfig, confirms, routed } = loadHarness({
-    request: async () => {
-      calls += 1
-
-      if (calls === 1) {
-        return { ok: true, applied: {}, confirm_required: true, confirm_message: 'guarded' }
-      }
-
-      return { ok: true, applied: { model: true } }
-    }
-  })
-
-  await applyAdvancedConfig(bot, { ...dirtyModelState })
-  assert.equal(confirms.length, 1)
-
-  // Drive the confirmed resend exactly as the shared handler's Confirm
-  // action does.
-  const confirmed = await confirms[0].requestConfirmed()
-
-  assert.equal(routed.length, 2)
-  const [method, params] = routed[1]
-  assert.equal(method, 'profiles.configure')
-  assert.equal(params.confirm_expensive_model, true)
-  assert.equal(params.model, 'muse-spark-1.2-contributor')
-  assert.equal(params.provider, 'opencode-go')
-  assert.equal(params.name, 'zeta')
-  // Only the model section rides the resend — no soul/skills/toolsets replay.
-  assert.deepEqual(
-    Object.keys(params).sort(),
-    ['confirm_expensive_model', 'model', 'name', 'provider']
-  )
-  assert.equal(confirmed?.applied?.model, true)
-})
-
-test('unguarded saves keep the existing single-shot behavior', async () => {
-  const { applyAdvancedConfig, confirms, routed } = loadHarness({
-    request: async () => ({ ok: true, applied: { model: true } })
-  })
-
-  const res = await applyAdvancedConfig(bot, { ...dirtyModelState })
-
-  assert.equal(routed.length, 1)
-  assert.equal(confirms.length, 0)
-  assert.equal(res?.ok, true)
-  assert.equal(res?.applied?.model, true)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/multi-source-roster.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/multi-source-roster.test.mjs
deleted file mode 100644
index 0d34889773d9..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/multi-source-roster.test.mjs
+++ /dev/null
@@ -1,868 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function runtime() {
-  const atom = value => ({ get: () => value, set: () => undefined })
-  const jsx = (type, props = {}) => ({ type, props })
-  const context = {
-    atom,
-    jsx,
-    jsxs: jsx,
-    useQuery: () => ({}),
-    useValue: value => (value?.get ? value.get() : value),
-    useState: value => [value, () => undefined],
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      state: {
-        connectionId: { get: () => 'local', listen: () => undefined },
-        profile: { get: () => 'ops', listen: () => undefined }
-      },
-      request: () => undefined
-    },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const code = source
-    .replace(/^import \* as sdk from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__mergeMultiSourceRoster = mergeMultiSourceRoster;\nglobalThis.__botHandle = botHandle;\nglobalThis.__botRosterKey = botRosterKey;\nglobalThis.__botRosterMeta = botRosterMeta;\nglobalThis.__displayName = displayName;\nglobalThis.__filterBots = filterBots;\nglobalThis.__resolveRosterMentions = resolveRosterMentions;\nglobalThis.__botConnectionRoute = botConnectionRoute;\nglobalThis.__resolveBotConnectionRoute = resolveBotConnectionRoute;\nglobalThis.__preferReachableSameNameRows = preferReachableSameNameRows;'
-    )
-  vm.runInNewContext(code, context)
-  return context
-}
-
-test('merge: no union → local list untouched', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = { profiles: [{ name: 'default', last_session: { id: 's1' } }] }
-
-  const out = merge(local, { agents: [] })
-  assert.equal(out.profiles.length, 1)
-  assert.equal(out.profiles[0].name, 'default')
-  assert.equal(out.profiles[0].last_session.id, 's1')
-})
-
-test('merge: local rows are annotated, remote rows appended with source tags', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = { profiles: [{ name: 'research', last_session: { id: 's1' } }] }
-  const union = {
-    agents: [
-      {
-        connectionId: 'local',
-        connectionKind: 'local',
-        connectionLabel: 'This device',
-        profile: 'research',
-        handle: 'research-this-device'
-      },
-      {
-        connectionId: 'homelab',
-        connectionKind: 'remote',
-        connectionLabel: 'Homelab',
-        profile: 'research',
-        handle: 'research-homelab'
-      },
-      {
-        connectionId: 'homelab',
-        connectionKind: 'remote',
-        connectionLabel: 'Homelab',
-        profile: 'coder',
-        handle: 'coder'
-      }
-    ]
-  }
-
-  const out = merge(local, union, 'local')
-  assert.equal(out.profiles.length, 3)
-
-  const localRow = out.profiles.find(p => p.name === 'research' && !p.remoteSource)
-  // Annotated in place — rich fields survive, handle attached.
-  assert.equal(localRow.last_session.id, 's1')
-  assert.equal(localRow.handle, 'research-this-device')
-  assert.equal(localRow.sourceScoped, true)
-  assert.equal(localRow.remoteSource, undefined)
-
-  const remoteRow = out.profiles.find(p => p.name === 'research' && p.remoteSource)
-  assert.equal(remoteRow.handle, 'research-homelab')
-  assert.equal(remoteRow.connectionId, 'homelab')
-  assert.equal(remoteRow.connectionLabel, 'Homelab')
-
-  const coder = out.profiles.find(p => p.name === 'coder')
-  assert.equal(coder.remoteSource, true)
-  assert.equal(coder.handle, 'coder')
-})
-
-test('merge: union-only active profiles are NOT invented as thin rows', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = { profiles: [{ name: 'default' }] }
-  const union = {
-    agents: [
-      {
-        connectionId: 'local',
-        connectionKind: 'local',
-        connectionLabel: 'This device',
-        profile: 'ghost',
-        handle: 'ghost'
-      }
-    ]
-  }
-
-  const out = merge(local, union, 'local')
-  assert.equal(out.profiles.length, 1)
-  assert.equal(out.profiles[0].name, 'default')
-})
-
-test('merge: duplicate source and local identities render once', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = {
-    profiles: [
-      { name: 'default', last_session: { id: 'newest' } },
-      { name: 'default', last_session: { id: 'stale' } }
-    ]
-  }
-  const union = {
-    agents: [
-      { connectionId: 'local', connectionKind: 'local', profile: 'default', handle: 'default-this-device' },
-      { connectionId: 'local', connectionKind: 'local', profile: 'default', handle: 'default-this-device' },
-      {
-        connectionId: 'homelab',
-        connectionKind: 'remote',
-        connectionLabel: 'Homelab',
-        profile: 'default',
-        handle: 'default-homelab'
-      },
-      {
-        connectionId: 'homelab',
-        connectionKind: 'remote',
-        connectionLabel: 'Homelab',
-        profile: 'default',
-        handle: 'default-homelab'
-      }
-    ]
-  }
-
-  const out = merge(local, union, 'local')
-
-  assert.equal(out.profiles.length, 2)
-  assert.equal(out.profiles[0].last_session.id, 'newest')
-  assert.equal(out.profiles[0].handle, 'default-this-device')
-  assert.equal(out.profiles[1].connectionId, 'homelab')
-})
-
-test('merge: rich rows follow the active remote source, not the local source', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const active = { profiles: [{ name: 'default', last_session: { id: 'remote-session' } }] }
-  const union = {
-    agents: [
-      {
-        connectionId: 'local',
-        connectionKind: 'local',
-        connectionLabel: 'This device',
-        profile: 'default',
-        handle: 'default-this-device'
-      },
-      {
-        connectionId: 'work',
-        connectionKind: 'remote',
-        connectionLabel: 'Work',
-        profile: 'default',
-        handle: 'default-work'
-      }
-    ]
-  }
-
-  const out = merge(active, union, 'work')
-  const remote = out.profiles.find(p => p.connectionId === 'work')
-  const local = out.profiles.find(p => p.connectionId === 'local')
-
-  assert.equal(remote.last_session.id, 'remote-session')
-  assert.equal(remote.sourceScoped, true)
-  assert.equal(remote.remoteSource, undefined)
-  assert.equal(local.remoteSource, true)
-  assert.equal(local.sourceScoped, true)
-})
-
-test('merge: repeated refreshes stay idempotent and do not mutate gateway rows', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const rich = { name: 'default', last_session: { id: 'remote-session' } }
-  const local = { profiles: [rich, rich] }
-  const union = {
-    agents: [
-      {
-        connectionId: 'local',
-        connectionKind: 'local',
-        connectionLabel: 'This device',
-        profile: 'default',
-        handle: 'default-this-device'
-      },
-      {
-        connectionId: 'work',
-        connectionKind: 'remote',
-        connectionLabel: 'Work',
-        profile: 'default',
-        handle: 'default-work'
-      },
-      {
-        connectionId: 'work',
-        connectionKind: 'remote',
-        connectionLabel: 'Work',
-        profile: 'default',
-        handle: 'default-work'
-      }
-    ]
-  }
-
-  const once = merge(local, union, 'work')
-  const twice = merge(once, union, 'work')
-  const identities = twice.profiles.map(row => `${row.connectionId}:${row.name}`)
-
-  assert.equal(identities.join(','), 'work:default,local:default')
-  assert.equal(new Set(identities).size, identities.length)
-  assert.equal(rich.connectionId, undefined)
-})
-
-test('default rows use source identity without borrowing another source title', () => {
-  const { __botRosterKey: key, __botRosterMeta: metaFor, __displayName: name } = runtime()
-  const remote = {
-    name: 'default',
-    connectionId: 'other',
-    connectionLabel: 'Personal',
-    remoteSource: true,
-    sourceScoped: true
-  }
-  const active = { ...remote, connectionId: 'personal', remoteSource: undefined }
-  const metadata = {
-    default: { title: 'Legacy local only' },
-    'personal::default': { title: 'Active workspace' }
-  }
-
-  assert.equal(metaFor(remote, metadata), undefined)
-  assert.equal(name(remote, metaFor(remote, metadata)), 'Personal')
-  assert.equal(key(remote), 'other::default')
-
-  // The ACTIVE gateway's own default is the user's main agent — annotation
-  // (sourceScoped + connection fields) must NOT rename it to a connection
-  // label. Titled: the title wins. Untitled: it stays "Hermes". Regression:
-  // remote-gateway desktops showed the main agent as an IP-derived label
-  // with no shortname (Aug 17 2026 report).
-  assert.equal(name(active, metadata['personal::default']), 'Active workspace')
-  assert.equal(name(active, undefined), 'Hermes')
-})
-
-test('botRosterMeta: a group roster row orphaned by a deleted connection does not throw', () => {
-  const { __botRosterMeta: metaFor } = runtime()
-  // Mirrors the persisted `group-chats` descriptor left behind once its
-  // connection is removed: remoteSource is still true, but connectionId is
-  // gone, so botConnectionRoute has nothing to resolve. This must not crash
-  // rendering the group (#93492) just because one member is unroutable.
-  const orphaned = { name: 'halakukhan', handle: 'halakukhan', connectionId: null, remoteSource: true }
-
-  assert.doesNotThrow(() => metaFor(orphaned, {}))
-  assert.equal(metaFor(orphaned, {}), null)
-})
-
-test('resolveBotConnectionRoute: typed status for resolved / owner_removed / not_scoped, and strict botConnectionRoute still fails closed', () => {
-  const { __resolveBotConnectionRoute: resolve, __botConnectionRoute: strictRoute } = runtime()
-  const orphaned = { name: 'halakukhan', connectionId: null, remoteSource: true }
-  const owned = { name: 'halakukhan', connectionId: 'conn-1', remoteSource: true }
-  const local = { name: 'default' }
-
-  // Passive resolver: typed status, never throws.
-  assert.equal(resolve(orphaned).status, 'owner_removed')
-  assert.equal(resolve(owned).status, 'resolved')
-  assert.equal(resolve(owned).route.connectionId, 'conn-1')
-  assert.equal(resolve(local).status, 'not_scoped')
-
-  // Strict wrapper used by real dispatch (requestForBot, session creation)
-  // must still fail closed on the same orphaned row -- the split only moves
-  // the *passive* lookup off this throw, it does not remove it.
-  assert.throws(() => strictRoute(orphaned), /has no connection owner/)
-  assert.equal(strictRoute(owned).connectionId, 'conn-1')
-})
-
-test('botRosterMeta: an unrelated failure while resolving meta for a live route still propagates', () => {
-  const { __botRosterMeta: metaFor } = runtime()
-  const owned = { name: 'halakukhan', connectionId: 'conn-1', remoteSource: true }
-  // A metaByName lookup that throws for reasons that have nothing to do with
-  // connection ownership must not be caught by botRosterMeta -- only the
-  // owner_removed status is treated as "no meta for this row".
-  const explodingMetaByName = new Proxy({}, {
-    get() {
-      throw new Error('unrelated invariant failure')
-    }
-  })
-
-  assert.throws(() => metaFor(owned, explodingMetaByName), /unrelated invariant failure/)
-})
-
-test('botHandle: precomputed multi-source handle wins; default stays hermes', () => {
-  const { __botHandle: botHandle } = runtime()
-
-  assert.equal(botHandle('research', { handle: 'research-homelab' }), 'research-homelab')
-  assert.equal(botHandle('research', { handle: 'research' }), 'research')
-  assert.equal(botHandle('research'), 'research')
-  assert.equal(botHandle('default'), 'hermes')
-})
-
-test('filterBots: matches the source device name for remote rows', () => {
-  const { __filterBots: filterBots } = runtime()
-  const roster = [
-    { name: 'research' },
-    {
-      name: 'research',
-      connectionId: 'homelab',
-      connectionLabel: 'Homelab',
-      handle: 'research-homelab',
-      remoteSource: true,
-      sourceScoped: true
-    }
-  ]
-
-  const hits = filterBots(roster, {}, 'homelab')
-  assert.equal(hits.length, 1)
-  assert.equal(hits[0].remoteSource, true)
-
-  // Handle search still narrows to the disambiguated row.
-  const byHandle = filterBots(roster, {}, '@research-homelab')
-  assert.equal(byHandle.length, 1)
-  assert.equal(byHandle[0].handle, 'research-homelab')
-
-  // Bare profile search keeps matching both rows.
-  assert.equal(filterBots(roster, {}, 'research').length, 2)
-})
-
-test('merge: active-gateway union agents annotate local rows, not duplicates (remote-primary desktop)', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = {
-    profiles: [
-      { name: 'default', last_session: { id: 's-default' } },
-      { name: 'dev', last_session: { id: 's-dev' } }
-    ]
-  }
-  const union = {
-    primaryConnectionId: '10-244-108-128-9119',
-    agents: [
-      // The ACTIVE remote gateway itself — same identities as local, must
-      // annotate in place rather than append phantom duplicates (#88344).
-      { connectionId: '10-244-108-128-9119', connectionKind: 'remote', connectionLabel: '10.244.108.128:9119', profile: 'default', handle: 'default-10-244-108-128-9119' },
-      { connectionId: '10-244-108-128-9119', connectionKind: 'remote', connectionLabel: '10.244.108.128:9119', profile: 'dev', handle: 'dev' },
-      // A genuinely separate source with a same-named profile keeps its own row.
-      { connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device', profile: 'default', handle: 'default-this-device' },
-      { connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device', profile: 'agent-mentor', handle: 'agent-mentor' }
-    ]
-  }
-
-  const out = merge(local, union)
-  // 2 annotated local rows + 2 other-source rows = 4, NOT 6 (no phantom copies).
-  assert.equal(out.profiles.length, 4)
-
-  const defaultRow = out.profiles.find(p => p.name === 'default' && !p.remoteSource)
-  // Annotated with the ACTIVE gateway's handle; rich fields survive.
-  assert.equal(defaultRow.last_session.id, 's-default')
-  assert.equal(defaultRow.handle, 'default-10-244-108-128-9119')
-
-  // The same-named profile on the local device stays a separate tagged row.
-  const localDefault = out.profiles.find(p => p.name === 'default' && p.remoteSource)
-  assert.equal(localDefault.handle, 'default-this-device')
-  assert.equal(localDefault.connectionId, 'local')
-
-  const mentor = out.profiles.find(p => p.name === 'agent-mentor')
-  assert.equal(mentor.remoteSource, true)
-
-  // Exactly the two other-source rows are tagged remote; none from the active gateway.
-  assert.equal(out.profiles.filter(p => p.remoteSource).length, 2)
-})
-
-test('merge: primary-local desktop keeps single-source behavior (no phantom rows)', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = { profiles: [{ name: 'default' }, { name: 'dev' }] }
-  const union = {
-    primaryConnectionId: 'local',
-    agents: [
-      { connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device', profile: 'default', handle: 'default-this-device' },
-      { connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device', profile: 'dev', handle: 'dev' }
-    ]
-  }
-
-  const out = merge(local, union)
-  assert.equal(out.profiles.length, 2)
-  assert.equal(out.profiles.filter(p => p.remoteSource).length, 0)
-  assert.equal(out.profiles[0].handle, 'default-this-device')
-})
-
-// The LIVE-active-id override: after the user activates a non-primary
-// source's agent, profiles.list answers from THAT source — the merge must
-// classify against the live id, not the registry primary, or the active
-// source's agents duplicate all over again.
-test('merge: live-null local window does not treat registry primary as active', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = { profiles: [{ name: 'default', last_session: { id: 'this-chat' } }] }
-  const union = {
-    primaryConnectionId: 'spark',
-    agents: [
-      {
-        connectionId: 'local',
-        connectionKind: 'local',
-        connectionLabel: 'This device',
-        profile: 'default',
-        handle: 'default-this-device'
-      },
-      { connectionId: 'spark', connectionKind: 'ssh', connectionLabel: 'Spark', profile: 'bob', handle: 'bob' },
-      { connectionId: 'spark', connectionKind: 'ssh', connectionLabel: 'Spark', profile: 'kai', handle: 'kai' },
-      { connectionId: 'spark', connectionKind: 'ssh', connectionLabel: 'Spark', profile: 'rook', handle: 'rook' }
-    ]
-  }
-
-  // Clicking the local agent leaves host.state.connectionId null while the
-  // registry primary stays on Spark. That must not skip Spark bots or invent
-  // a second "This device" shadow of default.
-  const out = merge(local, union, null)
-
-  assert.equal(out.profiles.filter(p => p.name === 'default').length, 1)
-  assert.equal(out.profiles.find(p => p.name === 'default').last_session.id, 'this-chat')
-  assert.equal(out.profiles.filter(p => p.remoteSource && p.connectionId === 'local').length, 0)
-  assert.equal(
-    out.profiles
-      .filter(p => p.remoteSource)
-      .map(p => p.name)
-      .sort()
-      .join(','),
-    'bob,kai,rook'
-  )
-})
-
-test('merge: legacy remote descriptor infers a matching remote primary when local inventory differs', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = { profiles: [{ name: 'default', last_session: { id: 'noah-chat' } }] }
-  const union = {
-    primaryConnectionId: 'noah',
-    agents: [
-      { connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device', profile: 'archie', handle: 'archie' },
-      { connectionId: 'noah', connectionKind: 'remote', connectionLabel: 'Noah', profile: 'default', handle: 'default' }
-    ]
-  }
-
-  // Legacy remote descriptors have mode:'remote' but no connectionId, so the
-  // host state is null. The matching primary row must annotate the rich row,
-  // while Archie remains a selectable other-source agent.
-  const out = merge(local, union, null)
-
-  assert.equal(out.profiles.length, 2)
-  assert.equal(out.profiles.find(p => p.name === 'default').connectionId, 'noah')
-  assert.equal(out.profiles.find(p => p.name === 'default').remoteSource, undefined)
-  assert.equal(out.profiles.find(p => p.name === 'archie').connectionId, 'local')
-  assert.equal(out.profiles.find(p => p.name === 'archie').remoteSource, true)
-})
-
-test('merge: previously seen remotes survive a connect-on-demand empty union', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const previous = [
-    { name: 'default', last_session: { id: 'this-chat' } },
-    {
-      name: 'bob',
-      remoteSource: true,
-      sourceScoped: true,
-      connectionId: 'spark',
-      connectionKind: 'ssh',
-      connectionLabel: 'Spark',
-      handle: 'bob'
-    }
-  ]
-  const local = { profiles: [{ name: 'default', last_session: { id: 'this-chat' } }] }
-  const union = {
-    primaryConnectionId: 'local',
-    agents: [
-      {
-        connectionId: 'local',
-        connectionKind: 'local',
-        connectionLabel: 'This device',
-        profile: 'default',
-        handle: 'default'
-      }
-    ],
-    sources: [{ connectionId: 'spark', kind: 'ssh', error: 'connect-on-demand' }]
-  }
-
-  const out = merge(local, union, 'local', previous)
-  const bob = out.profiles.find(p => p.name === 'bob' && p.connectionId === 'spark')
-
-  assert.ok(bob)
-  assert.equal(bob.remoteSource, true)
-  assert.equal(out.profiles.filter(p => p.name === 'default').length, 1)
-})
-
-test('merge: previous remotes from a removed connection do not resurrect', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const previous = [
-    { name: 'default', last_session: { id: 'this-chat' } },
-    {
-      name: 'bob',
-      remoteSource: true,
-      sourceScoped: true,
-      connectionId: 'gone',
-      connectionKind: 'ssh',
-      connectionLabel: 'Gone',
-      handle: 'bob'
-    }
-  ]
-  const local = { profiles: [{ name: 'default', last_session: { id: 'this-chat' } }] }
-  const union = {
-    primaryConnectionId: 'local',
-    agents: [
-      {
-        connectionId: 'local',
-        connectionKind: 'local',
-        connectionLabel: 'This device',
-        profile: 'default',
-        handle: 'default'
-      }
-    ],
-    sources: [{ connectionId: 'local', kind: 'local' }]
-  }
-
-  const out = merge(local, union, 'local', previous)
-  assert.equal(out.profiles.find(p => p.connectionId === 'gone'), undefined)
-})
-
-test('displayName: local default stays Hermes; remote default uses the device label', () => {
-  const { __displayName: name } = runtime()
-
-  assert.equal(
-    name(
-      {
-        name: 'default',
-        sourceScoped: true,
-        connectionKind: 'local',
-        connectionLabel: 'This device'
-      },
-      null
-    ),
-    'Hermes'
-  )
-  assert.equal(
-    name(
-      {
-        name: 'default',
-        sourceScoped: true,
-        remoteSource: true,
-        connectionKind: 'ssh',
-        connectionLabel: 'Spark'
-      },
-      null
-    ),
-    'Spark'
-  )
-})
-
-test('merge: live active id beats primaryConnectionId for active-source matching', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = { profiles: [{ name: 'default', last_session: { id: 's1' } }] }
-  const union = {
-    primaryConnectionId: 'local',
-    agents: [
-      { connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device', profile: 'default', handle: 'default-this-device' },
-      { connectionId: 'vps', connectionKind: 'remote', connectionLabel: 'VPS', profile: 'default', handle: 'default-vps' }
-    ]
-  }
-
-  // Live gateway = vps: its union row annotates the rich row; the primary
-  // (local) row appends as the genuinely-other source.
-  const out = merge(local, union, 'vps')
-  assert.equal(out.profiles.length, 2)
-
-  const rich = out.profiles.find(p => p.last_session)
-  assert.equal(rich.handle, 'default-vps')
-  assert.equal(out.profiles.filter(p => p.remoteSource).length, 1)
-  assert.equal(out.profiles.find(p => p.remoteSource).connectionId, 'local')
-})
-
-// Composition of the two dedup layers (#88828 install_id collapse + #88697
-// boot-descriptor connectionId): when the remote PRIMARY is registered under
-// two addresses, buildAgentRoster collapses the twin to ONE union row that
-// carries the PRIMARY's connectionId (collapse prefers the active/primary
-// connection). The boot descriptor now reports that same id as the live id,
-// so the merge must classify those collapsed rows as active-source
-// annotations — collapse first, then merge, with no re-append and no
-// double-collapse of a genuinely distinct source.
-test('merge: install_id-collapsed twin-address primary composes with the live id (no re-append)', () => {
-  const { __mergeMultiSourceRoster: merge } = runtime()
-  const local = {
-    profiles: [
-      { name: 'default', last_session: { id: 's-default' } },
-      { name: 'dev', last_session: { id: 's-dev' } }
-    ]
-  }
-  const union = {
-    primaryConnectionId: 'spark-lan',
-    agents: [
-      // Post-#88828 union: the tailscale twin of the primary collapsed into
-      // these rows — one per profile, keyed to the PRIMARY connection id.
-      { connectionId: 'spark-lan', connectionKind: 'remote', connectionLabel: 'Spark', profile: 'default', handle: 'default-spark' },
-      { connectionId: 'spark-lan', connectionKind: 'remote', connectionLabel: 'Spark', profile: 'dev', handle: 'dev' },
-      // A real second backend survives the collapse and stays its own row.
-      { connectionId: 'local', connectionKind: 'local', connectionLabel: 'This device', profile: 'default', handle: 'default-this-device' }
-    ]
-  }
-
-  // Live id from the fixed boot descriptor === the collapsed rows' id.
-  const out = merge(local, union, 'spark-lan')
-
-  // 2 annotated primary rows + 1 distinct local row = 3. Pre-fix (live id
-  // null) this was 5: both primary rows re-appended as phantom sources.
-  assert.equal(out.profiles.length, 3)
-  assert.equal(out.profiles.filter(p => p.remoteSource).length, 1)
-
-  const defaultRow = out.profiles.find(p => p.name === 'default' && !p.remoteSource)
-  assert.equal(defaultRow.last_session.id, 's-default')
-  assert.equal(defaultRow.handle, 'default-spark')
-  assert.equal(defaultRow.connectionId, 'spark-lan')
-
-  const localTwin = out.profiles.find(p => p.name === 'default' && p.remoteSource)
-  assert.equal(localTwin.connectionId, 'local')
-})
-
-test('botRosterKey: same name on two sources yields distinct React keys', () => {
-  const { __botRosterKey: botRosterKey } = runtime()
-
-  const legacyRow = botRosterKey({ name: 'default' })
-  const remoteRow = botRosterKey({ name: 'default', remoteSource: true, connectionId: 'homelab' })
-  const activeRow = botRosterKey({ name: 'default', connectionId: 'vps' })
-
-  assert.notEqual(legacyRow, remoteRow)
-  assert.notEqual(activeRow, remoteRow)
-  // Single-source desktops (no connection ids anywhere) keep a stable key.
-  assert.equal(legacyRow, 'legacy::default')
-})
-
-test('resolveRosterMentions: @dixie and @bob-mac-mini hit Connections bots, not this chat', () => {
-  const { __resolveRosterMentions: resolve } = runtime()
-  const roster = [
-    { name: 'default', connectionId: 'local', connectionKind: 'local', handle: 'default-this-device' },
-    {
-      name: 'dixie',
-      connectionId: 'mac-mini',
-      connectionKind: 'ssh',
-      connectionLabel: 'Mac Mini',
-      handle: 'dixie',
-      remoteSource: true,
-      sourceScoped: true
-    },
-    {
-      name: 'bob',
-      connectionId: 'mac-mini',
-      connectionKind: 'ssh',
-      connectionLabel: 'Mac Mini',
-      handle: 'bob-mac-mini',
-      remoteSource: true,
-      sourceScoped: true
-    },
-    {
-      name: 'bob',
-      connectionId: 'spark',
-      connectionKind: 'ssh',
-      connectionLabel: 'Spark',
-      handle: 'bob-spark',
-      remoteSource: true,
-      sourceScoped: true
-    }
-  ]
-
-  const hits = resolve('hey @dixie and @bob-spark, ping @bob-mac-mini', roster, {
-    name: 'default',
-    connectionId: 'local'
-  })
-
-  assert.equal(
-    hits
-      .map(bot => `${bot.connectionId}::${bot.name}`)
-      .sort()
-      .join(','),
-    'mac-mini::bob,mac-mini::dixie,spark::bob'
-  )
-})
-
-test('resolveRosterMentions: @hermes in this chat is not a handoff to yourself', () => {
-  const { __resolveRosterMentions: resolve } = runtime()
-  const roster = [
-    { name: 'default', connectionId: 'local', handle: 'hermes' },
-    {
-      name: 'default',
-      connectionId: 'mac-mini',
-      connectionLabel: 'Mac Mini',
-      handle: 'default-mac-mini',
-      remoteSource: true
-    }
-  ]
-
-  const hits = resolve('ask @hermes and @default-mac-mini', roster, {
-    name: 'default',
-    connectionId: 'local'
-  })
-
-  assert.equal(hits.length, 1)
-  assert.equal(hits[0].connectionId, 'mac-mini')
-})
-
-test('source contract: active roster queries use the SDK ambient owner route', () => {
-  assert.doesNotMatch(source, /activeBotRoute/)
-  assert.equal(
-    source.match(/requestForBot\(activeBot, 'profiles\.list', \{\}\)/g)?.length,
-    2,
-    'roster hydration and the session sweep must both use the upstream ambient-owner route'
-  )
-})
-
-test('preferReachableSameNameRows: drops a dead loopback twin when This device is live', () => {
-  const { __preferReachableSameNameRows: prefer } = runtime()
-  const live = {
-    name: 'profile-a',
-    handle: 'profile-a-this-device',
-    connectionId: 'local',
-    connectionKind: 'local',
-    connectionLabel: 'This device',
-    sourceReachable: true
-  }
-  const dead = {
-    name: 'profile-a',
-    handle: 'profile-a-127-0-0-1-19119',
-    connectionId: 'loopback-19119',
-    connectionKind: 'remote',
-    connectionLabel: '127.0.0.1:19119',
-    remoteSource: true,
-    sourceScoped: true,
-    sourceReachable: false
-  }
-  const other = {
-    name: 'profile-b',
-    handle: 'profile-b-127-0-0-1-19119',
-    connectionId: 'loopback-19119',
-    connectionKind: 'remote',
-    connectionLabel: '127.0.0.1:19119',
-    remoteSource: true,
-    sourceScoped: true,
-    sourceReachable: false
-  }
-
-  const out = prefer([dead, live, other])
-
-  assert.equal(out.length, 2)
-  assert.equal(out[0], live)
-  assert.equal(out[1], other)
-})
-
-test('preferReachableSameNameRows: keeps two live sources with the same profile name', () => {
-  const { __preferReachableSameNameRows: prefer } = runtime()
-  const local = {
-    name: 'research',
-    connectionId: 'local',
-    connectionLabel: 'This device',
-    sourceReachable: true
-  }
-  const homelab = {
-    name: 'research',
-    connectionId: 'homelab',
-    connectionLabel: 'Homelab',
-    remoteSource: true,
-    sourceReachable: true
-  }
-
-  const out = prefer([local, homelab])
-
-  assert.equal(out.length, 2)
-  assert.equal(out[0], local)
-  assert.equal(out[1], homelab)
-})
-
-test('preferReachableSameNameRows: keeps an unreachable row when no live twin exists', () => {
-  const { __preferReachableSameNameRows: prefer } = runtime()
-  const dead = {
-    name: 'research',
-    connectionId: 'loopback-19119',
-    sourceReachable: false
-  }
-
-  const out = prefer([dead])
-
-  assert.equal(out.length, 1)
-  assert.equal(out[0], dead)
-})
-
-test('preferReachableSameNameRows: connect-on-demand counts as reachable', () => {
-  const { __preferReachableSameNameRows: prefer } = runtime()
-  const onDemand = {
-    name: 'research',
-    connectionId: 'mac-mini',
-    sourceError: 'connect-on-demand',
-    sourceReachable: false
-  }
-  const dead = {
-    name: 'research',
-    connectionId: 'loopback-19119',
-    sourceReachable: false
-  }
-
-  const out = prefer([onDemand, dead])
-
-  assert.equal(out.length, 1)
-  assert.equal(out[0], onDemand)
-})
-
-test('preferReachableSameNameRows: sourceMissing drops when a live same-name row exists', () => {
-  const { __preferReachableSameNameRows: prefer } = runtime()
-  const live = { name: 'research', connectionId: 'local', sourceReachable: true }
-  const missing = {
-    name: 'research',
-    connectionId: 'gone',
-    sourceMissing: true,
-    sourceReachable: false
-  }
-
-  const out = prefer([missing, live])
-
-  assert.equal(out.length, 1)
-  assert.equal(out[0], live)
-})
-
-test('preferReachableSameNameRows: ghosts stay so a selected offline owner is not replaced', () => {
-  const { __preferReachableSameNameRows: prefer } = runtime()
-  const live = { name: 'research', connectionId: 'local', sourceReachable: true }
-  const ghost = {
-    name: 'research',
-    connectionId: 'loopback-19119',
-    ghost: true,
-    sourceReachable: false
-  }
-
-  const out = prefer([ghost, live])
-
-  assert.equal(out.length, 2)
-  assert.equal(out[0], ghost)
-  assert.equal(out[1], live)
-})
-
-test('preferReachableSameNameRows: does not mutate the input list', () => {
-  const { __preferReachableSameNameRows: prefer } = runtime()
-  const rows = [
-    { name: 'research', connectionId: 'loopback-19119', sourceReachable: false },
-    { name: 'research', connectionId: 'local', sourceReachable: true }
-  ]
-
-  prefer(rows)
-
-  assert.equal(rows.length, 2)
-  assert.equal(rows[0].connectionId, 'loopback-19119')
-})
-
-test('source contract: presentation collapses unreachable twins; shared roster does not', () => {
-  assert.match(source, /preferReachableSameNameRows\(filteredRoster\)/)
-  assert.match(source, /\$lastRoster\.set\(roster\.filter\(row => !row\?\.ghost\)\)/)
-  assert.doesNotMatch(
-    source.slice(source.indexOf('function groupChatMemberBots'), source.indexOf('function durableGroupChatMembers')),
-    /preferReachableSameNameRows/
-  )
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/new-compact-guard.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/new-compact-guard.test.mjs
deleted file mode 100644
index d6a18bee1cde..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/new-compact-guard.test.mjs
+++ /dev/null
@@ -1,28 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// The /new -> /compact guard protects a bot's canonical forever-chat from being
-// forked by /new. Canonical identity is the NAME — the profile's session titled
-// "Bot Chat" — reported by the gateway as canonical_session on every roster row.
-// The guard compares the on-screen session id against that registry row (durable
-// id OR compression-lineage tip). No stored meta.chat pointer is consulted:
-// pointers dangle; the registry row cannot.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// Locate the /new reroute guard block.
-const guardStart = source.indexOf('const slashNew =')
-assert.notEqual(guardStart, -1, '/new guard block is missing')
-const guardBlock = source.slice(guardStart, guardStart + 900)
-
-test('the /new guard reads the canonical registry row, never a stored pointer', () => {
-  assert.match(guardBlock, /canonical_session/)
-  assert.doesNotMatch(guardBlock, /meta\?\.chat/)
-  assert.doesNotMatch(guardBlock, /chat_pin/)
-})
-
-test('the guard matches both the durable registry id and the lineage tip', () => {
-  assert.match(guardBlock, /canonical\?\.id/)
-  assert.match(guardBlock, /canonical\?\.resolved_id/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/orphaned-connection-members.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/orphaned-connection-members.test.mjs
deleted file mode 100644
index e5ccbcd2879f..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/orphaned-connection-members.test.mjs
+++ /dev/null
@@ -1,182 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-// #93492 root fix: deleting a connection sweeps/annotates the persisted
-// group-chat member rows that referenced it (registry 'removed' push), and a
-// hydrate-time pass annotates rows orphaned before the sweep existed. Rows
-// are marked (sourceMissing → the existing 'Gateway removed' degraded state),
-// never silently deleted.
-
-function runtime() {
-  const atom = initial => {
-    let value = initial
-    return { get: () => value, set: next => { value = next }, listen: () => () => undefined }
-  }
-  const jsx = (type, props = {}) => ({ type, props })
-  const storageWrites = []
-  const context = {
-    atom,
-    jsx,
-    jsxs: jsx,
-    useQuery: () => ({}),
-    useValue: value => (value?.get ? value.get() : value),
-    useState: value => [value, () => undefined],
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      state: {
-        connectionId: { get: () => 'local', listen: () => undefined },
-        profile: { get: () => 'ops', listen: () => undefined }
-      },
-      request: () => undefined
-    },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const code = source
-    .replace(/^import \* as sdk from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__orphan = { $groupChats, sweepGroupChatMembersForRemovedConnection, annotateOrphanedGroupChatMembers, markOrphanedGroupMemberDescriptor, groupMemberReferencesConnection, botSourceStatus, durableGroupChatMembers, botWorkspaceOwnerKey, setBotsWorkspaceOwner, useModelOptions, pluginCtxRef: () => pluginCtx, setPluginCtx: value => { pluginCtx = value } };'
-    )
-  vm.runInNewContext(code, context)
-  context.__storageWrites = storageWrites
-  return context
-}
-
-function member(overrides = {}) {
-  return {
-    name: 'dixie',
-    handle: 'dixie',
-    connectionId: 'conn-gone',
-    remoteSource: true,
-    sourceScoped: true,
-    route: { connectionId: 'conn-gone', mode: 'remote', profile: 'dixie', targetProfile: 'dixie' },
-    ...overrides
-  }
-}
-
-test('removed-connection sweep annotates matching members and persists; other rows untouched', () => {
-  const { __orphan: o } = runtime()
-  const writes = []
-  o.setPluginCtx({ storage: { set: (key, value) => { writes.push([key, value]); return Promise.resolve() } } })
-
-  o.$groupChats.set({
-    Crew: {
-      log: [{ id: '1', at: 1 }],
-      watermarks: {},
-      members: [member(), member({ name: 'bob', connectionId: 'conn-live', route: { connectionId: 'conn-live', mode: 'remote', profile: 'bob', targetProfile: 'bob' } })]
-    }
-  })
-
-  assert.equal(o.sweepGroupChatMembersForRemovedConnection('conn-gone'), true)
-
-  const room = o.$groupChats.get().Crew
-  const swept = room.members.find(m => m.name === 'dixie')
-  const kept = room.members.find(m => m.name === 'bob')
-
-  // Annotated, not deleted: identity survives, marked degraded.
-  assert.equal(room.members.length, 2)
-  assert.equal(swept.sourceMissing, true)
-  assert.equal(swept.sourceReachable, false)
-  assert.equal(kept.sourceMissing, undefined)
-  // The degraded mark renders as the existing 'Gateway removed' state.
-  assert.equal(o.botSourceStatus(swept).label, 'Gateway removed')
-  // Persisted so the fix survives restarts (the poisoned row lived in storage).
-  assert.ok(writes.some(([key]) => key === 'group-chats'))
-})
-
-test('removed-connection sweep is idempotent and ignores blank ids', () => {
-  const { __orphan: o } = runtime()
-  o.setPluginCtx({ storage: { set: () => Promise.resolve() } })
-  o.$groupChats.set({ Crew: { log: [], watermarks: {}, members: [member()] } })
-
-  assert.equal(o.sweepGroupChatMembersForRemovedConnection(''), false)
-  assert.equal(o.sweepGroupChatMembersForRemovedConnection('conn-gone'), true)
-  // Already annotated: nothing left to change.
-  assert.equal(o.sweepGroupChatMembersForRemovedConnection('conn-gone'), false)
-})
-
-test('hydrate annotate: lost-connectionId rows are marked even without a registry', () => {
-  const { __orphan: o } = runtime()
-  const rooms = {
-    Crew: {
-      log: [],
-      watermarks: {},
-      // The exact persisted shape from #93492: remoteSource kept, connectionId gone.
-      members: [{ name: 'halakukhan', handle: 'halakukhan', connectionId: null, remoteSource: true }]
-    }
-  }
-
-  const { rooms: next, changed } = o.annotateOrphanedGroupChatMembers(rooms, null)
-
-  assert.equal(changed, true)
-  assert.equal(next.Crew.members[0].sourceMissing, true)
-  assert.equal(o.botSourceStatus(next.Crew.members[0]).label, 'Gateway removed')
-})
-
-test('hydrate annotate: with a live registry, members on dead connections are marked, live and local kept', () => {
-  const { __orphan: o } = runtime()
-  const rooms = {
-    Crew: {
-      log: [],
-      watermarks: {},
-      members: [
-        member(),
-        member({ name: 'bob', connectionId: 'conn-live', route: { connectionId: 'conn-live', mode: 'remote', profile: 'bob', targetProfile: 'bob' } }),
-        { name: 'local-pal' }
-      ]
-    }
-  }
-
-  const { rooms: next, changed } = o.annotateOrphanedGroupChatMembers(rooms, new Set(['conn-live']))
-
-  assert.equal(changed, true)
-  assert.equal(next.Crew.members.find(m => m.name === 'dixie').sourceMissing, true)
-  assert.equal(next.Crew.members.find(m => m.name === 'bob').sourceMissing, undefined)
-  assert.equal(next.Crew.members.find(m => m.name === 'local-pal').sourceMissing, undefined)
-})
-
-test('hydrate annotate: no registry means only the unresolvable-route shape is touched', () => {
-  const { __orphan: o } = runtime()
-  const rooms = { Crew: { log: [], watermarks: {}, members: [member()] } }
-
-  // conn-gone still has an id; without a registry we cannot prove it dead.
-  const { changed } = o.annotateOrphanedGroupChatMembers(rooms, null)
-
-  assert.equal(changed, false)
-})
-
-test('render-reachable route callers degrade on an orphaned row instead of throwing', () => {
-  const { __orphan: o } = runtime()
-  const orphaned = { name: 'halakukhan', handle: 'halakukhan', connectionId: null, remoteSource: true }
-
-  // botWorkspaceOwnerKey (sidebar sync / Bots home / context menus)
-  assert.doesNotThrow(() => o.botWorkspaceOwnerKey(orphaned))
-  assert.equal(o.botWorkspaceOwnerKey(orphaned), 'bot:halakukhan')
-  // setBotsWorkspaceOwner (sidebar visibility listener)
-  assert.doesNotThrow(() => o.setBotsWorkspaceOwner('bot:halakukhan', orphaned))
-  // durableGroupChatMembers (every group send / roster refresh)
-  assert.doesNotThrow(() => o.durableGroupChatMembers([orphaned]))
-  const durable = o.durableGroupChatMembers([{ ...orphaned, sourceMissing: true, sourceReachable: false }])[0]
-  // The degraded mark survives the durable rebuild.
-  assert.equal(durable.sourceMissing, true)
-  // useModelOptions (hook body — runs during pane render)
-  assert.doesNotThrow(() => o.useModelOptions(orphaned))
-})
-
-test('source contract: the sweep is wired to the registry removed push and unbound on dispose', () => {
-  assert.match(source, /connections\?\.onChanged\?\.\(/)
-  assert.match(source, /payload\?\.reason === 'removed'/)
-  assert.match(source, /sweepGroupChatMembersForRemovedConnection\(payload\.connectionId\)/)
-  assert.match(source, /unbindConnectionsChanged\(\)/)
-})
-
-test('source contract: hydrate runs the orphan annotate over persisted rooms', () => {
-  assert.match(source, /annotateOrphanedGroupChatMembers\(\$groupChats\.get\(\), liveIds\)/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/pane-dock-layout.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/pane-dock-layout.test.mjs
deleted file mode 100644
index 8d4000349ddc..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/pane-dock-layout.test.mjs
+++ /dev/null
@@ -1,49 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// Bot Mode layout contract:
-//  - the Bots pane center-stacks into the sessions zone (SESSIONS | BOTS tab
-//    strip), never splits below it, and carries the ENFORCED dock invariant
-//    so every boot re-homes a stacked install — no heal token, no
-//    user-placed exemption (the retired one-shot heal left users who had
-//    dragged panes stuck stacked forever);
-//  - the Cronjobs (routines) pane only exists while a BOT CHAT owns the main
-//    workspace and the Bots pane is on screen — registered/unregistered
-//    through the contribution disposer, driven by the feature-detected
-//    host.paneVisibility SDK export, with the always-registered fallback kept
-//    for older desktops. Cronjobs are bot-scoped, so the tile must not sit
-//    beside the ownerless Bots home or a group chat.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('the Bots pane center-docks into the sessions zone as an enforced invariant', () => {
-  assert.match(source, /dock: \{ pane: 'sessions', pos: 'center', enforce: true \}/)
-  // The old workaround split must not come back.
-  assert.doesNotMatch(source, /pane: 'sessions', pos: 'bottom'/)
-  // Neither may the retired one-shot heal token.
-  assert.doesNotMatch(source, /heal: 'sessions-tab-v1'/)
-})
-
-test('routines registration is a reusable disposer-returning function', () => {
-  assert.match(source, /const registerRoutinesPane = \(\) =>\s*\n\s*ctx\.register\(\{\s*\n\s*id: 'routines'/)
-  assert.match(source, /dock: \{ pane: 'workspace', pos: 'right', enforce: true \}/)
-})
-
-test('routines pane rides Bots visibility via feature-detected host.paneVisibility', () => {
-  assert.match(source, /typeof host\.paneVisibility === 'function'/)
-  assert.match(source, /host\.paneVisibility\(`\$\{ID\}:pane`\)/)
-  // Transitions register/unregister through the tracked disposer.
-  assert.match(source, /unregisterRoutines \?\?= registerRoutinesPane\(\)/)
-  assert.match(source, /unregisterRoutines\(\)\s*\n\s*unregisterRoutines = null/)
-  // Ownership, not mere visibility: an actual bot chat must own the center.
-  assert.match(source, /if \(botChatOwnsWorkspace\(\)\) \{/)
-  // None of the lifecycle listeners may survive plugin disable.
-  assert.match(source, /ctx\.onDispose\(\(\) => \{\s*\n\s*stopSidebarSync\(\)/)
-  assert.match(source, /stopGroupSync\(\)/)
-  assert.match(source, /stopFocusSync\?\.\(\)/)
-})
-
-test('older desktops without the SDK export keep the always-registered pane', () => {
-  assert.match(source, /\} else \{\s*\n\s*registerRoutinesPane\(\)\s*\n\s*\}/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/pet-fetch.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/pet-fetch.test.mjs
deleted file mode 100644
index 1d818ba93643..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/pet-fetch.test.mjs
+++ /dev/null
@@ -1,76 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load(fetchImpl) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const fetches = []
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: {
-      getElementById: () => null,
-      createElement: () => ({
-        width: 0,
-        height: 0,
-        getContext: () => ({ drawImage() {} }),
-        toDataURL: () => 'data:image/png;base64,ok'
-      }),
-      head: { appendChild: () => undefined }
-    },
-    host: { state: { profile: { listen: () => undefined } } },
-    fetch: async (url, opts) => {
-      fetches.push({ url, opts })
-      return fetchImpl(url, opts)
-    },
-    AbortSignal,
-    createImageBitmap: async () => ({ close() {} })
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__api = { petFrameIcon };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return { context, fetches }
-}
-
-test('unit: a failed pet fetch is not stuck in the cache', async () => {
-  let n = 0
-  const { context, fetches } = load(async () => {
-    n += 1
-    throw new Error('network')
-  })
-  const a = await context.__api.petFrameIcon('https://pets.example/a.webp')
-  const b = await context.__api.petFrameIcon('https://pets.example/a.webp')
-  assert.equal(a, null)
-  assert.equal(b, null)
-  assert.equal(fetches.length, 2)
-  assert.equal(n, 2)
-  assert.ok(fetches[0].opts.signal, 'fetch is aborted if it hangs')
-})
-
-test('regression: a successful icon is still cached', async () => {
-  let n = 0
-  const { context } = load(async () => {
-    n += 1
-    return { blob: async () => new Blob() }
-  })
-  const a = await context.__api.petFrameIcon('https://pets.example/ok.webp')
-  const b = await context.__api.petFrameIcon('https://pets.example/ok.webp')
-  assert.equal(a, 'data:image/png;base64,ok')
-  assert.equal(n, 1)
-  assert.equal(a, b)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/profile-prewarm.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/profile-prewarm.test.mjs
deleted file mode 100644
index 61563a644970..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/profile-prewarm.test.mjs
+++ /dev/null
@@ -1,333 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function sourceBetween(start, end) {
-  const from = source.indexOf(start)
-  const to = source.indexOf(end, from)
-
-  assert.notEqual(from, -1, `missing ${start}`)
-  assert.notEqual(to, -1, `missing ${end}`)
-
-  return source.slice(from, to)
-}
-
-// BotRow's activity resolver — extract the REAL helper so the harness can't
-// drift from production behavior.
-function activitySessionSource() {
-  return sourceBetween('function botActivitySession(', '/** Bots that are working')
-}
-
-function renderBotRow(input = 'alpha') {
-  const bot = typeof input === 'string' ? { name: input } : input
-  const name = bot.name
-  const botRowSource = sourceBetween('function BotRow(', '// ── model picker')
-  // REAL owner-route resolver — the derivation from bare connectionId rows is
-  // exactly what these tests exercise, so a hand stub would drift.
-  const routeSource = sourceBetween('function botConnectionRoute(', 'function rewriteCliProfileOperands(')
-  const ensured = []
-  const opened = []
-  const saved = []
-  const warmed = []
-  let liveConnectionId = 'local'
-  const atom = value => ({
-    get: () => value,
-    set: next => {
-      value = next
-    }
-  })
-  const node = (type, props = {}) => ({ type, props })
-  const context = {
-    BotFace: 'BotFace',
-    ContextMenu: 'ContextMenu',
-    ContextMenuContent: 'ContextMenuContent',
-    ContextMenuItem: 'ContextMenuItem',
-    ContextMenuSeparator: 'ContextMenuSeparator',
-    ContextMenuTrigger: 'ContextMenuTrigger',
-    Codicon: 'Codicon',
-    Tip: 'Tip',
-    ROSTER_KEY: ['hermes-bots', 'roster'],
-    $botMeta: atom({}),
-    $botUnread: atom({}),
-    $botAttention: atom({}),
-    BOT_ATTENTION_HINTS: {},
-    $botChatFocused: atom(false),
-    $botsHomeFronted: atom(false),
-    $focusedBotOwner: atom({ connectionId: 'local', profile: 'default' }),
-    $focusedBotProfile: atom('default'),
-    $groupChatWorkspace: atom(null),
-    $lastRoster: atom([]),
-    $selectedBot: atom('default'),
-    $selectedRosterKey: atom(''),
-    botAppearance: () => ({ shape: 'round', color: '#000', image: null }),
-    botMetaKey: value => value.sourceScoped
-      ? `${value.route?.connectionId || value.connectionId}::${value.name}`
-      : value.name,
-    botGroups: () => [],
-    botHandle: value => value,
-    botRosterKey: value => `${value.connectionId || 'legacy'}::${value.name}`,
-    botRowOwnsWorkspace: () => false,
-    botSourceStatus: () => ({ available: true, label: 'Ready' }),
-    botOpenGeneration: 0,
-    botRosterMeta: (_bot, metaByName) => {
-      const key = _bot.sourceScoped
-        ? `${_bot.route?.connectionId || _bot.connectionId}::${_bot.name}`
-        : _bot.name
-      return metaByName?.[key] ?? null
-    },
-    cn: (...values) => values.filter(Boolean).join(' '),
-    createCanonicalChat: async () => null,
-    displayName: bot => bot.name,
-    duplicateBot: async () => `${name}-copy`,
-    ensureBotMetadata: async () => ({ pinned: true }),
-    haptic: () => undefined,
-    // #49 session-aware-row helpers referenced inside BotRow.
-    previewKind: () => ({ fromBot: false, sender: null }),
-    generatedSessionTitle: () => null,
-    focusedRosterOwner: owner => ({ connectionId: owner.connectionId, name: owner.profile }),
-    isActiveRosterBot: () => false,
-    isBackfilledFacePng: () => false,
-    isBotHidden: () => false,
-    isBotPinned: () => false,
-    botSelectionKey: value => value.sourceScoped ? `${value.connectionId}::${value.name}` : value.name,
-    isDefaultBot: value => value.name === 'default',
-    newBotChat: () => undefined,
-    openBotCanonicalChat: async (...args) => {
-      opened.push(args)
-      return 'stored-chat'
-    },
-    openRosterBot: async value => {
-      opened.push([value])
-      return true
-    },
-    workerActiveAt: () => false,
-    ACTIVE_WINDOW_S: 90,
-    A2A_PREFIX_RE: /^$/,
-    useEffect: () => undefined,
-    useState: initial => [typeof initial === 'function' ? initial() : initial, () => undefined],
-    host: {
-      state: { gateway: atom('open'), profile: atom('default') },
-      ensureAgent: async (connectionId, profile) => {
-        ensured.push([connectionId, profile])
-        liveConnectionId = connectionId
-      },
-      activeConnectionId: () => liveConnectionId,
-      requestProfile: async (_route, method) =>
-        method === 'profiles.list'
-          ? { profiles: [{ name, ui_meta: { 'hermes-bots': { chat: 'owner-chat' } } }] }
-          : { sessions: [] },
-      warmAgent: (connectionId, profile) => warmed.push([connectionId, profile]),
-      warmProfile: profile => warmed.push(profile),
-      request: async method =>
-        method === 'profiles.list'
-          ? { profiles: [{ name, ui_meta: { 'hermes-bots': { chat: 'owner-chat' } } }] }
-          : { sessions: [] },
-      notify: () => undefined,
-      notifyError: () => undefined
-    },
-    jsx: node,
-    jsxs: node,
-    onEdit: () => undefined,
-    persistBotMetaSnapshot: () => Promise.resolve(),
-    queryClient: { invalidateQueries: () => undefined },
-    relativeTime: () => 'now',
-    requestForBot: async (_bot, method) => method === 'profiles.list'
-      ? {
-          profiles: [{
-            name: _bot.route?.targetProfile || _bot.name,
-            ui_meta: { 'hermes-bots': { pinned: true } }
-          }]
-        }
-      : {},
-    saveBotMeta: (_bot, patch) => saved.push([_bot, patch]),
-    showsHandle: () => false,
-    stripPreviewMarkdown: text => String(text || ''),
-    useValue: store => store.get()
-  }
-
-  vm.runInNewContext(`${activitySessionSource()}\n${routeSource}\n${botRowSource}\nglobalThis.BotRow = BotRow`, context)
-
-  const tree = context.BotRow({ bot, onEdit: context.onEdit })
-  const row = tree.type === 'button' ? tree : tree.props.children[0].props.children
-
-  return { ensured, opened, row, saved, tree, warmed }
-}
-
-test('regression: rendering BotsPane does not prewarm the entire roster', () => {
-  const botsPaneSource = sourceBetween('function BotsPane(', '// ── plugin')
-
-  assert.doesNotMatch(botsPaneSource, /host\.warmProfile/)
-})
-
-test('regression: source transitions keep BotRow hook order stable', () => {
-  const botRowSource = sourceBetween('function BotRow(', '// ── model picker')
-
-  assert.match(botRowSource, /const unreadByName = useValue\(\$botUnread\)/)
-  assert.doesNotMatch(botRowSource, /remoteSource && Boolean\(useValue/)
-})
-
-test('behavior: pointer entry prewarms only the hovered bot', () => {
-  const { row, warmed } = renderBotRow('alpha')
-
-  assert.deepEqual(warmed, [])
-  assert.equal(typeof row.props.onPointerEnter, 'function')
-  row.props.onPointerEnter()
-  assert.deepEqual(warmed, ['alpha'])
-})
-
-test('behavior: context-menu pin mutation hydrates a non-identity alias before toggling', async () => {
-  const bot = {
-    connectionId: 'remote-a',
-    name: 'worker',
-    remoteSource: true,
-    sourceScoped: true,
-    route: {
-      connectionId: 'remote-a',
-      mode: 'remote',
-      profile: 'worker',
-      targetProfile: 'backend-worker'
-    }
-  }
-  const { saved, tree } = renderBotRow(bot)
-  const menuItems = tree.props.children[1].props.children
-
-  menuItems[0].props.onSelect()
-  await new Promise(resolve => setTimeout(resolve, 0))
-
-  assert.equal(saved.length, 1)
-  assert.equal(saved[0][0], bot)
-  assert.deepEqual(JSON.parse(JSON.stringify(saved[0][1])), { pinned: false })
-})
-
-test('behavior: a remote Connections row opens through its captured route without activation authority', async () => {
-  const { ensured, opened, row, warmed } = renderBotRow({
-    connectionId: 'work',
-    connectionLabel: 'Work',
-    name: 'research',
-    remoteSource: true,
-    sourceScoped: true
-  })
-
-  row.props.onPointerEnter()
-  assert.deepEqual(warmed, [['work', 'research']])
-
-  await row.props.onClick()
-  assert.deepEqual(ensured, [])
-  assert.equal(opened.length, 1)
-  assert.equal(opened[0][0].connectionId, 'work')
-})
-
-test('behavior: remote default never opens the same-name local chat', async () => {
-  const bot = {
-    connectionId: 'mac-mini',
-    connectionLabel: 'Mac Mini',
-    name: 'default',
-    remoteSource: true,
-    sourceScoped: true
-  }
-  const botRowSource = sourceBetween('function BotRow(', '// ── model picker')
-  const ensured = []
-  const opened = []
-  const errors = []
-  const atom = value => ({
-    get: () => value,
-    set: next => {
-      value = next
-    }
-  })
-  const node = (type, props = {}) => ({ type, props })
-  const context = {
-    BotFace: 'BotFace',
-    ContextMenu: 'ContextMenu',
-    ContextMenuContent: 'ContextMenuContent',
-    ContextMenuItem: 'ContextMenuItem',
-    ContextMenuSeparator: 'ContextMenuSeparator',
-    ContextMenuTrigger: 'ContextMenuTrigger',
-    Codicon: 'Codicon',
-    Tip: 'Tip',
-    ROSTER_KEY: ['hermes-bots', 'roster'],
-    $botMeta: atom({ default: { chat: 'this-device-chat' } }),
-    $botUnread: atom({}),
-    $botAttention: atom({}),
-    BOT_ATTENTION_HINTS: {},
-    $botChatFocused: atom(false),
-    $botsHomeFronted: atom(false),
-    $focusedBotOwner: atom({ connectionId: 'mac-mini', profile: 'default' }),
-    $focusedBotProfile: atom('default'),
-    $groupChatWorkspace: atom(null),
-    $lastRoster: atom([]),
-    $selectedBot: atom('default'),
-    $selectedRosterKey: atom(''),
-    botAppearance: () => ({ shape: 'round', color: '#000', image: null }),
-    botGroups: () => [],
-    botHandle: value => value,
-    botRosterKey: value => `${value.connectionId || 'legacy'}::${value.name}`,
-    botRowOwnsWorkspace: () => false,
-    botSourceStatus: () => ({ available: true, label: 'Ready' }),
-    botOpenGeneration: 0,
-    botRosterMeta: () => null,
-    cn: (...values) => values.filter(Boolean).join(' '),
-    createCanonicalChat: async () => null,
-    displayName: bot => bot.connectionLabel || bot.name,
-    duplicateBot: async () => 'copy',
-    ensureBotMetadata: async () => ({ pinned: true }),
-    haptic: () => undefined,
-    previewKind: () => ({ fromBot: false, sender: null }),
-    generatedSessionTitle: () => null,
-    focusedRosterOwner: owner => ({ connectionId: owner.connectionId, name: owner.profile }),
-    isActiveRosterBot: () => false,
-    isBackfilledFacePng: () => false,
-    isBotHidden: () => false,
-    isBotPinned: () => false,
-    botSelectionKey: value => value.sourceScoped ? `${value.connectionId}::${value.name}` : value.name,
-    isDefaultBot: value => value.name === 'default',
-    newBotChat: () => undefined,
-    openBotCanonicalChat: async (...args) => {
-      opened.push(args)
-      return 'this-device-chat'
-    },
-    openRosterBot: async value => {
-      opened.push([value])
-      return true
-    },
-    workerActiveAt: () => false,
-    ACTIVE_WINDOW_S: 90,
-    A2A_PREFIX_RE: /^$/,
-    useEffect: () => undefined,
-    useState: initial => [typeof initial === 'function' ? initial() : initial, () => undefined],
-    host: {
-      state: { gateway: atom('open'), profile: atom('default') },
-      ensureAgent: async (connectionId, profile) => ensured.push([connectionId, profile]),
-      requestProfile: async () => ({}),
-      activeConnectionId: () => 'local',
-      warmAgent: () => undefined,
-      warmProfile: () => undefined,
-      request: async () => ({ profiles: [{ name: 'default', ui_meta: { 'hermes-bots': { chat: 'this-device-chat' } } }] }),
-      notify: () => undefined,
-      notifyError: (_err, msg) => errors.push(msg)
-    },
-    jsx: node,
-    jsxs: node,
-    onEdit: () => undefined,
-    queryClient: { invalidateQueries: () => undefined },
-    relativeTime: () => 'now',
-    saveBotMeta: () => undefined,
-    showsHandle: () => false,
-    stripPreviewMarkdown: text => String(text || ''),
-    useValue: store => store.get()
-  }
-
-  const routeSource = sourceBetween('function botConnectionRoute(', 'function rewriteCliProfileOperands(')
-  vm.runInNewContext(`${activitySessionSource()}\n${routeSource}\n${botRowSource}\nglobalThis.BotRow = BotRow`, context)
-  const tree = context.BotRow({ bot, onEdit: context.onEdit })
-  const row = tree.type === 'button' ? tree : tree.props.children[0].props.children
-
-  await row.props.onClick()
-  assert.deepEqual(ensured, [])
-  assert.equal(opened.length, 1)
-  assert.equal(opened[0][0].connectionId, 'mac-mini')
-  assert.equal(errors.length, 0)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/reclaim-proactive-refresh.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/reclaim-proactive-refresh.test.mjs
deleted file mode 100644
index 2629724f0b20..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/reclaim-proactive-refresh.test.mjs
+++ /dev/null
@@ -1,51 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// Proactive reclaim refresh (polish on top of #92928/#92901): when the
-// gateway reaps the runtime behind the OPEN bot chat (session.reclaimed —
-// idle TTL, LRU, or the mass WS-orphan reap that killed every background
-// bot's handle at once in the Aug 23 incident), the plugin re-resumes the
-// canonical chat immediately instead of letting the user's next send eat a
-// stale-id error + recovery round-trip.
-//
-// Source-shape contracts:
-// - the listener subscribes via host.onEvent('session.reclaimed'), feature-
-//   detected, and is disposed with the other listeners;
-// - the match is on the STORED id against BOTH claim identities;
-// - a stale generation or missing claim/bot is a no-op;
-// - a failed re-resume is swallowed (next-send recovery ladder remains).
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function reclaimBlock() {
-  const start = pluginSource.indexOf("host.onEvent('session.reclaimed'")
-  assert.ok(start > 0, 'reclaim listener exists')
-  return pluginSource.slice(start - 400, start + 1800)
-}
-
-test('listener is feature-detected and disposed', () => {
-  const block = reclaimBlock()
-  assert.match(block, /typeof host\.onEvent === 'function'/)
-  assert.match(pluginSource, /stopReclaimSync\?\.\(\)/)
-})
-
-test('match is stored-id against both claim identities', () => {
-  const block = reclaimBlock()
-  assert.match(block, /payload\.stored_session_id/)
-  assert.match(block, /\[claim\.openedSessionId, claim\.openedRegistryId\]\.filter\(Boolean\)/)
-  assert.match(block, /owned\.includes\(stored\)/)
-})
-
-test('re-resume guards the open generation and refreshes both claim ids', () => {
-  const block = reclaimBlock()
-  assert.match(block, /generation !== botOpenGeneration/)
-  assert.match(block, /openedRegistryId: opened\.registryId/)
-  assert.match(block, /openedSessionId: opened\.openedId/)
-})
-
-test('failed re-resume is swallowed — next-send recovery stays the backstop', () => {
-  const block = reclaimBlock()
-  assert.match(block, /\.catch\(\(\) => \{/)
-  assert.match(block, /next send recovers via the ladder/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/relay-push-drain.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/relay-push-drain.test.mjs
deleted file mode 100644
index fb429b51eb92..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/relay-push-drain.test.mjs
+++ /dev/null
@@ -1,105 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Push-notified relay drain (#93091, motivated by #92760 slow replies): the
-// gateway broadcasts `bot_relay.outbox.pending` when an envelope lands in the
-// outbox; the plugin drains immediately instead of waiting out the 4s poll.
-// Contracts:
-// - a burst of signals inside RELAY_PUSH_DEBOUNCE_MS collapses to ONE drain;
-// - after the debounce fires, a later signal schedules a fresh drain;
-// - the subscription is feature-detected (host.onEvent) and disposed, and the
-//   4s interval poll remains untouched as the backstop.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadScheduler() {
-  const start = pluginSource.indexOf('function scheduleRelayPushDrain(')
-  const end = pluginSource.indexOf('function startBotRelay(', start)
-  assert.ok(start > 0, 'plugin defines scheduleRelayPushDrain')
-  assert.ok(end > start, 'scheduler has a stable source boundary')
-
-  const context = {
-    setTimeout,
-    clearTimeout,
-    relayDisposed: false,
-    relayPushDebounceTimer: null,
-    RELAY_PUSH_DEBOUNCE_MS: 50, // shrunk from 250ms to keep the test fast
-    drainCalls: 0
-  }
-  vm.createContext(context)
-  vm.runInContext(
-    `async function drainRelayOutboxes() { drainCalls += 1 }\n${pluginSource.slice(start, end)}\nglobalThis.scheduleRelayPushDrain = scheduleRelayPushDrain`,
-    context
-  )
-  return context
-}
-
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
-
-test('a burst of pending signals collapses to one drain', async () => {
-  const ctx = loadScheduler()
-
-  for (let i = 0; i < 6; i += 1) {
-    ctx.scheduleRelayPushDrain()
-  }
-
-  assert.equal(ctx.drainCalls, 0, 'drain waits for the debounce window')
-  await sleep(120)
-  assert.equal(ctx.drainCalls, 1, 'six signals inside the window → one drain')
-})
-
-test('a signal after the window fires a fresh drain', async () => {
-  const ctx = loadScheduler()
-
-  ctx.scheduleRelayPushDrain()
-  await sleep(120)
-  assert.equal(ctx.drainCalls, 1)
-
-  ctx.scheduleRelayPushDrain()
-  ctx.scheduleRelayPushDrain()
-  await sleep(120)
-  assert.equal(ctx.drainCalls, 2)
-})
-
-test('a disposed relay never schedules a drain', async () => {
-  const ctx = loadScheduler()
-  ctx.relayDisposed = true
-
-  ctx.scheduleRelayPushDrain()
-  await sleep(120)
-  assert.equal(ctx.drainCalls, 0)
-})
-
-test('subscription is feature-detected, disposed, and the poll backstop stays', () => {
-  const start = pluginSource.indexOf("host.onEvent('bot_relay.outbox.pending'")
-  assert.ok(start > 0, 'plugin subscribes to bot_relay.outbox.pending')
-  const block = pluginSource.slice(start - 400, start + 400)
-  assert.match(block, /typeof host\.onEvent === 'function'/)
-  assert.match(pluginSource, /relayPushUnsub\(\)/)
-  // The interval poll survives as a BACKSTOP — push is the delivery path,
-  // the poll covers older backends that never emit the event and connections
-  // whose events don't reach the tap. #93594 moved it from 4s (its cadence
-  // when the poll WAS the delivery path) to 30s backstop cadence, matching
-  // the live-session status backstop.
-  assert.match(pluginSource, /RELAY_DRAIN_INTERVAL_MS = 30_000/)
-  assert.match(pluginSource, /setInterval\(\(\) => void drainRelayOutboxes\(\), RELAY_DRAIN_INTERVAL_MS\)/)
-})
-
-test('a push racing an in-flight drain schedules a follow-up pass instead of dropping', () => {
-  // The gateway signature is monotone — one event per new envelope, never
-  // re-broadcast — so a push swallowed by the relayDrainBusy early-return
-  // would strand its envelope until the poll. The rerun flag re-schedules.
-  const drain = pluginSource.slice(
-    pluginSource.indexOf('async function drainRelayOutboxes'),
-    pluginSource.indexOf('function scheduleRelayPushDrain')
-  )
-  assert.match(drain, /if \(relayDrainBusy\) \{/)
-  assert.match(drain, /relayDrainRerun = true/)
-  // finally block: after busy clears, a remembered push re-schedules once.
-  const finallyBlock = drain.slice(drain.indexOf('} finally {'))
-  assert.match(finallyBlock, /relayDrainBusy = false/)
-  assert.match(finallyBlock, /relayDrainRerun && !relayDisposed/)
-  assert.match(finallyBlock, /scheduleRelayPushDrain\(\)/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/relay-socket-retention.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/relay-socket-retention.test.mjs
deleted file mode 100644
index 3f05db329196..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/relay-socket-retention.test.mjs
+++ /dev/null
@@ -1,130 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Relay-route socket retention (#93594): while the bot relay is active, each
-// registered connection's pooled socket is pinned open via
-// host.retainProfileSocket so the drain loop reuses ONE persistent WebSocket
-// instead of dialing and tearing down a fresh one per tick. Contracts:
-// - retention is feature-detected (host.retainProfileSocket) — older shells
-//   simply keep the per-call lease behavior;
-// - a connection is pinned once, not once per drain tick;
-// - a connection leaving the registry releases exactly its own pin;
-// - releaseRelayRetention drops every pin, and stopBotRelay calls it.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadRetention({ retainProfileSocket } = {}) {
-  const start = pluginSource.indexOf('const relayRouteRetentions = new Map()')
-  const end = pluginSource.indexOf('/** One representative route per reachable connection id. */', start)
-  assert.ok(start > 0, 'plugin defines relayRouteRetentions')
-  assert.ok(end > start, 'retention block has a stable source boundary')
-
-  const releases = []
-  const context = {
-    relayDisposed: false,
-    retainCalls: [],
-    releases,
-    host: {
-      retainProfileSocket:
-        retainProfileSocket === null
-          ? undefined
-          : route => {
-              context.retainCalls.push(route)
-              let released = false
-              const release = () => {
-                if (!released) {
-                  released = true
-                  releases.push(route)
-                }
-              }
-              return release
-            }
-    }
-  }
-  vm.createContext(context)
-  vm.runInContext(
-    `${pluginSource.slice(start, end)}
-globalThis.syncRelayRetention = syncRelayRetention
-globalThis.releaseRelayRetention = releaseRelayRetention
-globalThis.relayRouteRetentions = relayRouteRetentions`,
-    context
-  )
-  return context
-}
-
-const conn = id => ({ id, route: { connectionId: id, profile: 'default', targetProfile: 'default' } })
-
-test('each connection is pinned ONCE across multiple drain ticks', () => {
-  const ctx = loadRetention()
-  const connections = [conn('a'), conn('b')]
-
-  for (let tick = 0; tick < 4; tick += 1) {
-    ctx.syncRelayRetention(connections)
-  }
-
-  assert.equal(ctx.retainCalls.length, 2, 'one pin per connection, not per tick')
-  assert.equal(ctx.relayRouteRetentions.size, 2)
-  assert.equal(ctx.releases.length, 0, 'nothing released while connections stay registered')
-})
-
-test('a connection leaving the registry releases exactly its own pin', () => {
-  const ctx = loadRetention()
-
-  ctx.syncRelayRetention([conn('a'), conn('b')])
-  ctx.syncRelayRetention([conn('a')])
-
-  assert.equal(ctx.releases.length, 1)
-  assert.equal(ctx.releases[0].connectionId, 'b')
-  assert.equal(ctx.relayRouteRetentions.size, 1)
-})
-
-test('releaseRelayRetention drops every pin (stop/dispose path)', () => {
-  const ctx = loadRetention()
-
-  ctx.syncRelayRetention([conn('a'), conn('b'), conn('c')])
-  ctx.releaseRelayRetention()
-
-  assert.equal(ctx.releases.length, 3)
-  assert.equal(ctx.relayRouteRetentions.size, 0)
-
-  // Idempotent — a second stop releases nothing new.
-  ctx.releaseRelayRetention()
-  assert.equal(ctx.releases.length, 3)
-})
-
-test('a disposed relay never pins new connections but still releases stale ones', () => {
-  const ctx = loadRetention()
-
-  ctx.syncRelayRetention([conn('a')])
-  ctx.relayDisposed = true
-  ctx.syncRelayRetention([conn('b')])
-
-  assert.equal(ctx.retainCalls.length, 1, 'no new pin after dispose')
-  assert.equal(ctx.releases.length, 1, "the departed connection's pin was released")
-})
-
-test('retention is feature-detected: an older shell without the door is a no-op', () => {
-  const ctx = loadRetention({ retainProfileSocket: null })
-
-  ctx.syncRelayRetention([conn('a'), conn('b')])
-
-  assert.equal(ctx.relayRouteRetentions.size, 0)
-})
-
-test('stopBotRelay releases retention (source contract)', () => {
-  const stop = pluginSource.slice(
-    pluginSource.indexOf('function stopBotRelay('),
-    pluginSource.indexOf('/** Per-bot appearance')
-  )
-  assert.match(stop, /releaseRelayRetention\(\)/)
-
-  // And the drain loop reconciles retention with the CURRENT connection set
-  // before deciding whether there is anything to relay.
-  const drain = pluginSource.slice(
-    pluginSource.indexOf('async function drainRelayOutboxes'),
-    pluginSource.indexOf('function scheduleRelayPushDrain')
-  )
-  assert.match(drain, /syncRelayRetention\(/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/remote-routing-races.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/remote-routing-races.test.mjs
deleted file mode 100644
index dae14aa079a9..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/remote-routing-races.test.mjs
+++ /dev/null
@@ -1,683 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function deferred() {
-  let resolve
-  let reject
-  const promise = new Promise((res, rej) => {
-    resolve = res
-    reject = rej
-  })
-
-  return { promise, resolve, reject }
-}
-
-function load({ requestProfile, agents, profileRoutes } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = {
-      get: () => values.get(slot),
-      set: value => values.set(slot, typeof value === 'function' ? value(values.get(slot)) : value),
-      listen: () => undefined
-    }
-    values.set(slot, initial)
-    return slot
-  }
-  const calls = []
-  let activeConnectionId = 'remote-a'
-  const host = {
-    activeConnectionId: () => activeConnectionId,
-    agents: agents || (async () => ({ agents: [], sources: [] })),
-    deleteProfile: async route => calls.push(['deleteProfile', route]),
-    ensureAgent: async (connectionId, profile) => {
-      activeConnectionId = connectionId
-      calls.push(['ensureAgent', connectionId, profile])
-    },
-    newChat: (route, options) => calls.push(['newChat', route, options]),
-    notify: () => undefined,
-    notifyError: () => undefined,
-    profileRoutes: profileRoutes || (async () => []),
-    openSession: async (...args) => calls.push(['openSession', ...args]),
-    request: async (method, params) => {
-      calls.push(['ambient', method, params])
-      return {}
-    },
-    requestProfile: requestProfile || (async (route, method, params) => {
-      calls.push(['profile', route, method, params])
-      return {}
-    }),
-    setWorkspaceScope: (mode, ownerKey, target) => calls.push(['workspaceScope', mode, ownerKey, target]),
-    state: {
-      connectionId: { get: () => activeConnectionId, listen: () => undefined },
-      gateway: { get: () => 'open', listen: () => undefined },
-      profile: { get: () => 'default', listen: () => undefined }
-    }
-  }
-  const context = {
-    atom,
-    clearTimeout,
-    console,
-    Date,
-    document: { createElement: () => ({}), getElementById: () => null, head: { appendChild: () => undefined } },
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    queryClient: { invalidateQueries: () => undefined },
-    setTimeout,
-    host,
-    window: { setTimeout, clearTimeout }
-  }
-  const code = source
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-      globalThis.__race = {
-        $botMeta,
-        botActivitySession,
-        botConnectionRoute,
-        botRosterKey,
-        botSelectionKey,
-        deleteBot,
-        duplicateBot,
-        ensureBotMetadata,
-        groupMemberKey,
-        migrateBotMeta,
-        migratedLocalRoutes,
-        newBotChat,
-        openBotCanonicalChat,
-        persistBotMetaSnapshot,
-        prepareBotSource,
-        requestForBot,
-        saveBotMeta,
-        setPluginStorage: storage => { pluginCtx = { storage } }
-      }
-    `)
-  vm.runInNewContext(code, context, { filename: 'plugin.js' })
-  return {
-    context,
-    calls,
-    host,
-    setActiveConnection: value => {
-      activeConnectionId = value
-    }
-  }
-}
-
-const remoteBot = {
-  connectionId: 'remote-a',
-  connectionLabel: 'Remote A',
-  name: 'default',
-  remoteSource: true,
-  route: { connectionId: 'remote-a', mode: 'remote', profile: 'default', targetProfile: 'remote-default' },
-  sourceScoped: true,
-  targetProfile: 'remote-default'
-}
-
-function recordingStorage(
-  initial,
-  failSetKey = null,
-  failRemoveKeys = [],
-  failSetTimes = Number.POSITIVE_INFINITY
-) {
-  const values = new Map(Object.entries(initial))
-  const operations = []
-  const failedRemovals = new Set(failRemoveKeys)
-  let failedSets = 0
-
-  return {
-    operations,
-    get: async key => values.get(key) ?? null,
-    set: async (key, value) => {
-      operations.push(['set', key, value])
-      if (key === failSetKey && failedSets < failSetTimes) {
-        failedSets += 1
-        throw new Error('disk full')
-      }
-      values.set(key, value)
-    },
-    remove: async key => {
-      operations.push(['remove', key])
-      if (failedRemovals.has(key)) {
-        throw new Error('remove failed')
-      }
-      values.delete(key)
-    }
-  }
-}
-
-test('same-name bots remain pinned to their own connection under concurrent requests', async () => {
-  const pendingA = deferred()
-  const pendingB = deferred()
-  const seen = []
-  const runtime = load({
-    requestProfile: (route, method) => {
-      seen.push([route, method])
-      return route.connectionId === 'remote-a' ? pendingA.promise : pendingB.promise
-    }
-  })
-  const botB = { ...remoteBot, connectionId: 'remote-b', route: { ...remoteBot.route, connectionId: 'remote-b', targetProfile: 'remote-default-b' } }
-
-  const first = runtime.context.__race.requestForBot(remoteBot, 'profiles.describe')
-  const second = runtime.context.__race.requestForBot(botB, 'profiles.describe')
-  await runtime.host.ensureAgent('remote-b', 'default')
-  pendingB.resolve({ ok: true })
-  pendingA.resolve({ ok: true })
-  await Promise.all([first, second])
-
-  assert.deepEqual(seen.map(([route]) => route.connectionId), ['remote-a', 'remote-b'])
-  assert.deepEqual(seen.map(([route]) => route.targetProfile), ['remote-default', 'remote-default-b'])
-})
-
-test('source-scoped routing fails closed instead of falling back to ambient host.request', async () => {
-  const runtime = load()
-  const ambient = []
-  runtime.host.request = async (...args) => ambient.push(args)
-  runtime.host.requestProfile = undefined
-
-  await assert.rejects(
-    runtime.context.__race.requestForBot(remoteBot, 'profiles.configure'),
-    /Cannot route profiles\.configure/
-  )
-  assert.deepEqual(ambient, [])
-})
-
-test('source-scoped routing rejects a missing connection id before dispatch', async () => {
-  const runtime = load()
-  const incomplete = {
-    ...remoteBot,
-    connectionId: '',
-    route: { ...remoteBot.route, connectionId: '' }
-  }
-
-  await assert.rejects(
-    runtime.context.__race.requestForBot(incomplete, 'profiles.configure'),
-    /no connection owner/i
-  )
-  assert.equal(runtime.calls.some(call => call[0] === 'ambient' || call[0] === 'profile'), false)
-})
-
-test('non-identity alias hydrates metadata from the backend row before Edit saves it', async () => {
-  const calls = []
-  const workerBot = {
-    ...remoteBot,
-    name: 'worker',
-    route: { ...remoteBot.route, profile: 'worker', targetProfile: 'backend-worker' },
-    targetProfile: 'backend-worker'
-  }
-  const runtime = load({
-    requestProfile: async (_route, method, params) => {
-      calls.push([method, params])
-      if (method === 'profiles.list') {
-        return {
-          profiles: [{
-            name: 'backend-worker',
-            ui_meta: {
-              'hermes-bots': { title: 'Hydrated', pinned: true, chat: 'worker-chat' }
-            }
-          }]
-        }
-      }
-      return { applied: { ui_meta: true } }
-    }
-  })
-
-  // prepareBotSource is a capability gate under name-identity — no pin returns.
-  await runtime.context.__race.prepareBotSource(workerBot)
-
-  const hydrated = await runtime.context.__race.ensureBotMetadata(workerBot)
-  assert.deepEqual(JSON.parse(JSON.stringify(hydrated)), {
-    title: 'Hydrated',
-    pinned: true,
-    chat: 'worker-chat'
-  })
-
-  await runtime.context.__race.saveBotMeta(workerBot, { title: 'Edited' })
-  const edit = calls.find(([method]) => method === 'profiles.configure')
-  assert.deepEqual(JSON.parse(JSON.stringify(edit[1])), {
-    name: 'backend-worker',
-    ui_meta: {
-      'hermes-bots': { title: 'Edited', pinned: true, chat: 'worker-chat' }
-    }
-  })
-})
-
-test('non-identity alias resolves the canonical chat by NAME on the backend profile', async () => {
-  const requests = []
-  const workerBot = {
-    ...remoteBot,
-    name: 'worker',
-    route: { ...remoteBot.route, profile: 'worker', targetProfile: 'backend-worker' },
-    targetProfile: 'backend-worker'
-  }
-  const runtime = load({
-    requestProfile: async (_route, method, params) => {
-      requests.push([method, params])
-      if (method === 'session.list') {
-        return {
-          sessions: [{ id: 'worker-chat', resolved_id: 'worker-chat-tip', title: 'Bot Chat', message_count: 3 }]
-        }
-      }
-      if (method === 'session.create') {
-        throw new Error('must not create: the registry row exists on the alias profile')
-      }
-      return {}
-    }
-  })
-
-  const result = await runtime.context.__race.openBotCanonicalChat(workerBot)
-
-  assert.equal(result.registryId, 'worker-chat')
-  assert.equal(result.openedId, 'worker-chat-tip')
-  const lookup = requests.find(([method]) => method === 'session.list')
-  assert.equal(lookup[1].profile, 'backend-worker', 'lookup uses the backend alias, not the logical name')
-  assert.equal(lookup[1].title, 'Bot Chat')
-  assert.equal(lookup[1].include_hidden, true)
-  const opened = runtime.calls.find(call => call[0] === 'openSession')
-  assert.equal(opened[1], 'worker-chat-tip', 'the lineage tip opens; the registry row stays the identity')
-})
-
-test('canonical sidebar activity and an explicit bot switch converge on a forced-resume open', async () => {
-  const bot = {
-    ...remoteBot,
-    canonical_session: { id: 'bot-chat', last_active: 20, preview: 'new canonical activity' },
-    last_session: { id: 'old-visible-chat', last_active: 10, preview: 'stale visible activity' }
-  }
-  const runtime = load({
-    requestProfile: async (_route, method) => {
-      if (method === 'session.list') {
-        return {
-          sessions: [{ id: 'bot-chat', resolved_id: 'bot-chat-tip', title: 'Bot Chat', message_count: 4 }]
-        }
-      }
-
-      return {}
-    }
-  })
-
-  assert.equal(
-    runtime.context.__race.botActivitySession(bot).id,
-    'bot-chat',
-    'the sidebar activity tile follows the hidden canonical chat'
-  )
-
-  const result = await runtime.context.__race.openBotCanonicalChat(bot)
-  const opened = runtime.calls.find(call => call[0] === 'openSession')
-
-  assert.deepEqual(JSON.parse(JSON.stringify(result)), { registryId: 'bot-chat', openedId: 'bot-chat-tip' })
-  assert.equal(opened[1], 'bot-chat-tip', 'the explicit switch opens the canonical lineage tip')
-  assert.equal(opened[2].awaitHydration, true)
-  assert.equal(opened[2].expectHistory, true)
-  assert.equal(opened[2].forceResume, true, 'a cached stale runtime must never suppress session.resume')
-  assert.equal(opened[2].route.connectionId, 'remote-a', 'resume stays on the canonical chat owner')
-})
-
-test('remote canonical lookup failure rejects instead of minting on the remote source', async () => {
-  const runtime = load({
-    requestProfile: async (_route, method) => {
-      if (method === 'session.list') {
-        throw new Error('remote gateway not ready')
-      }
-      if (method === 'session.create') {
-        throw new Error('must not create: a failed remote lookup is not "no chat exists"')
-      }
-      return {}
-    }
-  })
-
-  await assert.rejects(() => runtime.context.__race.openBotCanonicalChat(remoteBot), /Bot Chat registry/)
-  assert.equal(runtime.calls.some(call => call[0] === 'openSession'), false)
-})
-
-test('delayed edit, group mutation, and canonical session RPCs retain the route', async () => {
-  const pending = deferred()
-  const seen = []
-  const runtime = load({
-    requestProfile: (route, method, params) => {
-      seen.push([route, method, params])
-      return pending.promise
-    }
-  })
-
-  const edit = runtime.context.__race.saveBotMeta(remoteBot, { title: 'Remote title' })
-  const group = runtime.context.__race.requestForBot(remoteBot, 'profiles.configure', { name: 'default' })
-  const open = runtime.context.__race.openBotCanonicalChat(remoteBot)
-  await runtime.host.ensureAgent('remote-b', 'default')
-  pending.resolve({ applied: { ui_meta: true }, profiles: [{ name: 'default', preferred_session: { id: 'stored-remote' } }] })
-  await Promise.all([edit, group, open])
-
-  assert.ok(seen.length >= 3)
-  assert.ok(seen.every(([route]) => route.connectionId === 'remote-a'))
-  assert.ok(seen.every(([route]) => Object.isFrozen(route)))
-})
-
-test('delayed duplicate, delete, and new chat keep source ownership', async () => {
-  const pending = deferred()
-  const runtime = load({
-    requestProfile: (route, method) => {
-      runtime.calls.push(['profile', route, method])
-      return pending.promise
-    }
-  })
-  const workerBot = {
-    ...remoteBot,
-    name: 'worker',
-    route: { ...remoteBot.route, profile: 'worker', targetProfile: 'backend-worker' },
-    targetProfile: 'backend-worker'
-  }
-  runtime.context.__race.$botMeta.set({ 'remote-a::worker': { title: 'Original' } })
-
-  const duplicate = runtime.context.__race.duplicateBot(workerBot, [workerBot])
-  const edit = runtime.context.__race.saveBotMeta(workerBot, { pinned: true })
-  await runtime.host.ensureAgent('remote-b', 'default')
-  pending.resolve({ profiles: [{ name: 'default' }], applied: { ui_meta: true } })
-  await Promise.all([duplicate, edit])
-
-  runtime.context.__race.newBotChat(workerBot)
-  const deletePromise = runtime.context.__race.deleteBot(workerBot)
-  await deletePromise
-
-  const routes = runtime.calls
-    .filter(call => call[0] === 'profile' || call[0] === 'deleteProfile' || call[0] === 'newChat')
-    .map(call => call[1])
-    .filter(value => value && typeof value === 'object')
-  assert.ok(routes.length >= 3)
-  assert.ok(routes.every(route => route.connectionId === 'remote-a'))
-
-  const newChat = runtime.calls.find(call => call[0] === 'newChat')
-  assert.equal(newChat[2].workspaceMode, 'bots')
-  assert.equal(newChat[2].workspaceOwnerKey, 'bot:remote-a::worker')
-  assert.equal(newChat[1].targetProfile, 'backend-worker')
-
-  const scope = runtime.calls.find(call => call[0] === 'workspaceScope')
-  assert.equal(scope[1], 'bots')
-  assert.equal(scope[2], 'bot:remote-a::worker')
-  assert.equal(scope[3].kind, 'route')
-  assert.equal(scope[3].route.connectionId, 'remote-a')
-})
-
-
-test('default deletion is rejected in the executable mutation layer', async () => {
-  const runtime = load()
-  await assert.rejects(runtime.context.__race.deleteBot(remoteBot), /default profile cannot be deleted/i)
-  assert.equal(runtime.calls.some(call => call[0] === 'deleteProfile'), false)
-})
-
-test('source-scoped bot metadata save commits v2 marker after its data', async () => {
-  const storage = recordingStorage({ 'bot-meta-v2-migrated': true })
-  const runtime = load({
-    requestProfile: async () => ({ applied: { ui_meta: true } })
-  })
-  runtime.context.__race.setPluginStorage(storage)
-
-  await runtime.context.__race.saveBotMeta(remoteBot, { title: 'Remote' })
-
-  assert.deepEqual(storage.operations.map(operation => operation.slice(0, 2)), [
-    ['remove', 'bot-meta-v2-migrated'],
-    ['set', 'bot-meta-v2'],
-    ['set', 'bot-meta-v2-migrated']
-  ])
-})
-
-test('scoped metadata reconciliation commits v2 marker after its data', async () => {
-  const storage = recordingStorage({ 'bot-meta-v2-migrated': true })
-  const runtime = load()
-  runtime.context.__race.setPluginStorage(storage)
-
-  await runtime.context.__race.persistBotMetaSnapshot({
-    'remote-a::default': { hidden: true }
-  }, true)
-
-  assert.deepEqual(storage.operations.map(operation => operation.slice(0, 2)), [
-    ['remove', 'bot-meta-v2-migrated'],
-    ['set', 'bot-meta-v2'],
-    ['set', 'bot-meta-v2-migrated']
-  ])
-})
-
-test('v1 metadata migrates only for a provable sole-local topology and keeps rollback data', async () => {
-  const writes = []
-  const runtime = load({
-    agents: async () => ({
-      agents: [{ connectionId: 'local', connectionKind: 'local', profile: 'default' }],
-      sources: [{ connectionId: 'local', kind: 'local' }]
-    }),
-    profileRoutes: async () => [{ connectionId: 'local', mode: 'local', profile: 'default', targetProfile: 'default' }],
-    storage: {
-      get: async key => key === 'bot-meta' ? { default: { title: 'Local' } } : null,
-      set: async (key, value) => writes.push([key, value])
-    }
-  })
-
-  const migrated = await runtime.context.__race.migrateBotMeta({
-    get: async key => key === 'bot-meta' ? { default: { title: 'Local' } } : null,
-    remove: async () => undefined,
-    set: async (key, value) => writes.push([key, value])
-  })
-  assert.equal(migrated, true)
-  assert.deepEqual(Object.keys(runtime.context.__race.$botMeta.get()), ['local::default'])
-  assert.deepEqual(writes.map(([key]) => key), ['bot-meta-v2', 'bot-meta-v2-migrated'])
-})
-
-test('migration rolls back routes when a later v1 profile has no local route', async () => {
-  const runtime = load({
-    agents: async () => ({
-      agents: [{ connectionId: 'local', connectionKind: 'local', profile: 'first' }],
-      sources: [{ connectionId: 'local', kind: 'local' }]
-    }),
-    profileRoutes: async () => [
-      { connectionId: 'local', mode: 'local', profile: 'first', targetProfile: 'backend-first' }
-    ]
-  })
-
-
-  const migrated = await runtime.context.__race.migrateBotMeta({
-    get: async key => key === 'bot-meta'
-      ? { first: { title: 'First' }, missing: { title: 'Missing' } }
-      : null,
-    set: async () => assert.fail('storage must not be written before every route is proven')
-  })
-
-  assert.equal(migrated, false)
-  assert.equal(runtime.context.__race.migratedLocalRoutes.size, 0)
-  assert.deepEqual(JSON.parse(JSON.stringify(runtime.context.__race.$botMeta.get())), {
-    first: { title: 'First' },
-    missing: { title: 'Missing' }
-  })
-})
-
-test('failed normal v2 successor commit preserves the last committed generation on reload', async () => {
-  const committed = {
-    'remote-a::default': { title: 'B' }
-  }
-  const storage = recordingStorage(
-    {
-      'bot-meta-v2': committed,
-      'bot-meta-v2-migrated': true
-    },
-    'bot-meta-v2-migrated',
-    [],
-    1
-  )
-  const runtime = load({
-    requestProfile: async () => ({ applied: { ui_meta: true } }),
-    storage
-  })
-  runtime.context.__race.setPluginStorage(storage)
-  assert.equal(await runtime.context.__race.migrateBotMeta(storage), true)
-
-  await runtime.context.__race.saveBotMeta(remoteBot, { title: 'D' })
-
-  const reloaded = load({ storage })
-  assert.equal(await reloaded.context.__race.migrateBotMeta(storage), true)
-  assert.deepEqual(
-    JSON.parse(JSON.stringify(reloaded.context.__race.$botMeta.get())),
-    committed
-  )
-})
-
-test('failed marker commit rolls persisted v2 back and reload keeps v1 authoritative', async () => {
-  const storage = recordingStorage(
-    { 'bot-meta': { first: { title: 'First' } } },
-    'bot-meta-v2-migrated'
-  )
-  const options = {
-    agents: async () => ({
-      agents: [{ connectionId: 'local', connectionKind: 'local', profile: 'first' }],
-      sources: [{ connectionId: 'local', kind: 'local' }]
-    }),
-    profileRoutes: async () => [
-      { connectionId: 'local', mode: 'local', profile: 'first', targetProfile: 'backend-first' }
-    ],
-    storage
-  }
-  const runtime = load(options)
-
-  const migrated = await runtime.context.__race.migrateBotMeta(storage)
-
-  assert.equal(migrated, false)
-  assert.equal(runtime.context.__race.migratedLocalRoutes.size, 0)
-  assert.deepEqual(JSON.parse(JSON.stringify(runtime.context.__race.$botMeta.get())), {
-    first: { title: 'First' }
-  })
-  assert.deepEqual(storage.operations.map(operation => operation.slice(0, 2)), [
-    ['remove', 'bot-meta-v2-migrated'],
-    ['set', 'bot-meta-v2'],
-    ['set', 'bot-meta-v2-migrated'],
-    ['remove', 'bot-meta-v2-migrated'],
-    ['remove', 'bot-meta-v2']
-  ])
-
-  const reloaded = load(options)
-  const acceptedAfterReload = await reloaded.context.__race.migrateBotMeta(storage)
-
-  assert.equal(acceptedAfterReload, false)
-  assert.deepEqual(JSON.parse(JSON.stringify(reloaded.context.__race.$botMeta.get())), {
-    first: { title: 'First' }
-  })
-})
-
-test('failed marker and failed v2 cleanup still reload v1 instead of markerless v2', async () => {
-  const storage = recordingStorage(
-    { 'bot-meta': { first: { title: 'Rollback' } } },
-    'bot-meta-v2-migrated',
-    ['bot-meta-v2']
-  )
-  const options = {
-    agents: async () => ({
-      agents: [{ connectionId: 'local', connectionKind: 'local', profile: 'first' }],
-      sources: [{ connectionId: 'local', kind: 'local' }]
-    }),
-    profileRoutes: async () => [
-      { connectionId: 'local', mode: 'local', profile: 'first', targetProfile: 'backend-first' }
-    ],
-    storage
-  }
-  const runtime = load(options)
-
-  assert.equal(await runtime.context.__race.migrateBotMeta(storage), false)
-
-  const reloaded = load(options)
-  assert.equal(await reloaded.context.__race.migrateBotMeta(storage), false)
-  assert.deepEqual(JSON.parse(JSON.stringify(reloaded.context.__race.$botMeta.get())), {
-    first: { title: 'Rollback' }
-  })
-})
-
-test('crash-window v2 write without a marker reloads v1 rollback data', async () => {
-  const storage = recordingStorage({
-    'bot-meta': { first: { title: 'Rollback' } },
-    'bot-meta-v2': { 'local::first': { title: 'Crash window' } }
-  })
-  const runtime = load({ storage })
-
-  assert.equal(await runtime.context.__race.migrateBotMeta(storage), false)
-  assert.deepEqual(JSON.parse(JSON.stringify(runtime.context.__race.$botMeta.get())), {
-    first: { title: 'Rollback' }
-  })
-})
-
-test('v1 metadata is not projected onto same-name bots in a multi-source topology', async () => {
-  const writes = []
-  const runtime = load({
-    agents: async () => ({
-      agents: [
-        { connectionId: 'local', connectionKind: 'local', profile: 'default' },
-        { connectionId: 'remote-a', connectionKind: 'remote', profile: 'default' }
-      ],
-      sources: [
-        { connectionId: 'local', kind: 'local' },
-        { connectionId: 'remote-a', kind: 'remote' }
-      ]
-    }),
-    profileRoutes: async () => [
-      { connectionId: 'local', mode: 'local', profile: 'default', targetProfile: 'default' },
-      remoteBot.route
-    ]
-  })
-
-  const migrated = await runtime.context.__race.migrateBotMeta({
-    get: async key => key === 'bot-meta' ? { default: { title: 'Legacy local' } } : null,
-    set: async (key, value) => writes.push([key, value])
-  })
-
-  assert.equal(migrated, false)
-  assert.deepEqual(JSON.parse(JSON.stringify(runtime.context.__race.$botMeta.get())), {
-    default: { title: 'Legacy local' }
-  })
-  assert.deepEqual(writes, [])
-})
-
-test('bot-meta-v2 is authoritative only with its persisted commit marker', async () => {
-  const runtime = load()
-  const v2 = {
-    'remote-a::default': { title: 'A' },
-    'remote-b::default': { title: 'B' }
-  }
-
-  const migrated = await runtime.context.__race.migrateBotMeta({
-    get: async key => key === 'bot-meta-v2'
-      ? v2
-      : key === 'bot-meta-v2-migrated'
-        ? true
-        : null,
-    set: async () => assert.fail('existing v2 must not be rewritten during hydration')
-  })
-
-  assert.equal(migrated, true)
-  assert.deepEqual(JSON.parse(JSON.stringify(runtime.context.__race.$botMeta.get())), v2)
-})
-
-test('markerless bot-meta-v2 is ignored on reload', async () => {
-  const runtime = load()
-  const markerlessV2 = { 'remote-a::default': { title: 'Uncommitted' } }
-
-  const migrated = await runtime.context.__race.migrateBotMeta({
-    get: async key => key === 'bot-meta-v2' ? markerlessV2 : null,
-    set: async () => assert.fail('markerless v2 must not be committed implicitly')
-  })
-
-  assert.equal(migrated, false)
-  assert.deepEqual(JSON.parse(JSON.stringify(runtime.context.__race.$botMeta.get())), {})
-})
-
-test('selection and metadata keys do not collide for same-name connections', () => {
-  const runtime = load()
-  const { botRosterKey, botSelectionKey, botConnectionRoute } = runtime.context.__race
-  const botB = {
-    ...remoteBot,
-    connectionId: 'remote-b',
-    route: { ...remoteBot.route, connectionId: 'remote-b' }
-  }
-  const a = botConnectionRoute(remoteBot)
-  const b = botConnectionRoute(botB)
-
-  assert.notEqual(botRosterKey({ ...remoteBot, route: a }), botRosterKey({ ...botB, route: b }))
-  assert.notEqual(botSelectionKey({ ...remoteBot, route: a }), botSelectionKey({ ...botB, route: b }))
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/roster-groups.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/roster-groups.test.mjs
deleted file mode 100644
index 27467a3f1c6a..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/roster-groups.test.mjs
+++ /dev/null
@@ -1,276 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request: () => Promise.resolve({}),
-      state: { profile: { get: () => 'default', listen: () => undefined }, gateway: { listen: () => undefined } }
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__groups = { botGroups, groupMembershipPatch, groupChatNames, groupLastActivity, groupChatMemberBots, durableGroupChatMembers, knownGroups, stripPreviewMarkdown, $groupChats };\n'
-    )
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context.__groups
-}
-
-test('botGroups: normalizes canonical and legacy membership without duplicates', () => {
-  const { botGroups } = load()
-
-  assert.equal(
-    JSON.stringify(
-      botGroups({ groups: [' Engineering ', '', 'Research', 'Engineering', null, 7, { name: 'Nope' }], group: 'Operations' })
-    ),
-    JSON.stringify(['Engineering', 'Research'])
-  )
-  assert.equal(JSON.stringify(botGroups({ group: 'Legacy' })), JSON.stringify(['Legacy']))
-  assert.equal(JSON.stringify(botGroups({ groups: [] })), JSON.stringify([]))
-})
-
-test('groupMembershipPatch: toggles one membership and keeps the legacy projection compatible', () => {
-  const { groupMembershipPatch } = load()
-  const meta = { groups: ['Engineering', 'Research'], group: 'Engineering' }
-
-  assert.equal(
-    JSON.stringify(groupMembershipPatch(meta, 'Engineering', true)),
-    JSON.stringify({ groups: ['Engineering', 'Research'], group: 'Engineering' })
-  )
-  assert.equal(
-    JSON.stringify(groupMembershipPatch(meta, 'Operations', true)),
-    JSON.stringify({ groups: ['Engineering', 'Research', 'Operations'], group: 'Engineering' })
-  )
-  assert.equal(
-    JSON.stringify(groupMembershipPatch(meta, 'Engineering', false)),
-    JSON.stringify({ groups: ['Research'], group: 'Research' })
-  )
-  assert.equal(
-    JSON.stringify(groupMembershipPatch({ group: 'Legacy' }, 'Legacy', false)),
-    JSON.stringify({ groups: [], group: null })
-  )
-})
-
-test('groupChatNames: unions bot-meta groups with room records that carry members or log', () => {
-  const { groupChatNames } = load()
-  const meta = {
-    researcher: { group: 'Research' },
-    pm: { groups: ['Ops', 'Research'], group: 'Ops' },
-    scout: { groups: ['External'], group: 'Stale' }
-  }
-  const rooms = {
-    Research: { log: [], members: [] }, // already known via meta
-    Remote: { log: [], members: [{ name: 'spark', remoteSource: true }] },
-    Chatty: { log: [{ from: { kind: 'user' }, text: 'hi', at: 5 }] },
-    Empty: { log: [], members: [] } // nothing behind it — no row
-  }
-
-  const names = groupChatNames(meta, rooms)
-
-  assert.equal(
-    JSON.stringify([...names].sort()),
-    JSON.stringify(['Chatty', 'External', 'Ops', 'Remote', 'Research'])
-  )
-})
-
-test('groupLastActivity: newest room-log timestamp, 0 for silence', () => {
-  const { groupLastActivity } = load()
-
-  assert.equal(groupLastActivity({ log: [{ at: 3 }, { at: 9 }] }), 9)
-  assert.equal(groupLastActivity({ log: [] }), 0)
-  assert.equal(groupLastActivity(undefined), 0)
-})
-
-test('groupChatMemberBots: seats local meta members plus stored remote descriptors, preferring live rows', () => {
-  const { groupChatMemberBots, $groupChats } = load()
-  const roster = [
-    { name: 'researcher' },
-    { name: 'builder' },
-    { name: 'spark', remoteSource: true, connectionId: 'c1', sourceScoped: true }
-  ]
-  $groupChats.set({
-    Research: {
-      log: [],
-      members: [{ name: 'spark', remoteSource: true, connectionId: 'c1', sourceScoped: true }]
-    }
-  })
-
-  const members = groupChatMemberBots('Research', roster, {
-    researcher: { group: 'Research' },
-    builder: { groups: ['Ops', 'Research'], group: 'Ops' }
-  })
-
-  assert.equal(JSON.stringify(members.map(m => m.name)), JSON.stringify(['researcher', 'builder', 'spark']))
-  // The LIVE roster row was preferred over the stored descriptor.
-  assert.equal(members[2], roster[2])
-})
-
-test('groupChatMemberBots: persisted unreachable source members stay seated next to a live same-name twin', () => {
-  const { groupChatMemberBots, $groupChats } = load()
-  const live = {
-    name: 'profile-a',
-    handle: 'profile-a-this-device',
-    connectionId: 'local',
-    connectionKind: 'local',
-    connectionLabel: 'This device',
-    sourceReachable: true
-  }
-  const stored = {
-    name: 'profile-a',
-    handle: 'profile-a-127-0-0-1-19119',
-    connectionId: 'loopback-19119',
-    connectionKind: 'remote',
-    connectionLabel: '127.0.0.1:19119',
-    remoteSource: true,
-    sourceScoped: true,
-    sourceReachable: false
-  }
-  $groupChats.set({ Research: { log: [], members: [stored] } })
-
-  const members = groupChatMemberBots('Research', [live, stored], {
-    'profile-a': { group: 'Research' }
-  })
-
-  assert.equal(members.length, 2)
-  assert.equal(members[0], live)
-  assert.equal(members[1], stored)
-  assert.equal(members[1].handle, 'profile-a-127-0-0-1-19119')
-})
-
-test('groupChatMemberBots: stored descriptors beat presentation-only ghosts', () => {
-  const { groupChatMemberBots, $groupChats } = load()
-  const ghost = {
-    name: 'spark',
-    remoteSource: true,
-    sourceScoped: true,
-    ghost: true,
-    connectionId: 'c1',
-    connectionLabel: 'Workshop'
-  }
-  const stored = {
-    name: 'spark',
-    handle: 'spark-work',
-    title: 'Spark',
-    remoteSource: true,
-    sourceScoped: true,
-    connectionId: 'c1',
-    connectionLabel: 'Workshop'
-  }
-  $groupChats.set({ Research: { log: [], members: [stored] } })
-
-  const members = groupChatMemberBots('Research', [ghost], {})
-
-  assert.equal(members.length, 1)
-  assert.equal(members[0], stored)
-  assert.equal(members[0].handle, 'spark-work')
-})
-
-test('durableGroupChatMembers: retains active and remote source identities', () => {
-  const { durableGroupChatMembers } = load()
-  const members = durableGroupChatMembers([
-    {
-      name: 'default',
-      handle: 'noah',
-      connectionId: 'noah',
-      connectionKind: 'remote',
-      connectionLabel: 'Noah',
-      sourceScoped: true
-    },
-    {
-      name: 'default',
-      handle: 'maya',
-      connectionId: 'maya',
-      connectionKind: 'remote',
-      connectionLabel: 'Maya',
-      remoteSource: true,
-      sourceScoped: true
-    }
-  ])
-
-  assert.equal(members.length, 2)
-  assert.deepEqual(
-    JSON.parse(JSON.stringify(members)),
-    [
-      {
-        name: 'default',
-        handle: 'noah',
-        connectionId: 'noah',
-        connectionKind: 'remote',
-        connectionLabel: 'Noah',
-        route: { connectionId: 'noah', mode: 'remote', profile: 'default', targetProfile: 'default' },
-        targetProfile: 'default',
-        remoteSource: true,
-        sourceScoped: true
-      },
-      {
-        name: 'default',
-        handle: 'maya',
-        connectionId: 'maya',
-        connectionKind: 'remote',
-        connectionLabel: 'Maya',
-        route: { connectionId: 'maya', mode: 'remote', profile: 'default', targetProfile: 'default' },
-        targetProfile: 'default',
-        remoteSource: true,
-        sourceScoped: true
-      }
-    ]
-  )
-})
-
-test('knownGroups: unique, trimmed, alphabetical', () => {
-  const { knownGroups } = load()
-
-  const groups = knownGroups({
-    a: { group: 'research' },
-    b: { groups: ['Ops', 'research'], group: 'Ops' },
-    c: { groups: ['Design'] },
-    d: { group: '' },
-    e: {}
-  })
-
-  assert.equal(JSON.stringify(groups), JSON.stringify(['Design', 'Ops', 'research']))
-})
-
-test('stripPreviewMarkdown: flattens bold, quotes, code, and links out of previews', () => {
-  const { stripPreviewMarkdown } = load()
-
-  assert.equal(stripPreviewMarkdown('**Plan**: ship the `thing`'), 'Plan: ship the thing')
-  assert.equal(stripPreviewMarkdown('> quoted wisdom'), 'quoted wisdom')
-  assert.equal(stripPreviewMarkdown('see [the doc](https://x.y/z) now'), 'see the doc now')
-  assert.equal(stripPreviewMarkdown('## Heading\nbody'), 'Heading body')
-  assert.equal(stripPreviewMarkdown(''), '')
-})
-
-test('source contract: the roster progressively groups multiple gateways and keeps group chats distinct', () => {
-  assert.match(pluginSource, /function rosterGatewaySections\(/)
-  assert.match(pluginSource, /options\.length <= 1/)
-  assert.match(pluginSource, /gatewayFilter !== 'all'/)
-  assert.match(pluginSource, /label: 'Group chats'/)
-  assert.match(pluginSource, /function GroupRow\(/)
-  assert.match(pluginSource, /onGroup: setGrouping/)
-})
-
-test('source contract: group rows carry the needs-you badge and open via openGroupChat', () => {
-  assert.match(pluginSource, /needsYou: Boolean\(groupNeedsYou\[row\.name\]\)/)
-  assert.match(pluginSource, /onOpen: openGroupChat/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/roster-preview.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/roster-preview.test.mjs
deleted file mode 100644
index 989767e97a02..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/roster-preview.test.mjs
+++ /dev/null
@@ -1,257 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function runtime() {
-  const atom = value => ({ get: () => value, set: () => undefined })
-  const jsx = (type, props = {}) => ({ type, props })
-  const context = {
-    atom,
-    jsx,
-    jsxs: jsx,
-    useQuery: () => ({}),
-    useValue: value => (value?.get ? value.get() : value),
-    useState: value => [value, () => undefined],
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: { state: { profile: { get: () => 'ops', listen: () => undefined } }, request: () => undefined }
-  }
-  const code = source
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__previewKind = previewKind;\nglobalThis.__generatedSessionTitle = generatedSessionTitle;\nglobalThis.__isGenericTitle = isGenericTitle;'
-    )
-  vm.runInNewContext(code, context)
-  return context
-}
-
-// NOTE: objects created inside the vm realm carry that realm's Object
-// prototype, so assert.deepEqual against host-realm literals fails on
-// reference-equality. Compare fields explicitly.
-function fromBotOf(preview) {
-  return runtime().__previewKind(preview).fromBot
-}
-
-test('previewKind: a plain chat preview is a human exchange, not a DM', () => {
-  assert.equal(fromBotOf('Can you check the vault sync?'), null)
-})
-
-test('previewKind: parses the current 🤖 delivery prefix and sender handle', () => {
-  assert.equal(fromBotOf('Message from 🤖 manager (@manager): Learn-share: skill installed'), 'manager')
-})
-
-test('previewKind: parses the legacy agent-prefix shape', () => {
-  assert.equal(fromBotOf("Message from agent 'researcher': here is the paper"), 'researcher')
-})
-
-test('previewKind: empty or absent preview is not a DM', () => {
-  assert.equal(fromBotOf(''), null)
-  assert.equal(fromBotOf(undefined), null)
-})
-
-test('isGenericTitle: auto-assigned titles are generic', () => {
-  const r = runtime()
-  assert.equal(r.__isGenericTitle('Bot Chat'), true)
-  assert.equal(r.__isGenericTitle('New chat'), true)
-  assert.equal(r.__isGenericTitle(''), true)
-  assert.equal(r.__isGenericTitle('Weekly review planning'), false)
-})
-
-test('generatedSessionTitle: keeps a meaningful stored title', () => {
-  const r = runtime()
-  assert.equal(r.__generatedSessionTitle({ title: 'Weekly review' }, 'some preview'), 'Weekly review')
-})
-
-test('generatedSessionTitle: invents a label from the preview for generic titles', () => {
-  const r = runtime()
-  assert.equal(r.__generatedSessionTitle({ title: 'Bot Chat' }, 'The tailnet proxy binds 100.64.0.1'), 'The tailnet proxy binds 100.64.0.1')
-})
-
-test('generatedSessionTitle: strips the bot-to-bot prefix before generating', () => {
-  const r = runtime()
-  const out = r.__generatedSessionTitle({ title: '' }, 'Message from 🤖 manager (@manager): Learn-share: skill installed')
-  assert.match(out, /Learn-share/)
-  assert.doesNotMatch(out, /Message from/)
-})
-
-test('generatedSessionTitle: caps the generated label length', () => {
-  const r = runtime()
-  const out = r.__generatedSessionTitle({ title: '' }, 'this is a very long preview that goes on and on and on about something or other entirely')
-  assert.ok(out.length <= 34, `expected <= 34 chars, got ${out.length}: ${out}`)
-})
-
-// ── render smoke: BotRow must paint the new row furniture without throwing ──
-
-function renderRuntime() {
-  const atom = value => ({ get: () => value, set: () => undefined })
-  const jsx = (type, props = {}) => ({ type, props })
-  const context = {
-    atom,
-    jsx,
-    jsxs: jsx,
-    cn: (...args) => args.filter(Boolean).join(' '),
-    Button: 'Button',
-    BotFace: 'BotFace',
-    Codicon: 'Codicon',
-    ContextMenu: 'ContextMenu',
-    ContextMenuContent: 'ContextMenuContent',
-    ContextMenuItem: 'ContextMenuItem',
-    ContextMenuSeparator: 'ContextMenuSeparator',
-    ContextMenuTrigger: 'ContextMenuTrigger',
-    Tip: 'Tip',
-    haptic: () => undefined,
-    host: {
-      state: {
-        profile: { get: () => 'scribe', listen: () => undefined },
-        gateway: { get: () => 'idle', listen: () => undefined }
-      },
-      request: () => Promise.resolve({ sessions: [] }),
-      openSession: () => undefined,
-      newChat: () => undefined,
-      navigate: () => undefined
-    },
-    profileColor: () => '#8b5cf6',
-    queryClient: { invalidateQueries: () => undefined },
-    relativeTime: () => 'now',
-    useQuery: () => ({}),
-    useValue: value => (value?.get ? value.get() : value),
-    useState: value => [value, () => undefined],
-    useEffect: () => undefined,
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } }
-  }
-  const code = source
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__BotRow = BotRow;')
-  vm.runInNewContext(code, context)
-  return context
-}
-
-function textOf(node) {
-  if (node == null || typeof node === 'boolean') return ''
-  if (typeof node === 'string' || typeof node === 'number') return String(node)
-  if (Array.isArray(node)) return node.map(textOf).join(' ')
-  if (typeof node === 'object') {
-    if (node.props) return textOf(node.props.children ?? '')
-    return Object.values(node).map(textOf).join(' ')
-  }
-  return ''
-}
-
-function findNode(node, predicate) {
-  if (node == null || typeof node !== 'object') return null
-  if (Array.isArray(node)) {
-    for (const child of node) {
-      const found = findNode(child, predicate)
-      if (found) return found
-    }
-    return null
-  }
-  if (predicate(node)) return node
-  return findNode(node.props?.children, predicate)
-}
-
-const DM_BOT = {
-  name: 'scribe',
-  title: 'Scribe',
-  description: '',
-  last_session: {
-    id: 's1',
-    title: 'Bot Chat',
-    preview: 'Message from 🤖 manager (@manager): Learn-share: skill installed in your profile',
-    last_active: Math.floor(Date.now() / 1000) - 5
-  }
-}
-
-test('render: BotRow shows a clean stripped DM preview without delivery furniture', () => {
-  const r = renderRuntime()
-  const tree = r.__BotRow({ bot: DM_BOT, onEdit: () => undefined })
-  const text = textOf(tree)
-  assert.match(text, /Learn-share/)
-  assert.doesNotMatch(text, /@manager/)
-  assert.doesNotMatch(text, /Message from/)
-})
-
-test('render: BotRow renders plain previews without a badge', () => {
-  const r = renderRuntime()
-  const tree = r.__BotRow({
-    bot: { name: 'ops', title: 'Ops', description: '', last_session: { id: 's2', title: 'Weekly review', preview: 'All hosts are healthy', last_active: 1_700_000_000 } },
-    onEdit: () => undefined
-  })
-  const text = textOf(tree)
-  assert.match(text, /All hosts are healthy/)
-  assert.doesNotMatch(text, /@manager/)
-  // The inline session-history chip is gone — the conversation lives in the
-  // bot's one canonical chat, so the title no longer renders inline.
-  assert.doesNotMatch(text, /Weekly review/)
-})
-
-test('render: BotRow tolerates a fresh bot with no sessions yet', () => {
-  const r = renderRuntime()
-  const tree = r.__BotRow({ bot: { name: 'newbie', title: '', description: 'Fresh bot' }, onEdit: () => undefined })
-  const text = textOf(tree)
-  assert.match(text, /Newbie/)
-  assert.doesNotMatch(text, /No conversations yet/)
-})
-
-test('render: a remote default uses its gateway identity without repeating it', () => {
-  const r = renderRuntime()
-  const tree = r.__BotRow({
-    bot: {
-      connectionId: 'studio-over-ssh',
-      connectionLabel: 'Studio over SSH',
-      handle: 'default-studio-over-ssh',
-      name: 'default',
-      remoteSource: true
-    },
-    onEdit: () => undefined
-  })
-  const name = findNode(tree, node => node.type === 'span' && textOf(node) === 'Studio over SSH')
-  const button = findNode(tree, node => node.type === 'button' && node.props?.['aria-label'])
-
-  assert.ok(name)
-  assert.ok(button)
-  assert.match(button.props['aria-label'], /Studio over SSH/)
-  assert.equal((textOf(button).match(/Studio over SSH/g) || []).length, 1)
-})
-
-test('render: BotRow previews the pinned canonical chat, not an unrelated latest session', () => {
-  // hermes-agent#88200: the row opens the pinned chat on click, so the
-  // preview must describe that same session — not the profile's most recent
-  // (but unrelated) activity.
-  const r = renderRuntime()
-  const tree = r.__BotRow({
-    bot: {
-      name: 'ops',
-      title: 'Ops',
-      description: '',
-      last_session: { id: 'scratch9', title: 'Scratch', preview: 'unrelated scratch content', last_active: 1_800_000_000 },
-      canonical_session: { id: 'pinned1', resolved_id: 'pinned1', title: 'Bot Chat', preview: 'pinned chat content', started_at: 1, last_active: 1_700_000_000, message_count: 5 }
-    },
-    onEdit: () => undefined
-  })
-  const text = textOf(tree)
-  assert.match(text, /pinned chat content/)
-  assert.doesNotMatch(text, /unrelated scratch content/)
-})
-
-test('previewKind: the primary profile surfaces as @hermes, never @default', () => {
-  // botHandle() exists so "the word 'default' never surfaces in the UI"; the
-  // bot-to-bot badge was rendering the raw captured profile name (#89484).
-  assert.equal(fromBotOf("Message from agent 'default': deploy is green"), 'hermes')
-})
-
-test('previewKind: a named profile keeps its own handle', () => {
-  assert.equal(fromBotOf("Message from agent 'ops': deploy is green"), 'ops')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/roster-query-retry.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/roster-query-retry.test.mjs
deleted file mode 100644
index 02150f31944c..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/roster-query-retry.test.mjs
+++ /dev/null
@@ -1,56 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// The Bots pane renders a spinner while useRoster() is isLoading and has no
-// snapshot. React Query treats `retry: true` as infinite retries, which keeps
-// isLoading true forever — the sidebar stays empty with no error/retry card.
-// Bounded retries plus the existing 5s refetch recover SSH/sleep drops.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      state: {
-        profile: { get: () => 'default', listen: () => undefined },
-        gateway: { get: () => 'open', listen: () => undefined },
-        connectionId: { get: () => 'local', listen: () => undefined }
-      },
-      request: () => Promise.resolve({ profiles: [] })
-    },
-    sdk: new Proxy({}, { get: () => undefined })
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-globalThis.__roster = { ROSTER_QUERY_RETRY };
-`)
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context.__roster
-}
-
-test('roster query retries are bounded so a stalled profiles.list cannot pin the spinner', () => {
-  const { ROSTER_QUERY_RETRY } = load()
-  assert.equal(typeof ROSTER_QUERY_RETRY, 'number')
-  assert.ok(ROSTER_QUERY_RETRY >= 0)
-  assert.ok(ROSTER_QUERY_RETRY < Number.POSITIVE_INFINITY)
-  assert.notEqual(ROSTER_QUERY_RETRY, true)
-  assert.match(pluginSource, /retry:\s*ROSTER_QUERY_RETRY/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routine-deliver-target.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routine-deliver-target.test.mjs
deleted file mode 100644
index 4e4fe79d0c5c..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routine-deliver-target.test.mjs
+++ /dev/null
@@ -1,31 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// The Create Cronjob dialog's "Send results to" target picker: source-shape
-// tests in the style of the sibling routine tests (the plugin is a single
-// direct file; behavior contracts are pinned via source assertions where a
-// full DOM harness would be heavier than the seam warrants).
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('dialog offers a delivery target picker with history and bot-chat options', () => {
-  assert.match(pluginSource, /Send results to/)
-  assert.match(pluginSource, /id: 'history', label: 'Run history only'/)
-  assert.match(pluginSource, /id: 'bot-chat'/)
-})
-
-test('bot-chat target sends the BARE deliver token on the profile-scoped create', () => {
-  // The job is created in the bot's own cron store (profile: bot), so the
-  // bare token resolves to that profile machine-locally — a named token
-  // built from a Desktop-side alias could name a profile the backend does
-  // not have (the #82530 alias trap). Pin the bare form.
-  assert.match(pluginSource, /\.\.\.\(target === 'bot-chat' \? \{ deliver: 'bot-chat' \} : \{\}\)/)
-  assert.doesNotMatch(pluginSource, /deliver: `bot-chat:\$\{/)
-})
-
-test('history target (default) sends no deliver param — behavior unchanged', () => {
-  assert.match(pluginSource, /useState\('history'\)/)
-  // reset() returns the picker to the default so a reopened dialog never
-  // inherits the previous create's target.
-  assert.match(pluginSource, /setTarget\('history'\)/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routine-detail.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routine-detail.test.mjs
deleted file mode 100644
index 1d7e55293d31..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routine-detail.test.mjs
+++ /dev/null
@@ -1,205 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// Bot Mode's Cronjobs rows were inert: the only interactive controls were the
-// enable switch and the hover-only delete button, so clicking a cronjob to see
-// what it runs, when it runs next, or why it stopped did nothing at all. The
-// gateway already ships every one of those facts with `cron.manage list`, so
-// the inspector reads the record the pane is holding — no extra RPC, and no
-// second mutation path beside the row's own switch and delete.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const node = (type, props = {}) => ({ props, type })
-  const context = {
-    atom,
-    Button: 'Button',
-    Codicon: 'Codicon',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    cn: (...parts) => parts.filter(Boolean).join(' '),
-    Dialog: 'Dialog',
-    DialogContent: 'DialogContent',
-    DialogDescription: 'DialogDescription',
-    DialogFooter: 'DialogFooter',
-    DialogHeader: 'DialogHeader',
-    DialogTitle: 'DialogTitle',
-    document: { createElement: () => ({}), getElementById: () => null, head: { appendChild: () => undefined } },
-    host: { state: { profile: { listen: () => undefined } } },
-    jsx: node,
-    jsxs: node,
-    PALETTE_AREA: 'palette',
-    relativeTime: () => 'in 5 min',
-    Switch: 'Switch',
-    Tip: 'Tip',
-    useState: initial => [typeof initial === 'function' ? initial() : initial, () => undefined]
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-      globalThis.__api = { RoutineDetailDialog, RoutineRow, routineDetailIssue, routineDetailRows };
-    `)
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context.__api
-}
-
-/** Depth-first walk over the stubbed element tree. */
-function collect(node, match, found = []) {
-  if (Array.isArray(node)) {
-    for (const child of node) collect(child, match, found)
-    return found
-  }
-
-  if (!node || typeof node !== 'object') {
-    return found
-  }
-
-  if (match(node)) {
-    found.push(node)
-  }
-
-  return collect(node.props?.children, match, found)
-}
-
-function textOf(node) {
-  return collect(node, entry => typeof entry.props?.children === 'string')
-    .map(entry => entry.props.children)
-    .join(' | ')
-}
-
-const activeJob = {
-  deliver: 'bot-chat',
-  enabled: true,
-  job_id: 'job-1',
-  last_run_at: '2026-08-23T09:00:00Z',
-  last_status: 'success',
-  name: '[bot:notetaker] Morning digest',
-  next_run_at: '2026-08-23T10:00:00Z',
-  prompt_preview: 'Summarize yesterday and post it.',
-  repeat: 'forever',
-  schedule: 'every 1440m'
-}
-
-// ── the facts the row never showed ──────────────────────────────────────────
-
-test('detail rows only carry fields the gateway actually sent', () => {
-  const { routineDetailRows } = load()
-  const rows = routineDetailRows({ enabled: true, job_id: 'bare', name: 'Bare', schedule: 'every 1h' })
-  const labels = rows.map(row => row.label)
-
-  // A job that has never run carries no last_run_at/last_status/model; those
-  // rows must be absent rather than rendering an empty or "undefined" value.
-  assert.ok(!labels.includes('Last run'))
-  assert.ok(!labels.includes('Last result'))
-  assert.ok(!labels.includes('Model'))
-  assert.ok(rows.every(row => row.value.trim().length > 0))
-})
-
-test('an active job reports its next run; a paused one does not claim one', () => {
-  const { routineDetailRows } = load()
-  const value = (rows, label) => rows.find(row => row.label === label)?.value
-
-  const active = routineDetailRows(activeJob)
-  assert.equal(value(active, 'Status'), 'Active')
-  assert.ok(value(active, 'Next run'))
-
-  const paused = routineDetailRows({ ...activeJob, enabled: false, state: 'paused' })
-  assert.equal(value(paused, 'Status'), 'Paused')
-  assert.equal(value(paused, 'Next run'), undefined, 'a paused job has no next run to promise')
-  assert.ok(value(paused, 'Last run'), 'history it does have is still shown')
-})
-
-test('the raw schedule appears only when the humanized label dropped something', () => {
-  const { routineDetailRows } = load()
-  const raw = rows => rows.find(row => row.label === 'Schedule (raw)')?.value
-
-  // "every 1440m" humanizes to "Daily" — the raw form still carries the cadence.
-  assert.equal(raw(routineDetailRows(activeJob)), 'every 1440m')
-  // A schedule the label passes through unchanged would only be duplicated.
-  const passthrough = routineDetailRows({ ...activeJob, schedule: '0 9 * * 1-5' })
-  assert.equal(raw(passthrough), undefined)
-  assert.equal(passthrough.find(row => row.label === 'Schedule')?.value, '0 9 * * 1-5')
-})
-
-test('a failing or scheduler-paused job explains itself, in failure order', () => {
-  const { routineDetailIssue } = load()
-
-  assert.equal(routineDetailIssue(activeJob), null)
-  assert.equal(routineDetailIssue({ ...activeJob, paused_reason: 'too many failures' }), 'too many failures')
-  assert.equal(
-    routineDetailIssue({ ...activeJob, last_delivery_error: 'telegram 401', paused_reason: 'too many failures' }),
-    'telegram 401'
-  )
-  assert.equal(
-    routineDetailIssue({
-      ...activeJob,
-      last_delivery_error: 'telegram 401',
-      last_fire_error: 'model timeout',
-      paused_reason: 'too many failures'
-    }),
-    'model timeout',
-    'the run that never happened outranks the delivery of a run that did'
-  )
-})
-
-// ── the row is reachable ────────────────────────────────────────────────────
-
-test('the row title is a button that opens THIS job', () => {
-  const { RoutineRow } = load()
-  const opened = []
-  const tree = RoutineRow({ job: activeJob, onOpen: job => opened.push(job), owner: 'notetaker' })
-  const buttons = collect(tree, entry => entry.type === 'button' && typeof entry.props.onClick === 'function')
-
-  assert.ok(buttons.length >= 1, 'the row exposes at least one activation target')
-  const [title] = buttons
-  title.props.onClick()
-  assert.deepEqual(opened, [activeJob])
-})
-
-test('opening the details cannot swallow the switch or the delete control', () => {
-  const { RoutineRow } = load()
-  const tree = RoutineRow({ job: activeJob, onOpen: () => undefined, owner: 'notetaker' })
-  const openers = collect(tree, entry => entry.props?.title === 'Cronjob details')
-
-  assert.equal(openers.length, 1)
-  // The switch and the delete button must not live INSIDE the opener: a click
-  // on them would otherwise also open the inspector (and nested interactive
-  // elements are invalid markup).
-  assert.deepEqual(collect(openers[0], entry => entry.type === 'Switch'), [])
-  assert.deepEqual(collect(openers[0], entry => entry.type === 'Tip'), [])
-  assert.equal(collect(tree, entry => entry.type === 'Switch').length, 1)
-})
-
-// ── the inspector ───────────────────────────────────────────────────────────
-
-test('the inspector renders the job’s instruction and its failure', () => {
-  const { RoutineDetailDialog } = load()
-  const job = { ...activeJob, last_fire_error: 'model timeout' }
-  const rendered = textOf(RoutineDetailDialog({ job, onClose: () => undefined, open: true }))
-
-  assert.match(rendered, /Morning digest/)
-  assert.match(rendered, /Summarize yesterday and post it\./)
-  assert.match(rendered, /model timeout/)
-  assert.doesNotMatch(rendered, /\[bot:notetaker\]/, 'the routing tag is plumbing, not a title')
-})
-
-test('the inspector stays shut without a job to inspect', () => {
-  const { RoutineDetailDialog } = load()
-
-  assert.equal(RoutineDetailDialog({ job: null, onClose: () => undefined, open: true }).props.open, false)
-  assert.equal(RoutineDetailDialog({ job: activeJob, onClose: () => undefined, open: false }).props.open, false)
-  assert.equal(RoutineDetailDialog({ job: activeJob, onClose: () => undefined, open: true }).props.open, true)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routine-owner.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routine-owner.test.mjs
deleted file mode 100644
index a97932154009..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routine-owner.test.mjs
+++ /dev/null
@@ -1,146 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-const plain = value => JSON.parse(JSON.stringify(value))
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = {
-      get: () => values.get(slot),
-      set: value => values.set(slot, typeof value === 'function' ? value(values.get(slot)) : value)
-    }
-    values.set(slot, initial)
-    return slot
-  }
-  const invalidations = []
-  const requests = []
-  const node = (type, props = {}) => ({ props, type })
-  const context = {
-    atom,
-    Button: 'Button',
-    Codicon: 'Codicon',
-    cn: (...parts) => parts.filter(Boolean).join(' '),
-    Dialog: 'Dialog',
-    DialogContent: 'DialogContent',
-    DialogDescription: 'DialogDescription',
-    DialogFooter: 'DialogFooter',
-    DialogHeader: 'DialogHeader',
-    DialogTitle: 'DialogTitle',
-    host: {
-      state: {
-        profile: { get: () => 'ops', listen: () => undefined },
-        gateway: { get: () => 'open', listen: () => undefined }
-      },
-      request: async (method, params) => {
-        requests.push({ method, params })
-        return { jobs: [] }
-      },
-      requestProfile: async (route, method, params) => {
-        requests.push({ method, params, route })
-        return { jobs: [] }
-      },
-      notify: () => undefined,
-      notifyError: () => undefined
-    },
-    jsx: node,
-    jsxs: node,
-    queryClient: {
-      invalidateQueries: async options => invalidations.push(options)
-    },
-    relativeTime: () => 'in 5 min',
-    Switch: 'Switch',
-    Tip: 'Tip',
-    useState: initial => [typeof initial === 'function' ? initial() : initial, () => undefined],
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__routineOwners = { RoutineRow, routineCreateTarget, invalidateRoutineOwner };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return { ...context, invalidations, requests }
-}
-
-/** Depth-first search over the stubbed element tree. */
-function find(node, match) {
-  if (Array.isArray(node)) {
-    for (const child of node) {
-      const hit = find(child, match)
-      if (hit) return hit
-    }
-    return null
-  }
-
-  if (!node || typeof node !== 'object') {
-    return null
-  }
-
-  return match(node) ? node : find(node.props?.children, match)
-}
-
-test('routine creation keeps its captured owner while another bot becomes active', () => {
-  const runtime = load()
-  assert.equal(runtime.__routineOwners.routineCreateTarget('ops', 'ops'), 'ops')
-  assert.equal(runtime.__routineOwners.routineCreateTarget('ops', 'default'), 'ops')
-  assert.equal(runtime.__routineOwners.routineCreateTarget(null, 'default'), 'default')
-})
-
-test('routine mutation invalidates only its immutable owner cache', async () => {
-  const runtime = load()
-  await runtime.__routineOwners.invalidateRoutineOwner('ops')
-  assert.deepEqual(plain(runtime.invalidations), [{
-    queryKey: ['hermes-bots', 'routines', 'ops'],
-    exact: true
-  }])
-})
-
-test('a row mutation addresses — and invalidates — the owner that rendered it', async () => {
-  const runtime = load()
-  const row = runtime.__routineOwners.RoutineRow({
-    job: { enabled: true, job_id: 'digest', name: '[bot:ops] Digest', schedule: 'every 1h' },
-    onOpen: () => undefined,
-    owner: 'ops'
-  })
-
-  const toggle = find(row, node => node.type === 'Switch')
-  assert.ok(toggle, 'the row still exposes its enable switch')
-
-  // 'ops' is the row's owner while the live gateway may already be on another
-  // bot: both the RPC and the cache eviction must name the owner, not the
-  // ambient profile.
-  await toggle.props.onCheckedChange(false)
-
-  assert.deepEqual(plain(runtime.requests), [
-    { method: 'cron.manage', params: { action: 'pause', name: 'digest', profile: 'ops' } }
-  ])
-  assert.deepEqual(plain(runtime.invalidations), [
-    { queryKey: ['hermes-bots', 'routines', 'ops'], exact: true }
-  ])
-})
-
-test('source contract: create mutations and dialog state retain one owner', () => {
-  assert.match(
-    pluginSource,
-    /function CreateRoutineDialog\(\{ bot, open, onClose \}\)[\s\S]*await requestForBot\(bot, 'cron\.manage',[\s\S]*\.\.\.\(profile \? \{ profile \} : \{\}\)[\s\S]*await invalidateRoutineOwner\(bot\)/
-  )
-  assert.match(pluginSource, /const \[createOwner, setCreateOwner\] = useState\(null\)/)
-  assert.match(pluginSource, /const openCreate = \(\) => \{[\s\S]*setCreateOwner\(owner\)[\s\S]*setCreateOpen\(true\)/)
-  assert.match(pluginSource, /const createTarget = owner \? routineCreateTarget\(createOwner, bot\) : null/)
-  // key must be the jsx() THIRD argument (a `key:` prop is silently ignored
-  // by the react/jsx-runtime and the dialog would keep stale per-bot state).
-  assert.match(pluginSource, /jsx\(CreateRoutineDialog, \{[\s\S]*?\}, createTarget\)/)
-  assert.doesNotMatch(pluginSource, /key: createTarget/)
-  assert.match(pluginSource, /bot: createTarget/)
-  assert.doesNotMatch(pluginSource, /setCreateOwner\(owner =>/)
-  assert.doesNotMatch(pluginSource, /onChanged: \(\) => void refetch\(\)/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routine-prompt.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routine-prompt.test.mjs
deleted file mode 100644
index ed2de91bf4bd..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routine-prompt.test.mjs
+++ /dev/null
@@ -1,190 +0,0 @@
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { existsSync, readFileSync, rmSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load(request = async () => ({ jobs: [] })) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom, PALETTE_AREA: 'palette', COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: {
-      request,
-      state: {
-        profile: { listen: () => undefined },
-        gateway: { listen: () => undefined }
-      }
-    }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(
-      '\nglobalThis.__routines = { isLegacyDelegatedRoutine, loadRoutines, normalizedProfileName, routineInputError, routinePrompt };\n'
-    )
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context
-}
-
-test('unit: direct execution is selected for the active bot profile', () => {
-  const { __routines } = load()
-  assert.equal(__routines.normalizedProfileName(' Default '), 'default')
-  assert.equal(__routines.routinePrompt('default', 'Health', 'Collect status', ' DEFAULT '), 'Collect status')
-})
-
-test('integration: a different active profile retains the delegated routine wrapper', () => {
-  const { __routines } = load()
-  const prompt = __routines.routinePrompt('research', 'Digest', 'Summarize findings', 'default')
-  assert.match(prompt, /hermes -p 'research' chat/)
-  assert.match(prompt, /\[Scheduled routine\] Summarize findings/)
-})
-
-test('security: delegated routine arguments remain literal shell values', () => {
-  const { __routines } = load()
-  const title = 'Audit $(printf TITLE_EXPANDED) `printf TITLE_TICK` \'quoted\''
-  const instruction = 'Line one $(printf TASK_EXPANDED) `printf TASK_TICK`\nLine two \'quoted\''
-  const prompt = __routines.routinePrompt('research', title, instruction, 'default')
-  const command = prompt.slice(prompt.indexOf('hermes '), prompt.lastIndexOf('\n\nIf the command'))
-  const script = `hermes() { printf '%s\\037' "$@"; }\n${command}`
-  const result = spawnSync('sh', ['-c', script], { encoding: 'utf8' })
-
-  assert.equal(result.status, 0, result.stderr)
-  assert.deepEqual(result.stdout.split('\x1f').slice(0, -1), [
-    '-p',
-    'research',
-    'chat',
-    '-c',
-    `Routine: ${title}`,
-    '-q',
-    `[Scheduled routine] ${instruction}`
-  ])
-})
-
-test('security: upgrade pauses persisted delegated routines before they can execute', async () => {
-  const titleSentinel = `/tmp/hermes-bot-mode-title-${process.pid}`
-  const taskSentinel = `/tmp/hermes-bot-mode-task-${process.pid}`
-  rmSync(titleSentinel, { force: true })
-  rmSync(taskSentinel, { force: true })
-
-  const title = `Audit $(touch ${titleSentinel})`
-  const instruction = `Inspect $(touch ${taskSentinel})`
-  const oldPrompt =
-    `You are running the scheduled routine "${title}" for agent 'research'. ` +
-    `Execute it AS that agent so the run lands in its own history: run this in the terminal and relay the output:\n\n` +
-    `hermes -p research chat -c "Routine: ${title}" -q ${JSON.stringify(`[Scheduled routine] ${instruction}`)}\n\n` +
-    `If the command fails, report the error instead.`
-  const persisted = JSON.parse(
-    JSON.stringify({
-      job_id: 'legacy-job',
-      name: '[bot:research] Audit',
-      prompt: oldPrompt,
-      prompt_preview: oldPrompt.slice(0, 100),
-      schedule: 'every 2h',
-      enabled: true,
-      state: 'scheduled',
-      repeat: { times: 3, completed: 1 }
-    })
-  )
-  const requests = []
-  const runtime = load(async (method, params) => {
-    requests.push([method, params])
-
-    if (params.action === 'list') {
-      return { jobs: [persisted] }
-    }
-
-    if (params.action === 'pause' && params.name === persisted.job_id) {
-      persisted.enabled = false
-      persisted.state = 'paused'
-      return { success: true }
-    }
-
-    throw new Error(`Unexpected request: ${method} ${JSON.stringify(params)}`)
-  })
-
-  const result = await runtime.__routines.loadRoutines()
-  assert.deepEqual(JSON.parse(JSON.stringify(requests)), [
-    ['cron.manage', { action: 'list', include_disabled: true }],
-    ['cron.manage', { action: 'pause', name: 'legacy-job' }]
-  ])
-  assert.equal(result.jobs[0].job_id, 'legacy-job')
-  assert.equal(result.jobs[0].schedule, 'every 2h')
-  assert.deepEqual(result.jobs[0].repeat, { times: 3, completed: 1 })
-  assert.equal(result.jobs[0].enabled, false)
-  assert.equal(result.jobs[0].state, 'paused')
-  assert.equal(existsSync(titleSentinel), false)
-  assert.equal(existsSync(taskSentinel), false)
-
-  await runtime.__routines.loadRoutines()
-  assert.deepEqual(JSON.parse(JSON.stringify(requests.slice(2))), [
-    ['cron.manage', { action: 'list', include_disabled: true }]
-  ])
-  assert.match(pluginSource, /disabled: busy \|\| legacyUnsafe/)
-  assert.match(pluginSource, /Paused for security: delete and recreate this legacy cronjob/)
-
-  const recreated = runtime.__routines.routinePrompt('research', title, instruction, 'default')
-  assert.equal(runtime.__routines.isLegacyDelegatedRoutine({ ...persisted, prompt_preview: recreated.slice(0, 100) }), false)
-  const command = recreated.slice(recreated.indexOf('hermes '), recreated.lastIndexOf('\n\nIf the command'))
-  const script = `hermes() { printf '%s\\037' "$@"; }\n${command}`
-  const executed = spawnSync('sh', ['-c', script], { encoding: 'utf8' })
-  assert.equal(executed.status, 0, executed.stderr)
-  assert.deepEqual(executed.stdout.split('\x1f').slice(0, -1), [
-    '-p',
-    'research',
-    'chat',
-    '-c',
-    `Routine: ${title}`,
-    '-q',
-    `[Scheduled routine] ${instruction}`
-  ])
-  assert.equal(existsSync(titleSentinel), false)
-  assert.equal(existsSync(taskSentinel), false)
-})
-
-test('robustness: routine input rejects NUL before cron creation', () => {
-  const { __routines } = load()
-  assert.equal(__routines.routineInputError('Normal title', 'Normal instruction'), null)
-  assert.match(__routines.routineInputError('Bad\0title', 'Normal instruction'), /NUL.*U\+0000/)
-  assert.match(__routines.routineInputError('Normal title', 'Bad\0instruction'), /NUL.*U\+0000/)
-  assert.match(
-    pluginSource,
-    /const inputError = routineInputError\(title, task\)[\s\S]*if \(inputError\)[\s\S]*setError\(inputError\)[\s\S]*return[\s\S]*requestForBot\(bot, 'cron\.manage'/
-  )
-})
-
-test('regression: Create Cronjob passes the active profile to routinePrompt', () => {
-  assert.match(pluginSource, /prompt: routinePrompt\(profile, title, task, activeProfile\)/)
-  const { __routines } = load()
-  const instruction = 'Keep "quoted" output intact'
-  assert.equal(__routines.routinePrompt('ops', 'Check', instruction, 'ops'), instruction)
-  assert.doesNotMatch(__routines.routinePrompt('ops', 'Check', instruction, 'ops'), /hermes -p/)
-})
-
-test('system: the direct-file plugin still registers its panes', () => {
-  const runtime = load()
-  const registered = []
-  runtime.plugin.register({ storage: { get: () => null }, register: entry => registered.push(entry) })
-  assert.equal(registered.some(entry => entry.id === 'pane'), true)
-  assert.equal(registered.some(entry => entry.id === 'routines'), true)
-})
-
-test('performance: direct prompt selection remains bounded', t => {
-  const { __routines } = load()
-  const start = Date.now()
-  for (let index = 0; index < 10000; index += 1) __routines.routinePrompt('ops', 'Check', 'Inspect', 'ops')
-  const elapsed = Date.now() - start
-  t.diagnostic(`10,000 direct prompt selections: ${elapsed} ms`)
-  assert.ok(elapsed < 1000)
-})
\ No newline at end of file
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routines-dialog-owner-label.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routines-dialog-owner-label.test.mjs
deleted file mode 100644
index 70618002cd0c..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routines-dialog-owner-label.test.mjs
+++ /dev/null
@@ -1,31 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// #93572: CreateRoutineDialog's "Send results to" picker built its label with
-// `displayName({ name: bot }, $botMeta.get()[bot])`. The dialog's `bot` prop
-// is routineCreateTarget() output — an owner OBJECT for roster-scoped bots —
-// so the label rendered "[object Object]" and the meta lookup keyed the map
-// with an object. The label must resolve owner objects through the
-// object-aware botRosterMeta() path and only wrap bare strings.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('CreateRoutineDialog bot-chat label resolves owner objects via botRosterMeta', () => {
-  const start = pluginSource.indexOf('function CreateRoutineDialog(')
-  assert.ok(start >= 0, 'CreateRoutineDialog must exist')
-  const dialog = pluginSource.slice(start, start + 8000)
-
-  const label = dialog.match(/\{ id: 'bot-chat', label: `\$\{displayName\(([^`]+)\)\}/)
-  assert.ok(label, 'bot-chat picker label must be built through displayName()')
-
-  // Owner objects pass through untouched; only bare strings are wrapped.
-  assert.match(label[1], /typeof bot === 'string' \? \{ name: bot \} : bot/)
-  // Meta lookup must go through the object-aware resolver, never index
-  // $botMeta with a possibly-object key.
-  assert.match(label[1], /botRosterMeta\(bot, \$botMeta\.get\(\)\)/)
-  assert.ok(
-    !/\$botMeta\.get\(\)\[bot\]/.test(dialog),
-    'the dialog must not index bot meta with the raw bot prop'
-  )
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routines-error.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routines-error.test.mjs
deleted file mode 100644
index a83b2ac68218..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routines-error.test.mjs
+++ /dev/null
@@ -1,110 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: { state: { profile: { listen: () => undefined } } }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__api = { selectRoutineJobs };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context
-}
-
-const jobs = [
-  { name: '[bot:ops] Morning', job_id: '1' },
-  { name: '[bot:research] Digest', job_id: '2' }
-]
-
-test('unit: a live list is filtered to the current bot', () => {
-  const { jobs: shown, live } = load().__api.selectRoutineJobs({ jobs }, null, [], 'ops')
-  assert.equal(live.length, 2)
-  assert.equal(shown.length, 1)
-  assert.equal(shown[0].job_id, '1')
-})
-
-test('regression: a profile-scoped list shows every job owned by that bot profile', () => {
-  const profileJobs = [
-    { name: 'ordinary profile cronjob', job_id: 'legacy' },
-    { name: '[bot:ops] Bot Mode routine', job_id: 'routine' }
-  ]
-  const view = load().__api.selectRoutineJobs({ jobs: profileJobs, scoped: 'ops' }, null, [], 'ops')
-
-  assert.deepEqual(
-    Array.from(view.jobs, job => job.job_id),
-    ['legacy', 'routine']
-  )
-})
-
-test('compatibility: an unmarked list keeps tag filtering for older gateways', () => {
-  const profileJobs = [
-    { name: 'ordinary launch-profile cronjob', job_id: 'legacy' },
-    { name: '[bot:ops] Bot Mode routine', job_id: 'routine' }
-  ]
-  const view = load().__api.selectRoutineJobs({ jobs: profileJobs }, null, [], 'ops')
-
-  assert.deepEqual(
-    Array.from(view.jobs, job => job.job_id),
-    ['routine']
-  )
-})
-
-test('compatibility: a stale scope marker cannot leak another profile\'s jobs', () => {
-  const profileJobs = [
-    { name: 'ordinary research cronjob', job_id: 'research' },
-    { name: '[bot:ops] Bot Mode routine', job_id: 'routine' }
-  ]
-  const view = load().__api.selectRoutineJobs({ jobs: profileJobs, scoped: 'research' }, null, [], 'ops')
-
-  assert.deepEqual(
-    Array.from(view.jobs, job => job.job_id),
-    ['routine']
-  )
-})
-
-test('regression: untagged legacy cronjobs remain visible only on the default bot', () => {
-  const legacy = { name: 'Existing reminder', job_id: 'legacy' }
-  const api = load().__api
-
-  assert.deepEqual(api.selectRoutineJobs({ jobs: [legacy] }, null, [], 'default').jobs, [legacy])
-  assert.deepEqual(api.selectRoutineJobs({ jobs: [legacy] }, null, [], 'ops').jobs, [])
-})
-
-test('unit: a failed refresh keeps the last good list', () => {
-  const view = load().__api.selectRoutineJobs(undefined, new Error('down'), jobs, 'ops')
-  assert.equal(view.live, null)
-  assert.equal(view.all.length, 2)
-  assert.equal(view.jobs.length, 1)
-})
-
-test('regression: a true empty list is still empty', () => {
-  const view = load().__api.selectRoutineJobs({ jobs: [] }, null, jobs, 'ops')
-  assert.ok(view.live)
-  assert.equal(view.jobs.length, 0)
-})
-
-test('regression: a first load error has no jobs to show', () => {
-  const view = load().__api.selectRoutineJobs(undefined, new Error('down'), [], 'ops')
-  assert.equal(view.all.length, 0)
-  assert.equal(view.jobs.length, 0)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routines-filter-hint.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routines-filter-hint.test.mjs
deleted file mode 100644
index 1df7adacc8ce..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routines-filter-hint.test.mjs
+++ /dev/null
@@ -1,56 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// UX improvement: when a bot's cron store HAS jobs but none are namespaced
-// `[bot:<name>]` for the active bot, the Routines pane now explains why it's
-// empty instead of showing the generic empty state with no hint.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load() {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: { state: { profile: { listen: () => undefined } } }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__api = { routineFilterHint };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context
-}
-
-test('hint: null when the active bot already has tagged jobs', () => {
-  const all = [{ name: '[bot:ops] Morning', job_id: '1' }]
-  assert.equal(load().__api.routineFilterHint(all, all), null)
-})
-
-test('hint: null when the store is genuinely empty', () => {
-  assert.equal(load().__api.routineFilterHint([], []), null)
-  assert.equal(load().__api.routineFilterHint(undefined, []), null)
-})
-
-test('hint: explains hidden jobs when store has jobs but none match the bot', () => {
-  const all = [
-    { name: '[bot:research] Digest', job_id: '2' },
-    { name: 'untagged job', job_id: '3' }
-  ]
-  const hint = load().__api.routineFilterHint(all, [])
-  assert.ok(hint)
-  assert.match(hint, /tagged for this bot/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routines-pane-owner.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routines-pane-owner.test.mjs
deleted file mode 100644
index c1d1307d6f54..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routines-pane-owner.test.mjs
+++ /dev/null
@@ -1,270 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// The Cronjobs pane read the shared roster with a bare `$lastRoster.get()`
-// while rendering. BotsHomeView owns the roster fetch, so whenever this pane
-// mounted before the roster hydrated (fresh boot ordering, renderer reload
-// resetting the atoms) it captured an empty snapshot forever: the pane stayed
-// pinned on "Cronjobs are unavailable until this agent appears in the
-// roster." even for a focused bot chat whose exact roster row existed, and
-// Create Cronjob silently no-oped (#94483).
-//
-// Contract:
-// 1. RoutinesPane must SUBSCRIBE to the roster (like every other consumer
-//    via useValue), so hydration/roster changes can re-render the pane.
-// 2. Once the owner resolves, the pane actually renders its content and a
-//    working create affordance instead of staying on the placeholder.
-// 3. A complete (authoritative) focused owner with no exact roster row still
-//    fails closed — the subscription fix must not loosen identity matching.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-const NL = String.fromCharCode(10)
-
-function stripImports(source) {
-  const out = []
-  let inImportBlock = false
-  for (const line of source.split(NL)) {
-    if (inImportBlock) {
-      if (line.includes(' from ')) inImportBlock = false
-      continue
-    }
-    if (line.startsWith('import ')) {
-      if (!line.includes(' from ')) inImportBlock = true
-      continue
-    }
-    out.push(line)
-  }
-  return out.join(NL)
-}
-
-function makeAtom(initial) {
-  const slot = {
-    value: initial,
-    listeners: new Set(),
-    get: () => slot.value,
-    set: next => {
-      slot.value = next
-      for (const fn of [...slot.listeners]) fn()
-    },
-    listen: fn => {
-      slot.listeners.add(fn)
-      return () => slot.listeners.delete(fn)
-    }
-  }
-  return slot
-}
-
-const UNAVAILABLE = 'Cronjobs are unavailable until this agent appears in the roster.'
-
-// Function components are lazily expanded (React would call them during
-// render); a component that explodes under the stubs contributes an opaque
-// subtree rather than failing the whole traversal.
-function expandNode(node, depth) {
-  if (typeof node.type !== 'function' || depth > 12) return null
-  try {
-    return node.type(node.props)
-  } catch {
-    return null
-  }
-}
-
-function collectStrings(node, out = [], depth = 0) {
-  if (node == null || depth > 24) return out
-  if (Array.isArray(node)) {
-    for (const child of node) collectStrings(child, out, depth + 1)
-    return out
-  }
-  if (typeof node === 'object') {
-    if (!node.props) return out
-    if (typeof node.type === 'function') {
-      collectStrings(expandNode(node, depth), out, depth + 1)
-      return out
-    }
-    collectStrings(node.props.children, out, depth + 1)
-    return out
-  }
-  if (typeof node === 'string' || typeof node === 'number') out.push(String(node))
-  return out
-}
-
-/** Depth-first search over the stubbed element tree. */
-function findNode(node, match, depth = 0) {
-  if (node == null || depth > 24) return null
-  if (Array.isArray(node)) {
-    for (const child of node) {
-      const hit = findNode(child, match, depth + 1)
-      if (hit) return hit
-    }
-    return null
-  }
-  if (!node || typeof node !== 'object' || !node.props) return null
-  if (match(node)) return node
-  if (typeof node.type === 'function') return findNode(expandNode(node, depth), match, depth + 1)
-  return findNode(node.props.children, match, depth + 1)
-}
-
-function runtime({ focusedOwner, jobs = [] } = {}) {
-  const subscribed = new Set()
-
-  // Minimal React hook memory: one slot list per runtime, indexed by call
-  // order within a render pass. `render()` starts a fresh pass so repeated
-  // calls model re-renders while setters keep their values across them.
-  const hooks = []
-  let hookIndex = 0
-
-  const context = {
-    atom: initial => makeAtom(initial),
-    sdk: new Proxy({}, { get: () => undefined }),
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    profileColor: () => '#64748b',
-    haptic: () => undefined,
-    queryClient: {},
-    relativeTime: () => '',
-    cn: (...parts) => parts.filter(Boolean).join(' '),
-    Button: 'Button',
-    Checkbox: 'Checkbox',
-    Codicon: 'Codicon',
-    ContextMenu: 'ContextMenu',
-    ContextMenuContent: 'ContextMenuContent',
-    ContextMenuItem: 'ContextMenuItem',
-    ContextMenuSeparator: 'ContextMenuSeparator',
-    ContextMenuTrigger: 'ContextMenuTrigger',
-    ConfirmDialog: 'ConfirmDialog',
-    CopyButton: 'CopyButton',
-    Dialog: 'Dialog',
-    DialogContent: 'DialogContent',
-    DialogDescription: 'DialogDescription',
-    DialogFooter: 'DialogFooter',
-    DialogHeader: 'DialogTitle-header',
-    DialogTitle: 'DialogTitle',
-    DropdownMenu: 'DropdownMenu',
-    DropdownMenuContent: 'DropdownMenuContent',
-    DropdownMenuItem: 'DropdownMenuItem',
-    DropdownMenuSeparator: 'DropdownMenuSeparator',
-    DropdownMenuTrigger: 'DropdownMenuTrigger',
-    EmptyState: 'EmptyState',
-    GlyphSpinner: 'GlyphSpinner',
-    Input: 'Input',
-    ScrollArea: 'ScrollArea',
-    SearchField: 'SearchField',
-    Select: 'Select',
-    SelectContent: 'SelectContent',
-    SelectItem: 'SelectItem',
-    SelectTrigger: 'SelectTrigger',
-    SelectValue: 'SelectValue',
-    Switch: 'Switch',
-    Textarea: 'Textarea',
-    Tip: 'Tip',
-    jsx: (type, props = {}) => ({ type, props }),
-    jsxs: (type, props = {}) => ({ type, props }),
-    // Minimal React stand-ins. useValue mirrors the SDK contract: registering
-    // the dependency is exactly what lets a later store write re-render us.
-    useState: initial => {
-      const i = hookIndex++
-      if (!(i in hooks)) hooks[i] = typeof initial === 'function' ? initial() : initial
-      const setValue = value => {
-        hooks[i] = typeof value === 'function' ? value(hooks[i]) : value
-      }
-      return [hooks[i], setValue]
-    },
-    useEffect: () => undefined,
-    useMemo: fn => fn(),
-    useRef: value => ({ current: value }),
-    useCallback: fn => fn,
-    useQuery: () => ({
-      data: { jobs, scoped: 'research' },
-      error: null,
-      isLoading: false,
-      refetch: () => {}
-    }),
-    useValue: value => {
-      if (value && typeof value.listen === 'function') {
-        value.listen(() => {})
-        subscribed.add(value)
-      }
-      return value?.get ? value.get() : value
-    },
-    host: {
-      request: async () => ({}),
-      state: {
-        connectionId: { get: () => 'local', listen: () => undefined },
-        profile: { get: () => 'research', listen: () => undefined },
-        ...(focusedOwner ? { focusedSessionOwner: focusedOwner } : {})
-      }
-    }
-  }
-
-  const marker = [NL + 'globalThis.__pane = { RoutinesPane, $lastRoster };'].join('')
-  const source = stripImports(pluginSource)
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(marker)
-
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-
-  const render = () => {
-    hookIndex = 0
-    return context.__pane.RoutinesPane()
-  }
-
-  return { render, $lastRoster: context.__pane.$lastRoster, subscribed }
-}
-
-test('regression: the pane follows the roster hydrating after mount', () => {
-  const focusedOwner = makeAtom({ connectionId: 'local', profile: 'research' })
-  const { render, $lastRoster, subscribed } = runtime({
-    focusedOwner,
-    jobs: [{ job_id: 'j-1', name: 'Report', schedule: 'every 1h', state: 'scheduled', enabled: true }]
-  })
-
-  // Mount order: pane first, roster fetch lands afterwards (BotsHomeView owns
-  // the fetch). First paint must be the fail-closed placeholder...
-  const before = collectStrings(render()).join(' ')
-  assert.ok(before.includes(UNAVAILABLE))
-
-  // ...but the pane must be wired to the store so the write can re-render it.
-  assert.ok(subscribed.has($lastRoster), 'RoutinesPane must subscribe to $lastRoster (bare .get() captured an empty roster forever)')
-  assert.ok($lastRoster.listeners.size >= 1, 'hydration must have a live path to re-render the pane')
-
-  // Roster arrives: the same focused bot chat now resolves to its exact row
-  // and the pane paints real content without any unrelated state change.
-  $lastRoster.set([{ name: 'research', connectionId: 'local' }])
-  const after = collectStrings(render()).join(' ')
-  assert.ok(!after.includes(UNAVAILABLE))
-  assert.ok(after.includes('Cronjobs'), 'pane should render its header once the owner resolves')
-  assert.ok(after.includes('Report'), 'the scheduled job row should paint after the roster hydrates')
-})
-
-test('create affordance appears once the owner resolves', () => {
-  const focusedOwner = makeAtom({ connectionId: 'local', profile: 'research' })
-  const { render, $lastRoster } = runtime({ focusedOwner, jobs: [] })
-
-  $lastRoster.set([{ name: 'research', connectionId: 'local' }])
-  const tree = render()
-
-  // The reported "Create Cronjob silently no-ops" symptom starts here: while
-  // the owner is stuck unresolved the pane never offers any create control.
-  // (Dialog internals are owned by the routine-create flow tests.)
-  const create = findNode(tree, node => {
-    if (node.type !== 'Button') return false
-    return collectStrings(node).join(' ') === 'Create Cronjob'
-  })
-  assert.ok(create, 'the empty-state Create Cronjob button should exist once the owner resolves')
-  assert.equal(typeof create.props.onClick, 'function')
-
-  const headerTip = findNode(tree, node => node.type === 'Tip' && node.props?.label === 'New Cronjob')
-  assert.ok(headerTip, 'the header New Cronjob affordance should exist once the owner resolves')
-  assert.equal(typeof headerTip.props.children?.props?.onClick, 'function')
-})
-
-test('a complete focused owner without an exact roster row still fails closed', () => {
-  const focusedOwner = makeAtom({ connectionId: 'local', profile: 'ghost-profile' })
-  const { render, $lastRoster } = runtime({ focusedOwner })
-
-  $lastRoster.set([{ name: 'research', connectionId: 'local' }])
-  const text = collectStrings(render()).join(' ')
-  assert.ok(text.includes(UNAVAILABLE))
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routines-pause-failure.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routines-pause-failure.test.mjs
deleted file mode 100644
index b81fa7cee3a3..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routines-pause-failure.test.mjs
+++ /dev/null
@@ -1,99 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// loadRoutines pauses persisted delegated routines inline before returning the
-// list. A single pause RPC failing used to reject the whole query — the pane
-// showed "Could not load cronjobs" (or the stale notice) over a list that
-// loaded fine, and the 20s poll retried the failing pause inside a failing
-// query forever. Each pause now swallows its own error, and the paused-state
-// overlay only claims jobs the gateway actually paused.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load(request) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: { request, state: { profile: { listen: () => undefined } } }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__routines = { loadRoutines };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context
-}
-
-const LEGACY_PREFIX = 'You are running the scheduled routine "'
-
-test('regression: a failed legacy-routine pause does not fail the routines list', async () => {
-  const jobs = [
-    { job_id: 'legacy-fails', name: '[bot:research] Audit', prompt_preview: `${LEGACY_PREFIX}Audit" for agent 'research'`, enabled: true, state: 'scheduled' },
-    { job_id: 'legacy-pauses', name: '[bot:research] Build', prompt_preview: `${LEGACY_PREFIX}Build" for agent 'research'`, enabled: true, state: 'scheduled' },
-    { job_id: 'normal', name: '[bot:research] Report', prompt: 'Summarize the day', enabled: true, state: 'scheduled' }
-  ]
-  const requests = []
-  const runtime = load(async (method, params) => {
-    requests.push([method, params])
-
-    if (params.action === 'list') {
-      return { jobs }
-    }
-    if (params.action === 'pause' && params.name === 'legacy-fails') {
-      throw new Error('gateway rejected the pause')
-    }
-    if (params.action === 'pause') {
-      return { success: true }
-    }
-    throw new Error(`Unexpected request: ${method} ${JSON.stringify(params)}`)
-  })
-
-  // Pre-fix this rejected with the pause error.
-  const result = await runtime.__routines.loadRoutines('research')
-  assert.equal(result.jobs.length, 3)
-
-  const byId = Object.fromEntries(result.jobs.map(job => [job.job_id, job]))
-  // Only the pause the gateway confirmed is overlaid as paused; the failed
-  // one keeps its server state and is retried on the next poll.
-  assert.equal(byId['legacy-fails'].enabled, true)
-  assert.equal(byId['legacy-fails'].state, 'scheduled')
-  assert.equal(byId['legacy-pauses'].enabled, false)
-  assert.equal(byId['legacy-pauses'].state, 'paused')
-  assert.equal(byId.normal.enabled, true)
-
-  assert.deepEqual(
-    requests.map(([method, params]) => [method, params.action, params.name]),
-    [
-      ['cron.manage', 'list', undefined],
-      ['cron.manage', 'pause', 'legacy-fails'],
-      ['cron.manage', 'pause', 'legacy-pauses']
-    ]
-  )
-})
-
-test('regression: all-pauses-failing still resolves with the list', async () => {
-  const runtime = load(async (method, params) => {
-    if (params.action === 'list') {
-      return { jobs: [{ job_id: 'only', name: '[bot:ops] Watch', prompt_preview: `${LEGACY_PREFIX}Watch" for agent 'ops'`, enabled: true, state: 'scheduled' }] }
-    }
-    throw new Error('gateway down')
-  })
-
-  const result = await runtime.__routines.loadRoutines('ops')
-  assert.equal(result.jobs[0].job_id, 'only')
-  assert.equal(result.jobs[0].enabled, true)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routines-profile-scope.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routines-profile-scope.test.mjs
deleted file mode 100644
index fd4e52b96136..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routines-profile-scope.test.mjs
+++ /dev/null
@@ -1,31 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-// #37: the Routines pane must scope cron.manage to the bot's OWN cron store via
-// the core RPC's optional `profile` param (a bot's profile can run a separate
-// gateway / keep cron in ~/.hermes/profiles/<name>/cron/). Older gateways
-// ignore the unknown param, so the [bot:] tag filter stays the fallback.
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-test('loadRoutines forwards a profile scope to cron.manage list + pause', () => {
-  const fn = source.slice(source.indexOf('async function loadRoutines('), source.indexOf('function useRoutines('))
-  assert.match(fn, /const scope = profile \? \{ profile \} : \{\}/)
-  // list call spreads the scope
-  assert.match(fn, /action: 'list', include_disabled: true, \.\.\.scope/)
-  // legacy-pause call spreads the scope too
-  assert.match(fn, /action: 'pause', name: job\.job_id, \.\.\.scope/)
-})
-
-test('useRoutines is bot-keyed so switching bots refetches', () => {
-  assert.match(source, /queryKey: \[\.\.\.ROUTINES_KEY, key\]/)
-  assert.match(source, /queryFn: \(\) => loadRoutines\(bot\)/)
-})
-
-test('RoutineRow toggle and create forward the profile scope', () => {
-  // RoutineRow pause/resume
-  assert.match(source, /requestForBot\(owner, 'cron\.manage', \{ action, name: job\.job_id, \.\.\.\(profile \? \{ profile \} : \{\}\) \}\)/)
-  // create
-  assert.match(source, /requestForBot\(bot, 'cron\.manage',[\s\S]*\.\.\.\(profile \? \{ profile \} : \{\}\)/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routines-rpc-error.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routines-rpc-error.test.mjs
deleted file mode 100644
index c334eff125e3..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routines-rpc-error.test.mjs
+++ /dev/null
@@ -1,103 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// loadRoutines -> requestForBot. A rejected JSON-RPC value that is not an
-// Error (or an Error whose `name` is not a string) used to crash React 19's
-// formatter: `(e.name || '').trim` is not a function. The Routines pane then
-// died instead of showing "Could not load cronjobs" (#94471).
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load(request, requestProfile) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const host = { request, state: { profile: { listen: () => undefined } } }
-  if (requestProfile) {
-    host.requestProfile = requestProfile
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat('\nglobalThis.__routines = { asRpcError, loadRoutines, requestForBot };\n')
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context
-}
-
-function react19Format(error) {
-  return `${(error.name || '').trim()}: ${error.message}`
-}
-
-test('regression: a non-Error cron.manage rejection becomes a string-named Error', async () => {
-  const runtime = load(async () => {
-    const failure = { name: 32000, message: 'cron.manage failed', code: -32603 }
-    throw failure
-  })
-
-  await assert.rejects(
-    () => runtime.__routines.loadRoutines('research'),
-    error => {
-      assert.equal(typeof error.name, 'string')
-      assert.doesNotThrow(() => react19Format(error))
-      assert.match(String(error.message), /cron.manage failed/)
-      assert.equal(error.cause.name, 32000)
-      return true
-    }
-  )
-})
-
-test('regression: Error with a numeric name is coerced before React 19 format', () => {
-  const weird = new Error('down')
-  Object.defineProperty(weird, 'name', { value: 13, configurable: true })
-  const coerced = load(async () => {}).__routines.asRpcError(weird, 'fallback')
-  assert.equal(typeof coerced.name, 'string')
-  assert.doesNotThrow(() => react19Format(coerced))
-  assert.match(String(coerced.message), /down/)
-})
-
-test('regression: a frozen non-string Error name is copied, not mutated in place', () => {
-  const weird = new Error('down')
-  Object.defineProperty(weird, 'name', { value: 13, configurable: false, writable: false })
-  const coerced = load(async () => {}).__routines.asRpcError(weird, 'fallback')
-  assert.notEqual(coerced, weird)
-  assert.equal(typeof coerced.name, 'string')
-  assert.doesNotThrow(() => react19Format(coerced))
-  assert.match(coerced.message, /down/)
-})
-
-test('regression: a sealed Error with a numeric name is copied, not mutated', () => {
-  const weird = new Error('sealed')
-  Object.defineProperty(weird, 'name', { value: 32000, configurable: true, writable: true })
-  Object.seal(weird)
-  const coerced = load(async () => {}).__routines.asRpcError(weird, 'fallback')
-  assert.notEqual(coerced, weird)
-  assert.equal(typeof coerced.name, 'string')
-  assert.doesNotThrow(() => react19Format(coerced))
-  assert.match(String(coerced.message), /sealed/)
-  // Assignment would have succeeded on a sealed writable property; we still
-  // copy so React 19 never sees a numeric name even if mutation is possible.
-  assert.equal(weird.name, 32000)
-})
-
-test('regression: a real Error passes through unchanged', () => {
-  const original = new Error('gateway rejected the pause')
-  const coerced = load(async () => {}).__routines.asRpcError(original, 'fallback')
-  assert.equal(coerced, original)
-  assert.equal(coerced.name, 'Error')
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/routines-selected-bot.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/routines-selected-bot.test.mjs
deleted file mode 100644
index f7c2f7fb3ee2..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/routines-selected-bot.test.mjs
+++ /dev/null
@@ -1,180 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #89625 follow-up (PR #89637 residual): nanostores' `.listen()` never replays
-// the current value the way `.subscribe()` does, so the $focusedBotProfile
-// listener in register() only kept $selectedBot current from the moment it was
-// attached. A disable -> profile switch -> re-enable cycle (Settings > Plugins)
-// left $selectedBot pointed at whichever bot was active before the plugin was
-// disabled. bindProfileSync() reseeds $selectedBot from the store's CURRENT
-// value before attaching the listener, so every register() starts in sync.
-//
-// #94516 regression: the same ladder must not dead-end the Routines pane.
-// The SDK's focusedSessionOwner store fails closed to null whenever the
-// focused session has no unique bot owner (normal chat, ambiguous owner
-// hints) — the common case while the user browses the Bots pane. The pane
-// must fall back to the bot the user clicked in the roster (the previously
-// working scope) instead of pinning every bot on the "Cronjobs are
-// unavailable until this agent appears in the roster." placeholder.
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function load({ focusedSessionOwnerSupported = false, focusedSessionOwner = null } = {}) {
-  const values = new Map()
-  const atom = initial => {
-    const slot = { get: () => values.get(slot), set: value => values.set(slot, value) }
-    values.set(slot, initial)
-    return slot
-  }
-  const state = { profile: { listen: () => undefined } }
-  if (focusedSessionOwnerSupported) {
-    state.focusedSessionOwner = atom(focusedSessionOwner)
-  }
-  const context = {
-    atom,
-    PALETTE_AREA: 'palette',
-    COMPOSER_AREAS: { middleware: 'middleware' },
-    document: { getElementById: () => null, createElement: () => ({}), head: { appendChild: () => undefined } },
-    host: { state }
-  }
-  const source = pluginSource
-    .replace(/^import\s+\*\s+as\s+sdk\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^import\s+\{[\s\S]*?\}\s+from '@hermes\/plugin-sdk'\r?\n/m, '')
-    .replace(/^const \{ McpTab, ToolsetConfigPanel \} = sdk\r?\n/m, '')
-    .replace(/^import .* from 'react'\r?\n/m, '')
-    .replace(/^import .* from 'react\/jsx-runtime'\r?\n/m, '')
-    .replace('export default {', 'globalThis.plugin = {')
-    .concat(`
-      globalThis.__api = {
-        bindProfileSync,
-        resolveRoutineOwner: typeof resolveRoutineOwner === 'function' ? resolveRoutineOwner : undefined,
-        $selectedBot
-      };
-    `)
-  vm.runInNewContext(source, context, { filename: 'plugin.js' })
-  return context
-}
-
-// Mimic real nanostores atom semantics (get + non-replaying listen) — not a
-// mock that assumes the fix — so this fails honestly if bindProfileSync
-// regresses to a plain, non-reseeding listen().
-function fakeProfileStore(initial) {
-  let value = initial
-  const listeners = new Set()
-  return {
-    get: () => value,
-    set: next => {
-      value = next
-      for (const listener of listeners) listener(value)
-    },
-    listen: listener => {
-      listeners.add(listener)
-      return () => listeners.delete(listener)
-    }
-  }
-}
-
-test('regression: re-enabling after a profile switch while disabled resyncs, not stays stale', () => {
-  const { bindProfileSync, $selectedBot } = load().__api
-  const profile = fakeProfileStore('blog-writer')
-
-  const unbind1 = bindProfileSync(profile)
-  assert.equal($selectedBot.get(), 'blog-writer', 'reseeded to the live profile on first bind')
-
-  unbind1() // plugin disabled: listener torn down
-  profile.set('researcher') // profile changes while nothing is listening
-
-  bindProfileSync(profile) // plugin re-enabled: register() runs again
-  assert.equal($selectedBot.get(), 'researcher', 'reseeded to the live profile on re-bind, not left stale')
-})
-
-test('unit: bindProfileSync keeps forwarding live profile changes after (re)binding', () => {
-  const { bindProfileSync, $selectedBot } = load().__api
-  const profile = fakeProfileStore('default')
-
-  bindProfileSync(profile)
-  profile.set('researcher')
-  assert.equal($selectedBot.get(), 'researcher', 'live changes still flow through the listener')
-})
-
-test('unit: bindProfileSync follows connection changes for the same profile name', () => {
-  const { bindProfileSync, $selectedBot } = load().__api
-  const owner = fakeProfileStore({ connectionId: 'source-a', profile: 'default' })
-
-  bindProfileSync(owner)
-  assert.equal($selectedBot.get(), 'source-a::default')
-
-  owner.set({ connectionId: 'source-b', profile: 'default' })
-  assert.equal($selectedBot.get(), 'source-b::default')
-})
-
-test('unit: an empty/non-string current value is not seeded into $selectedBot', () => {
-  const { bindProfileSync, $selectedBot } = load().__api
-  const before = $selectedBot.get()
-  bindProfileSync(fakeProfileStore(''))
-  assert.equal($selectedBot.get(), before, 'falsy current value leaves $selectedBot untouched')
-})
-
-test('unit: an authoritative focused owner missing from the roster fails closed', () => {
-  const { resolveRoutineOwner } = load().__api
-  const roster = [{
-    connectionId: 'source-a',
-    name: 'default',
-    remoteSource: true,
-    sourceScoped: true
-  }]
-  const focusedOwner = {
-    authoritative: true,
-    connectionId: 'source-b',
-    name: 'worker'
-  }
-
-  assert.equal(resolveRoutineOwner(roster, focusedOwner, 'source-a::default'), null)
-})
-
-test('regression #94516: a null focused owner falls back to the roster-clicked bot', () => {
-  // The focused session has no bot owner (a normal chat, or ambiguous owner
-  // hints — the SDK fails closed to null), but the user just clicked a bot in
-  // the populated roster. The Routines pane must scope to THAT bot instead of
-  // pinning every agent on the unavailable placeholder (#94516).
-  const { resolveRoutineOwner } = load({ focusedSessionOwnerSupported: true }).__api
-  const roster = [
-    { connectionId: 'source-a', name: 'default', remoteSource: true, sourceScoped: true },
-    { connectionId: 'source-a', name: 'blog-writer', remoteSource: true, sourceScoped: true }
-  ]
-
-  assert.equal(resolveRoutineOwner(roster, null, 'source-a::blog-writer'), roster[1])
-})
-
-test('regression #94516: a null focused owner with no matching selection still fails closed', () => {
-  // No focused owner AND the selection has no roster row: there is nothing to
-  // scope cron reads/mutations to, so the pane keeps its fail-closed state.
-  const { resolveRoutineOwner } = load({ focusedSessionOwnerSupported: true }).__api
-  const roster = [
-    { connectionId: 'source-a', name: 'default', remoteSource: true, sourceScoped: true }
-  ]
-
-  assert.equal(resolveRoutineOwner(roster, null, 'source-a::missing'), null)
-})
-
-test('unit: a legacy SDK without focused owner support may use selection', () => {
-  const { resolveRoutineOwner } = load().__api
-  const roster = [{
-    connectionId: 'source-a',
-    name: 'default',
-    remoteSource: true,
-    sourceScoped: true
-  }]
-
-  assert.equal(resolveRoutineOwner(roster, null, 'source-a::default'), roster[0])
-})
-
-test('unit: register() wires the focused-owner ladder through bindProfileSync', () => {
-  assert.match(
-    pluginSource,
-    /const unbindProfileListener = bindProfileSync\(\$focusedBotOwner\)/,
-    'the reseeding helper must own the connection-qualified focused owner subscription'
-  )
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/single-flight.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/single-flight.test.mjs
deleted file mode 100644
index 05cc64ea2e05..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/single-flight.test.mjs
+++ /dev/null
@@ -1,61 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const pluginSource = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadSingleFlight() {
-  const start = pluginSource.indexOf('function singleFlight(')
-  const end = pluginSource.indexOf('/** The agent-to-agent messaging protocol', start)
-  assert.notEqual(start, -1, 'plugin exports the single-flight helper source')
-  assert.notEqual(end, -1, 'single-flight helper has a stable source boundary')
-  const context = {}
-  vm.runInNewContext(`${pluginSource.slice(start, end)}\nglobalThis.singleFlight = singleFlight`, context)
-  return context.singleFlight
-}
-
-test('concurrent callers share one in-flight profile creation', async () => {
-  const singleFlight = loadSingleFlight()
-  const ref = { current: null }
-  let calls = 0
-  let release
-  const pending = new Promise(resolve => {
-    release = resolve
-  })
-  const create = async () => {
-    calls += 1
-    await pending
-    return 'researcher'
-  }
-
-  const first = singleFlight(ref, create)
-  const second = singleFlight(ref, create)
-
-  assert.equal(calls, 1)
-  assert.equal(first, second)
-  release()
-  assert.equal(await first, 'researcher')
-  assert.equal(ref.current, first)
-})
-
-test('a failed creation clears the flight so retry can succeed', async () => {
-  const singleFlight = loadSingleFlight()
-  const ref = { current: null }
-  let calls = 0
-
-  await assert.rejects(
-    singleFlight(ref, async () => {
-      calls += 1
-      throw new Error('gateway unavailable')
-    }),
-    /gateway unavailable/
-  )
-
-  assert.equal(ref.current, null)
-  assert.equal(await singleFlight(ref, async () => {
-    calls += 1
-    return 'researcher'
-  }), 'researcher')
-  assert.equal(calls, 2)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/soul-protocol-backfill.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/soul-protocol-backfill.test.mjs
deleted file mode 100644
index ef6688648c3e..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/soul-protocol-backfill.test.mjs
+++ /dev/null
@@ -1,145 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadSoulHelpers({ serverInjects = false } = {}) {
-  const start = source.indexOf('function botHandle(name')
-  const end = source.indexOf('// ── human-readable row helpers', start)
-  assert.notEqual(start, -1, 'botHandle is missing')
-  assert.notEqual(end, -1, 'soul-helper section delimiter is missing')
-  const context = { serverInjectsProtocol: serverInjects }
-  vm.runInNewContext(
-    `${source.slice(start, end)}\nObject.assign(globalThis, { botHandle, hasMessagingProtocol, ensureMessagingProtocol, composeSoul, messagingProtocolSection })`,
-    context
-  )
-  return context
-}
-
-const EXISTING_SOUL = `# Main agent
-
-I am the default profile on this machine.
-
-## Notes
-- Execute directly.
-`
-
-test('generated protocol uses hermes profile list, not the invalid profiles plural', () => {
-  assert.match(source, /run `hermes profile list` for the LIVE/)
-  assert.doesNotMatch(source, /run `hermes profiles list` for the LIVE/)
-})
-
-test('pre-existing custom SOUL is detected as missing the protocol', () => {
-  const { hasMessagingProtocol } = loadSoulHelpers()
-  assert.equal(hasMessagingProtocol(EXISTING_SOUL), false)
-  assert.equal(hasMessagingProtocol(''), false)
-  assert.equal(hasMessagingProtocol('# Bot\n\n## Messaging other agents\n\nYou work alongside'), true)
-})
-
-test('ensureMessagingProtocol appends once and does not duplicate', () => {
-  const { ensureMessagingProtocol, hasMessagingProtocol } = loadSoulHelpers()
-  const roster = [
-    { name: 'default', description: 'main agent' },
-    { name: 'researcher', description: 'research specialist' }
-  ]
-  const once = ensureMessagingProtocol(EXISTING_SOUL, 'default', roster)
-  assert.equal(hasMessagingProtocol(once), true)
-  assert.match(once, /I am the default profile on this machine/)
-  assert.match(once, /`researcher` — research specialist/)
-  assert.match(once, /@hermes/)
-  assert.doesNotMatch(once, /@default/)
-
-  const twice = ensureMessagingProtocol(once, 'default', roster)
-  assert.equal(twice, once.trim())
-  assert.equal(twice.split('## Messaging other agents').length, 2)
-})
-
-test('composeSoul does not double-append when custom SOUL already has the protocol', () => {
-  const { composeSoul } = loadSoulHelpers()
-  const roster = [{ name: 'researcher' }, { name: 'default' }]
-  const withProtocol = composeSoul({
-    name: 'researcher',
-    title: 'Researcher',
-    description: 'literature review',
-    roster,
-    customSoul: ''
-  })
-  const cloned = composeSoul({
-    name: 'researcher',
-    roster,
-    customSoul: withProtocol
-  })
-  assert.equal(cloned.split('## Messaging other agents').length, 2)
-})
-
-test('backfill is one-shot: describe-only when protocol exists, configure when missing', async () => {
-  const start = source.indexOf('const soulProtocolChecked = new Set()')
-  const end = source.indexOf('/** SOUL.md for a new bot:', start)
-  assert.notEqual(start, -1)
-  assert.notEqual(end, -1)
-
-  const calls = []
-  const context = {
-    serverInjectsProtocol: false,
-    soulProtocolChecked: new Set(),
-    soulProtocolInflight: new Set(),
-    hasMessagingProtocol: soul => /## Messaging other agents/.test(soul || ''),
-    ensureMessagingProtocol: soul => `${soul}\n\n## Messaging other agents\n`,
-    host: {
-      request: async (method, payload) => {
-        calls.push({ method, payload })
-        if (method === 'profiles.describe') {
-          if (payload.name === 'researcher') return { soul: '# Researcher\n\n## Messaging other agents\n' }
-          return { soul: EXISTING_SOUL }
-        }
-        return { ok: true }
-      }
-    }
-  }
-
-  vm.runInNewContext(
-    `${source.slice(start, end)}\nbackfillMessagingProtocol(roster)`,
-    { ...context, roster: [{ name: 'default' }, { name: 'researcher' }] }
-  )
-
-  await new Promise(resolve => setTimeout(resolve, 0))
-  await new Promise(resolve => setTimeout(resolve, 0))
-
-  const describes = calls.filter(c => c.method === 'profiles.describe').map(c => c.payload.name)
-  const configures = calls.filter(c => c.method === 'profiles.configure')
-  assert.deepEqual(describes.sort(), ['default', 'researcher'])
-  assert.equal(configures.length, 1)
-  assert.equal(configures[0].payload.name, 'default')
-  assert.match(configures[0].payload.soul, /## Messaging other agents/)
-})
-
-test('backend bot_mode_protocol capability suppresses every SOUL protocol write', async () => {
-  // ensureMessagingProtocol becomes identity — custom SOULs stay untouched.
-  const helpers = loadSoulHelpers({ serverInjects: true })
-  assert.equal(helpers.ensureMessagingProtocol(EXISTING_SOUL, 'default', []), EXISTING_SOUL.trim())
-
-  // backfill never issues a single RPC.
-  const start = source.indexOf('const soulProtocolChecked = new Set()')
-  const end = source.indexOf('/** SOUL.md for a new bot:', start)
-  const calls = []
-  vm.runInNewContext(
-    `${source.slice(start, end)}\nbackfillMessagingProtocol(roster)`,
-    {
-      serverInjectsProtocol: true,
-      soulProtocolChecked: new Set(),
-      soulProtocolInflight: new Set(),
-      hasMessagingProtocol: () => false,
-      ensureMessagingProtocol: soul => soul,
-      host: { request: async (method, payload) => (calls.push({ method, payload }), { ok: true }) },
-      roster: [{ name: 'default' }, { name: 'researcher' }]
-    }
-  )
-  await new Promise(resolve => setTimeout(resolve, 0))
-  assert.equal(calls.length, 0)
-
-  // composeSoul's generated-identity path also skips the section.
-  const generated = helpers.composeSoul({ name: 'newbot', title: 'T', description: 'D', roster: [], customSoul: '' })
-  assert.doesNotMatch(generated, /## Messaging other agents/)
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/tests/unaddressed-mentions.test.mjs b/apps/desktop/src/plugins/hermes-bots/tests/unaddressed-mentions.test.mjs
deleted file mode 100644
index 3e8e40f4fb27..000000000000
--- a/apps/desktop/src/plugins/hermes-bots/tests/unaddressed-mentions.test.mjs
+++ /dev/null
@@ -1,65 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-import vm from 'node:vm'
-
-// #94478 review: exercise the REAL unaddressedGroupMentions from plugin.js
-// via the same vm-slice pattern as active-now-strip.test.mjs, plus pin the
-// log-index ordering fix (entry ids are UUIDs, NOT monotonic).
-
-const source = readFileSync(new URL('../plugin.js', import.meta.url), 'utf8')
-
-function loadUnaddressed(roomLog) {
-  const start = source.indexOf('function unaddressedGroupMentions')
-  const end = source.indexOf('/** Drive one bounded round-robin turn for ONE THREAD.')
-
-  assert.ok(start >= 0 && end > start, 'unaddressedGroupMentions block must remain extractable')
-
-  const members = [{ name: 'alpha' }, { name: 'beta' }, { name: 'gamma' }]
-  const sandbox = {
-    $groupChats: {
-      // The production code indexes rooms by name; expose the room under
-      // both shapes so either access style resolves.
-      get: k => ({ log: roomLog, [k ?? 'g']: { log: roomLog } }),
-    },
-    groupThreadOf: e => e.thread,
-    parseGroupChatMentions: (text, ms) => ({
-      mentioned: [...new Set(ms.filter(m => text.includes(`@${m.name}`)).map(m => m.name))],
-      everyone: false,
-    }),
-    groupMemberKey: m => m.name,
-    members,
-    out: null,
-  }
-  vm.createContext(sandbox)
-  vm.runInContext(`${source.slice(start, end)}\nout = unaddressedGroupMentions('g', members, 't1')`, sandbox)
-  return sandbox.out
-}
-
-function entry(id, from, text, thread = 't1') {
-  return { id, at: 0, from: { kind: 'member', name: from }, text, thread }
-}
-
-test('unaddressedGroupMentions flags a cited member with no later post', () => {
-  const pending = loadUnaddressed([
-    entry('zzzz-0002', 'alpha', 'hello'),
-    entry('aaaa-0003', 'beta', 'ping @gamma — take this'),
-  ])
-  assert.equal(JSON.stringify(pending), JSON.stringify(['gamma']))
-})
-
-test('a reply AFTER the citation in log order counts as answered even when its id sorts lower', () => {
-  const pending = loadUnaddressed([
-    entry('aaaa-0003', 'beta', 'ping @gamma — take this'),
-    entry('9999-0004', 'gamma', 'on it'),
-  ])
-  assert.equal(JSON.stringify(pending), JSON.stringify([]))
-})
-
-test('self-citations and user entries never create pending handoffs', () => {
-  const pending = loadUnaddressed([
-    entry('bbbb-0001', 'alpha', 'I will do @alpha things myself'),
-    { id: 'cccc-0002', at: 0, from: { kind: 'user', name: 'You' }, text: '@beta @gamma look here', thread: 't1' },
-  ])
-  assert.equal(JSON.stringify(pending), JSON.stringify([]))
-})
diff --git a/apps/desktop/src/plugins/hermes-bots/types.ts b/apps/desktop/src/plugins/hermes-bots/types.ts
new file mode 100644
index 000000000000..e21298f544b2
--- /dev/null
+++ b/apps/desktop/src/plugins/hermes-bots/types.ts
@@ -0,0 +1,298 @@
+/**
+ * Bot Mode domain model.
+ *
+ * Derived from how the gateway's payloads are actually consumed, not from a
+ * published schema — so almost everything is optional. A roster row can arrive
+ * three ways (a rich `profiles.list` row from the active gateway, a thin
+ * `host.agents()` union row from another registered connection, or an offline
+ * "ghost" twin), and older gateways omit whole fields. Widening a field to
+ * required is a claim that every one of those paths supplies it.
+ */
+
+/**
+ * The compact age suffixes the sidebar's session rows render ("now", "m", "h",
+ * "d"). Structural rather than an import of core's `Translations`, which the
+ * plugin fence puts out of reach — `t.sidebar.row` satisfies it.
+ */
+export interface SidebarRowLabels {
+  ageDay: string
+  ageHour: string
+  ageMin: string
+  ageNow: string
+}
+
+/** Where a row came from when several connections contribute to one roster. */
+export interface ProfileRoute {
+  connectionId: string
+  mode: 'local' | 'remote'
+  profile: string
+  targetProfile: string
+}
+
+/**
+ * A bot's one canonical forever-chat: the profile's session titled exactly
+ * "Bot Chat". Resolved server-side by title and reported on every roster row —
+ * there is deliberately no stored session-id pointer (see AGENTS.md).
+ */
+export interface CanonicalSession {
+  /** Durable id, stable across reloads. */
+  id?: string
+  /** Compression-lineage tip — the live session a durable id currently maps to. */
+  resolved_id?: string
+  last_active?: number
+  preview?: string
+  root_title?: string
+  title?: string
+}
+
+export interface SessionPreview {
+  /** Unix seconds, not milliseconds. */
+  last_active?: number
+  preview?: string
+}
+
+/** Per-bot presentation state, persisted in the profile's `ui_meta`. */
+export interface BotMeta {
+  color?: string
+  /** Set when the user has customized the avatar, so defaults stop applying. */
+  custom?: boolean
+  description?: string
+  groups?: string[]
+  hidden?: boolean
+  /** Data URL. Stripped before `profiles.configure`; travels via `set_asset`. */
+  image?: null | string
+  imageKind?: 'photo' | 'shape'
+  /** Legacy single-group scalar, projected alongside `groups`. */
+  group?: null | string
+  pinned?: boolean
+  shape?: string
+  title?: string
+  /** Creation timestamp in ms. Deliberately not copied when duplicating a bot. */
+  created?: number
+}
+
+export interface RosterRow {
+  name: string
+  canonical_session?: CanonicalSession | null
+  connectionId?: string
+  connectionKind?: string
+  connectionLabel?: string
+  description?: string
+  display_name?: string
+  /** An offline twin of a selected bot, kept visible so the row doesn't vanish. */
+  ghost?: boolean
+  handle?: string
+  has_avatar?: boolean
+  last_session?: SessionPreview | null
+  remoteSource?: boolean
+  route?: ProfileRoute
+  sourceError?: null | string
+  sourceMissing?: boolean
+  sourceReachable?: boolean | null
+  sourceScoped?: boolean
+  targetProfile?: string
+  /** Nullable: the gateway sends `null` for a profile with no configured role,
+   *  and the create form threads its own optional title through the same shape. */
+  title?: null | string
+  ui_meta?: Record<string, unknown> & { 'hermes-bots'?: BotMeta }
+  /** Compare-and-swap revisions, per ui_meta key. */
+  ui_meta_revisions?: Record<string, number>
+  worker_session?: { last_active?: number } | null
+}
+
+/** A roster row reduced to what a group room needs to seat a member. */
+export type GroupMember = Pick<
+  RosterRow,
+  | 'connectionId'
+  | 'connectionKind'
+  | 'connectionLabel'
+  | 'display_name'
+  | 'ghost'
+  | 'handle'
+  | 'name'
+  | 'remoteSource'
+  | 'route'
+  | 'sourceMissing'
+  | 'sourceReachable'
+  | 'sourceScoped'
+  | 'targetProfile'
+  | 'title'
+>
+
+export type AttachmentKind = 'file' | 'image' | 'pdf'
+
+export interface Attachment {
+  /** Data URL. */
+  data: string
+  kind: AttachmentKind
+  name: string
+}
+
+export interface GroupMessageAuthor {
+  kind: 'member' | 'user'
+  name: string
+  /** Connection label, present when the speaker lives on another machine. */
+  source?: string
+}
+
+export interface GroupMessage {
+  /** Milliseconds. */
+  at: number
+  from: GroupMessageAuthor
+  id?: string
+  images?: Attachment[]
+  text: string
+  /** Messages predating threading carry the sentinel thread `'legacy'`. */
+  thread?: string
+}
+
+export interface GroupHold {
+  at?: number
+  noted?: boolean
+}
+
+export interface GroupChat {
+  /** Bumped to abandon in-flight member turns from a previous round. */
+  epoch?: number
+  holds?: Record<string, GroupHold>
+  image?: null | string
+  log: GroupMessage[]
+  members?: GroupMember[]
+  /** Immutable identity, so a rename doesn't fork the room. */
+  roomId?: null | string
+  running?: boolean
+  /** The immutable owner descriptor captured beside each plumbing session,
+   *  keyed the same way as `sessions`. Partial: legacy records hold a bare
+   *  `{ name }`, and the sweep re-validates the route before trusting one. */
+  sessionOwners?: Record<string, Partial<RosterRow>>
+  sessions?: Record<string, string | true>
+  stranded?: Record<string, number | { before: number; thread?: string }>
+  syncRevision?: number
+  /** Left behind when a room is disbanded, so sync can't resurrect it. */
+  tombstone?: boolean
+  /** Read when ordering rooms; no write site in the plugin today. */
+  pinned?: boolean
+  /** How far each `<thread>::<member>` has read into `log`. Required: unlike
+   *  the gateway-sourced shapes above, a room record is plugin-owned — every
+   *  writer (hydrate, server-sync merge, updateGroupChat, room reset) seeds
+   *  the map, and the turn engine indexes it unguarded. */
+  watermarks: Record<string, number>
+}
+
+export type GroupPromptKind = 'approval' | 'clarify'
+
+/**
+ * One sub-question of a batch clarify, straight off the wire. `choices` and
+ * `question` stay unknown because the card re-validates them; the two id
+ * spellings are the keys it maps drafts and answers by.
+ */
+export interface GroupPromptQuestion {
+  choices?: unknown
+  id?: string
+  multi_select?: boolean
+  multiSelect?: boolean
+  qid?: string
+  question?: unknown
+}
+
+export interface GroupPrompt {
+  at: number
+  choices: string[]
+  command?: string
+  group: string
+  kind: GroupPromptKind
+  member: string
+  memberKey: string
+  multiSelect: boolean
+  question: string
+  questions?: GroupPromptQuestion[] | null
+  requestId: string
+  sessionId?: null | string
+}
+
+export type GroupActivityKind =
+  | 'cancelled'
+  | 'capped'
+  | 'delivered'
+  | 'failed'
+  | 'held'
+  | 'passed'
+  | 'queued'
+  | 'replied'
+  | 'settled'
+  | 'stopped'
+  | 'timed-out'
+  | 'working'
+
+export interface GroupActivityEvent {
+  at: number
+  group: string
+  kind: GroupActivityKind
+  member?: string
+  preview?: string
+}
+
+/**
+ * A cron job as Bot Mode reads it. Deliberately NOT the core `CronJob` type:
+ * the gateway's `cron.manage` payload keys the id as `job_id`, carries the
+ * schedule as a plain string rather than a structured object, and splits the
+ * error into three separate fields. Reusing the core interface here would
+ * typecheck against fields that never arrive.
+ */
+export interface RoutineJob {
+  deliver?: string
+  enabled?: boolean
+  job_id: string
+  last_delivery_error?: string
+  last_fire_error?: string
+  last_run_at?: string
+  last_status?: string
+  model?: string
+  /** Prefixed `[bot:<slug>]` so the job can be scoped back to its bot. */
+  name?: string
+  next_run_at?: string
+  paused_reason?: string
+  prompt?: string
+  prompt_preview?: string
+  repeat?: number | string
+  schedule?: string
+  state?: string
+  workdir?: string
+}
+
+export interface ConnectionRow {
+  id: string
+  label?: string
+  primary?: boolean
+}
+
+export interface GatewaySource {
+  connectionId: string
+  count?: number
+  error?: null | string
+  kind?: string
+  label?: string
+  reachable?: boolean
+}
+
+export type AvatarShape = 'circle' | 'cloud' | 'drop' | 'hexagon' | 'pill' | 'squircle' | 'triangle'
+
+export type BlobKind =
+  'boxy' | 'capsule' | 'cloud' | 'droplet' | 'hexagon' | 'nub' | 'organic' | 'round' | 'sun' | 'triangle'
+
+export type FaceMood = 'idle' | 'work'
+
+export interface AvatarAppearance {
+  /** `null` when nothing is picked — the name's deterministic hue stands in.
+   *  `profileColor` returns null for the unnamed/default profile, so this has
+   *  always been nullable in practice; `avatarColor` is what resolves it. */
+  color: null | string
+  image: null | string
+  /** Free-form: a bare shape, `sigil-<n>`, a platonic solid, or `blobatar:<seed>:<kind>`. */
+  shape: string
+}
+
+export type AttentionClass = 'agent_blocked' | 'missing_config' | 'provider_auth_or_access' | 'provider_quota_limit'
+
+export type RosterKindFilter = 'all' | 'bots' | 'groups'
+export type RosterActivityFilter = 'active' | 'all' | 'older' | 'recent'
diff --git a/apps/desktop/src/sdk/index.test.ts b/apps/desktop/src/sdk/index.test.ts
index a279f3cd00ed..865a585c6e85 100644
--- a/apps/desktop/src/sdk/index.test.ts
+++ b/apps/desktop/src/sdk/index.test.ts
@@ -182,7 +182,7 @@ describe('host workspace scope', () => {
     tree.removeTreePane('plugin-workspace:scope-test')
   })
 
-  it('registers plugin workspace ownership and chrome options', async () => {
+  it('registers plugin workspace chrome options', async () => {
     const { registry } = await import('@/contrib/registry')
 
     const close = host.openWorkspace('scope-test', {
@@ -190,9 +190,7 @@ describe('host workspace scope', () => {
       headerVeto: true,
       render: () => null,
       title: 'Scoped',
-      uncloseable: true,
-      workspaceMode: 'bots',
-      workspaceOwnerKey: 'connection-a::default'
+      uncloseable: true
     })
 
     expect(registry.getArea('panes').find(pane => pane.id === 'plugin-workspace:scope-test')).toMatchObject({
@@ -200,9 +198,7 @@ describe('host workspace scope', () => {
         dock: { pane: 'workspace', pos: 'right' },
         headerVeto: true,
         uncloseable: true
-      },
-      workspaceMode: 'bots',
-      workspaceOwnerKey: 'connection-a::default'
+      }
     })
 
     close()
diff --git a/apps/desktop/src/sdk/index.ts b/apps/desktop/src/sdk/index.ts
index 1f1725462258..ac05825fc723 100644
--- a/apps/desktop/src/sdk/index.ts
+++ b/apps/desktop/src/sdk/index.ts
@@ -783,9 +783,11 @@ export const host = {
   },
 
   /** Pre-dial an agent's socket on ITS source — the (connection, profile)
-   *  analogue of warmProfile. Fire-and-forget, same semantics. */
-  warmAgent: (connectionId: null | string, profile: string): void => {
-    void openGatewayForAgent(connectionId, (profile ?? '').trim() || 'default').catch(() => undefined)
+   *  analogue of warmProfile. Fire-and-forget, same semantics.
+   *  `undefined` is accepted alongside `null` because a roster row's
+   *  `connectionId` is optional; both mean "no explicit source". */
+  warmAgent: (connectionId: null | string | undefined, profile: string): void => {
+    void openGatewayForAgent(connectionId ?? null, (profile ?? '').trim() || 'default').catch(() => undefined)
   },
 
   /** Activate an agent's gateway (dialing it if needed) so subsequent
@@ -794,8 +796,8 @@ export const host = {
    *  and rapid switches can't land out of order. The local source falls
    *  through to the profile path — single-source plugins keep working
    *  against older behavior unchanged. */
-  ensureAgent: async (connectionId: null | string, profile: string): Promise<void> =>
-    ensureGatewayAgent(connectionId, (profile ?? '').trim() || 'default'),
+  ensureAgent: async (connectionId: null | string | undefined, profile: string): Promise<void> =>
+    ensureGatewayAgent(connectionId ?? null, (profile ?? '').trim() || 'default'),
 
   /** Open a stored session the way core surfaces do. A plugin/Bot Mode open
    *  is navigation, not a workspace or chrome API-home switch —
@@ -1108,8 +1110,6 @@ export const host = {
       render: () => ReactNode
       title?: string
       uncloseable?: boolean
-      workspaceMode?: WorkspaceMode
-      workspaceOwnerKey?: string
     }
   ): (() => void) => {
     const key = (id ?? '').trim()
@@ -1133,9 +1133,7 @@ export const host = {
       },
       id: paneId,
       render: options.render,
-      title: options.title ?? key,
-      workspaceMode: options.workspaceMode,
-      workspaceOwnerKey: options.workspaceOwnerKey
+      title: options.title ?? key
     })
 
     const close = () => {
@@ -1383,8 +1381,53 @@ export {
 
 // -- ui: the design language --------------------------------------------------
 
+/** THE session status dot — the one primitive the sidebar row, the pane tabs
+ *  and the session switcher render, so a session's status can never disagree
+ *  between surfaces. Pass the STORED session id and it resolves the rest
+ *  itself: the live state (needs-input / working / stalled / background /
+ *  unread / draft / idle) and the project color. Never hand-roll a status
+ *  circle beside it — a plugin's own dot inverts core's color vocabulary the
+ *  moment either side moves. */
+export { SessionStatusDot, type SessionStatusDotProps } from '@/app/chat/session-status-dot'
+/** The sidebar row's leading cell — the fixed box a dot, icon or handle sits in.
+ *  Reserve it and your label starts on the same left edge as every session row
+ *  above you; spell the classes yourself and the row drifts. The session row is
+ *  canonical; `row-geometry.ts` explains what each measurement belongs to. */
+export { SidebarRowLead } from '@/app/chat/sidebar/chrome'
+/** One glyph per gateway kind — device, cloud, terminal, network. The statusbar
+ *  switcher, the fleet profile rail and any plugin rail listing gateways share
+ *  it, so a connection looks the same wherever it is named. */
+export { ConnectionGlyph } from '@/app/chat/sidebar/connection-glyph'
+export { SIDEBAR_ROW_LEAD, SIDEBAR_TRUNCATED_LEADING } from '@/app/chat/sidebar/row-geometry'
 export { PALETTE_AREA, type PaletteContribution } from '@/app/command-palette/contrib'
+/** THE master-detail toolkit core uses for list+inspector surfaces (Scheduled
+ *  jobs, Kanban, …): a dense left `PanelList` of `PanelListRow`s beside a
+ *  scrolling `PanelDetail` of `PanelSectionLabel` / `PanelMeta` / `PanelBlock`.
+ *  `PanelEmpty` is the icon+action empty state (plain `EmptyState` is title +
+ *  description only, and silently drops an `icon`). A row takes a custom `lead`
+ *  (avatar/swatch), trailing `meta`, and `menuItems` for kebab + right-click
+ *  parity, so a roster needs no hand-rolled row. The overlay-bound `Panel` root
+ *  is deliberately NOT exported — these compose inside a pane just as well. */
+export {
+  PanelAction,
+  PanelAddButton,
+  PanelBlock,
+  PanelBody,
+  PanelDetail,
+  PanelEmpty,
+  PanelHeader,
+  PanelList,
+  PanelListRow,
+  type PanelMenuItem,
+  PanelMeta,
+  type PanelMetaRow,
+  PanelPill,
+  type PanelPillTone,
+  PanelRowMenu,
+  PanelSectionLabel
+} from '@/app/overlays/panel'
 export { type RouteContribution, ROUTES_AREA, SIDEBAR_NAV_AREA, type SidebarNavContribution } from '@/app/routes'
+
 /** THE full per-toolset config panel core Settings renders — provider picker,
  *  env vars / API keys, model catalog picker, and post-setup runners. Route-
  *  decoupled (the "manage keys" deep link is a no-op outside the router); pass
@@ -1404,7 +1447,6 @@ export {
 } from '@/app/shell/model-catalog-menu'
 export type { StatusbarItem } from '@/app/shell/statusbar-controls'
 export type { TitlebarTool } from '@/app/shell/titlebar-controls'
-
 /** THE whole Capabilities surface (Skills / Tools / MCP tabs, installed
  *  lists, full-skill detail pane, embedded hub picker with one-click
  *  installs). For plugin dialogs pass `embedded` (tab state stays local —
@@ -1420,6 +1462,9 @@ export { SkillsView } from '@/app/skills'
  *  renders anywhere (a plugin dialog); pass a live `gateway` (see
  *  `host.getGateway()`) and an optional `profile` to scope it to one bot. */
 export { McpTab } from '@/app/skills/mcp-tab'
+/** The oversized Collapse lettering an empty chat is titled with — core writes
+ *  "HERMES AGENT" with it, a `chat.empty` contribution writes its own name. */
+export { Wordmark } from '@/components/chat/wordmark'
 /** Pane placement roles. `'floating'` is the one NON-tiling value: the pane is
  *  excluded from the layout tree and rendered as a fixed, draggable card above
  *  it — it takes no width from any zone, has no tab, and can't be docked.
@@ -1431,6 +1476,11 @@ export { Badge } from '@/components/ui/badge'
 export { Button } from '@/components/ui/button'
 export { Checkbox } from '@/components/ui/checkbox'
 export { Codicon } from '@/components/ui/codicon'
+/** THE color picker — swatch grid plus a clear row that means "back to the
+ *  deterministic color". Feed it `PROFILE_SWATCHES` so a hand-picked color
+ *  shares the generated palette's saturation and lightness; a bespoke grid of
+ *  literal hex drifts off-theme the moment the palette moves. */
+export { ColorSwatches } from '@/components/ui/color-swatches'
 export { ConfirmDialog } from '@/components/ui/confirm-dialog'
 export {
   ContextMenu,
@@ -1450,6 +1500,10 @@ export {
   DialogTitle,
   DialogTrigger
 } from '@/components/ui/dialog'
+/** The caret every collapsible section in core uses — points right when closed
+ *  and rotates down when open, so the motion matches the rest of the app. Swap
+ *  a hand-written `chevron-down`/`chevron-right` ternary for this. */
+export { DisclosureCaret } from '@/components/ui/disclosure-caret'
 export {
   DropdownMenu,
   DropdownMenuContent,
@@ -1468,6 +1522,10 @@ export { Kbd, KbdGroup } from '@/components/ui/kbd'
 export { Loader, type LoaderType } from '@/components/ui/loader'
 export { LogView } from '@/components/ui/log-view'
 export { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
+/** Full-row / region click target. Imposes NO styling — the caller keeps its own
+ *  layout classes — it just bakes in `type="button"` and a stable `data-slot`.
+ *  Use it for rows and regions; `Button` is for ordinary compact actions. */
+export { RowButton } from '@/components/ui/row-button'
 export { ScrollArea } from '@/components/ui/scroll-area'
 export { SearchField } from '@/components/ui/search-field'
 export { SegmentedControl } from '@/components/ui/segmented-control'
@@ -1507,7 +1565,11 @@ export type { HermesGateway } from '@/hermes'
 export { type GrabScroll, useGrabScroll } from '@/hooks/use-grab-scroll'
 /** Localized copy. `useI18n` reuses the app's strings; `usePluginI18n(id)` +
  *  `ctx.i18n.register` let a plugin ship its OWN locale bundles, scoped like
- *  `ctx.storage` and resolved against the app's active locale — no core edit. */
+ *  `ctx.storage` and resolved against the app's active locale — no core edit.
+ *  `translateNow` is the one-shot form for the places a hook can't reach —
+ *  notably a `ctx.register` pane `title`, which is read at registration time
+ *  and is why plugin pane titles otherwise strand as hardcoded English. It
+ *  samples the locale at call time, so React should still use the hooks. */
 export {
   type Locale,
   type PluginI18n,
@@ -1515,6 +1577,7 @@ export {
   type PluginMessages,
   type PluginMessageValue,
   type PluginTranslate,
+  translateNow,
   useI18n,
   usePluginI18n
 } from '@/i18n'
@@ -1523,6 +1586,9 @@ export {
  *  Plugins must route animation clocks through this instead of raw rAF loops
  *  so a disabled plugin or an empty roster costs zero frames. */
 export { type BudgetedLoop, type BudgetedLoopOptions, createBudgetedLoop } from '@/lib/budgeted-loop'
+/** The blank transcript as a contribution area: claim the sessions you own and
+ *  render what stands in the gap. Core's own splash keeps a fresh draft. */
+export { CHAT_EMPTY_AREA, type ChatEmptyContribution, type ChatEmptyProps } from '@/lib/chat-empty'
 /** THE compact-number formatter — every user-facing count/token figure goes
  *  through here (1230 → "1.2k", 1_500_000 → "1.5M"). Don't hand-roll `/1000`. */
 export { compactNumber } from '@/lib/format'
@@ -1542,14 +1608,23 @@ export type { HermesOpenTarget } from '@/lib/hermes-open-target'
 export * as icons from '@/lib/icons'
 export { type KeybindContribution, KEYBINDS_AREA } from '@/lib/keybinds/actions'
 export { formatModifierToken } from '@/lib/keybinds/combo'
+/** A `Map` with a ceiling, for the module-level caches a plugin keeps across
+ *  a renderer that stays open for days. Only for values that can be
+ *  regenerated — eviction costs a recompute or a refetch, never correctness. */
+export { LruCache } from '@/lib/lru-cache'
 /** The app's deterministic identity color for a name (profiles, assignees,
- *  authors) + its translucent tag fill — so plugin-rendered identities read
- *  the same hue as everywhere else. */
-export { profileColor, profileColorSoft } from '@/lib/profile-color'
+ *  authors), its translucent tag fill, and the curated picker swatches — so
+ *  plugin-rendered identities read the same hue as everywhere else. The
+ *  swatches share the deterministic palette's saturation/lightness, so a
+ *  hand-picked color still sits with the generated ones; reach for them
+ *  instead of literal hex, which can't follow the theme. */
+export { PROFILE_SWATCHES, profileColor, profileColorSoft } from '@/lib/profile-color'
 /** The shared client itself, for invalidation OUTSIDE React (e.g. a
  *  `ctx.socket` frame invalidating a query). Inside components keep using
  *  `useQueryClient`. */
 export { queryClient } from '@/lib/query-client'
+
+export const PANES_AREA = 'panes'
 /** Hermes' reasoning levels + their compact labels, so a plugin surfacing a
  *  thinking depth uses the same scale and spelling as the rest of the app. */
 export {
@@ -1559,16 +1634,20 @@ export {
   type ReasoningEffort,
   reasoningEffortLabel
 } from '@/lib/reasoning-effort'
+export const STATUSBAR_AREAS = { left: 'statusBar.left', right: 'statusBar.right' } as const
+export const TITLEBAR_AREAS = { center: 'titleBar.center', left: 'titleBar.left', right: 'titleBar.right' } as const
 
-export const PANES_AREA = 'panes'
 /** The app's own gateway-readiness evaluation (setup.status +
  *  setup.runtime_check, reconciled) — pass `host.request`. Don't hand-roll
  *  readiness from raw RPC shapes. */
 export { evaluateRuntimeReadiness, type RuntimeReadinessResult } from '@/lib/runtime-readiness'
-export const STATUSBAR_AREAS = { left: 'statusBar.left', right: 'statusBar.right' } as const
-export const TITLEBAR_AREAS = { center: 'titleBar.center', left: 'titleBar.left', right: 'titleBar.right' } as const
-
-export { coarseElapsed, fmtDateTime, fmtDayTime, relativeTime } from '@/lib/time'
+/** Canonical time formatting — every surface pulls from here so timestamps read
+ *  the same app-wide. For a row's AGE, bucket with `coarseElapsed` and render
+ *  the compact suffixes (`t.sidebar.row.ageMin` → "52m"), which is what the
+ *  session rows beside you do; `formatAgo` is the same buckets with an " ago"
+ *  suffix. `relativeTime` is the bidirectional Intl form ("in 14 hr") — use it
+ *  for a scheduled next-run, not for an age. */
+export { type AgoLabels, coarseElapsed, fmtDateTime, fmtDayTime, formatAgo, relativeTime } from '@/lib/time'
 /** The transcript as a contribution area: register a named `::directive{...}`
  *  and the model can render your component inline in assistant messages. */
 export {
@@ -1577,6 +1656,19 @@ export {
   type TranscriptDirectiveProps
 } from '@/lib/transcript-directives'
 export { cn } from '@/lib/utils'
+/** THE unread store behind `SessionStatusDot`'s emerald dot. A plugin that
+ *  learns out-of-band that a session produced something the user hasn't seen
+ *  (a roster poll's activity watermark, say) writes HERE rather than keeping
+ *  its own unread map — core's dot only paints what this store claims, and a
+ *  parallel map means a second badge that drifts. Works for sessions core
+ *  cannot see: a hidden session is never in the session list, so the backend
+ *  watermark can never claim it, but the transient marker resolves to the id
+ *  you pass. Key every call by the SAME stored id you hand the dot.
+ *  `markSessionUnreadFinished` lights it, `ackStoredSessionId` clears it when
+ *  the user opens the session, `forgetSessionUnread` drops it when the session
+ *  is gone. Pass the owning profile — a hidden session has no row to read it
+ *  from, and the persisted half is bucketed per profile. */
+export { ackStoredSessionId, forgetSessionUnread, markSessionUnreadFinished } from '@/store/session-unread'
 /** Live accent override — set a hex and the ACTIVE theme repaints with its
  *  accent family re-seeded from it (see `retintTheme`); `null` restores the
  *  authored palette. Deliberately not persisted: it is an authoring knob, not
diff --git a/apps/desktop/src/sdk/profile-routing.test.ts b/apps/desktop/src/sdk/profile-routing.test.ts
index 7d457762fa46..07f670b91008 100644
--- a/apps/desktop/src/sdk/profile-routing.test.ts
+++ b/apps/desktop/src/sdk/profile-routing.test.ts
@@ -20,18 +20,27 @@ vi.mock('@/store/system-actions', () => ({ runGatewayRestart: vi.fn() }))
 vi.mock('@/store/session', async () => {
   const { atom } = await import('nanostores')
 
+  type LineageRow = { _lineage_root_id?: null | string; id: string }
+
   return {
     $activeSessionId: atom(null),
     $connection: atom(null),
+    $cronSessions: atom([]),
     $currentCwd: atom(''),
     $currentModel: atom(''),
     $gatewayState: atom('open'),
     $messages: atom([]),
+    $messagingSessions: atom([]),
     $selectedStoredSessionId: atom(null),
     $sessions: atom([]),
+    $unreadFinishedSessionIds: atom([]),
+    lineageAliases: (storedId: string) => [storedId],
     rememberedSessionProfile: (_sessions: unknown, _sessionId: null | string, activeProfile: null | string) =>
       (activeProfile ?? '').trim() || 'default',
     requestSessionResume: vi.fn(),
+    sessionMatchesStoredId: (session: LineageRow, storedSessionId: string) =>
+      session.id === storedSessionId || session._lineage_root_id === storedSessionId,
+    sessionPinId: (session: LineageRow) => session._lineage_root_id ?? session.id,
     setSessionOwnerHint: vi.fn(),
     setResumeExhaustedSessionId: vi.fn()
   }
@@ -40,13 +49,17 @@ vi.mock('@/store/session-states', async () => {
   const { atom } = await import('nanostores')
 
   return {
+    $attentionSessionIds: atom([]),
+    $draftSessionIds: atom([]),
     $focusedRuntimeId: atom(null),
     $focusedSessionState: atom(null),
     $focusedStoredSessionId: atom(null),
     $sessionTiles: atom([]),
     $sessionStates: atom({}),
-    sessionTileDelegate: vi.fn(() => null),
-    dropTilesForProfile: vi.fn()
+    $stalledSessionIds: atom([]),
+    $workingSessionIds: atom([]),
+    dropTilesForProfile: vi.fn(),
+    sessionTileDelegate: vi.fn(() => null)
   }
 })
 vi.mock('@/store/profile', async () => {
@@ -69,6 +82,7 @@ vi.mock('@/store/profile', async () => {
     $gatewaySwapTarget: atom(null),
     $hydrationSyncProfile: atom(null),
     $profiles: profiles,
+    $showAllProfiles: atom(false),
     ensureGatewayAgent: vi.fn(),
     ensureGatewayProfile: vi.fn(),
     newSessionInAgent: vi.fn(),
@@ -85,6 +99,7 @@ vi.mock('@/store/gateway', async () => {
 
   return {
     $gateway: atom(null),
+    activeGateway: vi.fn(() => null),
     activeGatewayConnectionId: vi.fn(() => 'local'),
     ensureGatewayForAgent: vi.fn(),
     openGatewayForAgent: vi.fn(),
diff --git a/apps/desktop/src/store/bot-chat-scope.test.ts b/apps/desktop/src/store/bot-chat-scope.test.ts
new file mode 100644
index 000000000000..9098c2a7427f
--- /dev/null
+++ b/apps/desktop/src/store/bot-chat-scope.test.ts
@@ -0,0 +1,88 @@
+/**
+ * `$botChatSessionIds` is the store a surface must SUBSCRIBE to when it asks
+ * `isBotChatSession`.
+ *
+ * The composer originally subscribed to `$sessionStates` while reading this
+ * set. It looked fine because `$sessionStates` churns constantly — busy flags,
+ * stream ticks — so the stale answer was overwritten within a frame or two.
+ * The assertion that matters is the one that made that wrong: this set moves on
+ * its own, with no `$sessionStates` write anywhere near it, so a subscriber to
+ * the other store can miss the transition entirely.
+ */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+
+const { $botChatSessionIds, $sessionStates, $sessionTiles, isBotChatSession, setSessionTileWorkspaceScope } =
+  await import('./session-states')
+
+const botScope = { workspaceMode: 'bots' as const, workspaceOwnerKey: 'bot:alpha' }
+
+beforeEach(() => {
+  $botChatSessionIds.set(new Set())
+  // isBotChatSession takes a LIVE session id and files the answer under the
+  // stored one, so a binding has to exist for the lookup to resolve at all.
+  $sessionTiles.set([{ runtimeId: 'runtime-1', storedSessionId: 'stored-1' } as never])
+})
+
+describe('the bot-chat set moves independently of session state', () => {
+  it('notifies its own listeners without touching $sessionStates', () => {
+    const seen: number[] = []
+    const statesBefore = $sessionStates.get()
+    const stop = $botChatSessionIds.listen(ids => seen.push(ids.size))
+
+    try {
+      setSessionTileWorkspaceScope('stored-1', botScope)
+    } finally {
+      stop()
+    }
+
+    expect(seen).toEqual([1])
+    // The store a stale subscriber would have been waiting on never moved.
+    expect($sessionStates.get()).toBe(statesBefore)
+  })
+
+  it('answers for the live id behind a marked stored one, and stops when cleared', () => {
+    setSessionTileWorkspaceScope('stored-1', botScope)
+
+    expect(isBotChatSession('runtime-1')).toBe(true)
+    expect(isBotChatSession('stored-1')).toBe(true)
+
+    setSessionTileWorkspaceScope('stored-1', { workspaceMode: 'sessions', workspaceOwnerKey: '' })
+
+    expect(isBotChatSession('runtime-1')).toBe(false)
+  })
+
+  it('is silent for an id it never marked, and for no id at all', () => {
+    expect(isBotChatSession('never-seen')).toBe(false)
+    expect(isBotChatSession(null)).toBe(false)
+    expect(isBotChatSession(undefined)).toBe(false)
+  })
+
+  it('resolves a marked chat only once the binding that names it exists', () => {
+    // The reason a subscriber cannot watch the scope set alone: with the set
+    // already marked, the answer still flips when the BINDING arrives.
+    $sessionTiles.set([])
+    setSessionTileWorkspaceScope('stored-1', botScope)
+
+    expect(isBotChatSession('runtime-1')).toBe(false)
+
+    $sessionTiles.set([{ runtimeId: 'runtime-1', storedSessionId: 'stored-1' } as never])
+
+    expect(isBotChatSession('runtime-1')).toBe(true)
+  })
+
+  it('does not re-notify when the same scope is recorded twice', () => {
+    setSessionTileWorkspaceScope('stored-1', botScope)
+
+    const seen: number[] = []
+    const stop = $botChatSessionIds.listen(ids => seen.push(ids.size))
+
+    try {
+      setSessionTileWorkspaceScope('stored-1', botScope)
+    } finally {
+      stop()
+    }
+
+    expect(seen).toEqual([])
+  })
+})
diff --git a/apps/desktop/src/store/session-states.ts b/apps/desktop/src/store/session-states.ts
index eb95d832e4c3..1004405bfa65 100644
--- a/apps/desktop/src/store/session-states.ts
+++ b/apps/desktop/src/store/session-states.ts
@@ -1076,7 +1076,50 @@ export function storedSessionIdForRuntimeId(sessionId: string): null | string {
   return mirrored || null
 }
 
+const BOT_CHAT_SCOPE_KEY = 'hermes.desktop.botChatSessions.v1'
+
+/** Stored ids last opened as a bot's chat. A tile carries `workspaceMode`, but
+ *  a bot chat normally lands in MAIN — `in-place` mints no tile when there is
+ *  none to front — and main has no tile to carry the scope on. Kept here so a
+ *  surface can still tell a companion chat from a working session, persisted
+ *  so that survives a relaunch the way tile scope does. */
+export const $botChatSessionIds = atom<ReadonlySet<string>>(
+  new Set((readJson<unknown>(BOT_CHAT_SCOPE_KEY) as unknown[] | null)?.filter(id => typeof id === 'string') ?? [])
+)
+
+function rememberBotChatScope(storedSessionId: string, isBotChat: boolean): void {
+  const current = $botChatSessionIds.get()
+
+  if (current.has(storedSessionId) === isBotChat) {
+    return
+  }
+
+  const next = new Set(current)
+
+  if (isBotChat) {
+    next.add(storedSessionId)
+  } else {
+    next.delete(storedSessionId)
+  }
+
+  $botChatSessionIds.set(next)
+  writeJson(BOT_CHAT_SCOPE_KEY, next.size ? [...next] : null)
+}
+
+/** True while this live session is a bot's chat rather than a working session.
+ *  Surfaces read it to drop coding chrome that means nothing in a companion
+ *  conversation — the composer's branch/worktree rail. */
+export function isBotChatSession(sessionId: null | string | undefined): boolean {
+  const stored = sessionId ? storedSessionIdForRuntimeId(sessionId) : null
+
+  return Boolean(stored && $botChatSessionIds.get().has(stored))
+}
+
 export function setSessionTileWorkspaceScope(storedSessionId: string, scope: SessionTileWorkspaceScope): boolean {
+  // Before the tile lookup: openSession routes every open through here, and a
+  // bot chat usually has no tile to record the scope on.
+  rememberBotChatScope(storedSessionId, scope.workspaceMode === 'bots')
+
   const tile = $sessionTiles.get().find(candidate => candidate.storedSessionId === storedSessionId)
   const workspaceOwnerKey = scope.workspaceMode === 'bots' ? scope.workspaceOwnerKey : undefined
   const ownerRoute = scope.workspaceMode === 'bots' ? scope.ownerRoute : undefined
diff --git a/apps/desktop/src/store/session-unread.ts b/apps/desktop/src/store/session-unread.ts
index c3e12122f552..de0f7ed60491 100644
--- a/apps/desktop/src/store/session-unread.ts
+++ b/apps/desktop/src/store/session-unread.ts
@@ -43,9 +43,11 @@ import { isBrowserWindow, isSecondaryWindow } from './windows'
  * cross-profile, `$sessions` is too in all-profiles mode). Unscoped keys let
  * one profile's watermark/marker paint (or silence) another's row. The bucket
  * is always the ROW's own `profile` (normalizeProfileKey, absent → "default"),
- * never the live gateway's — except for the live busy→idle edge with no loaded
- * row, which only ever fires for the ACTIVE gateway's runtimes and therefore
- * falls back to `$activeGatewayProfile`.
+ * never the live gateway's. Only an id with NO loaded row has no profile to
+ * read: it uses the caller's `profileHint` when there is one (a permanently
+ * hidden session, e.g. a Bot Mode canonical chat, is never listed and can
+ * belong to a profile the gateway isn't homed on), else `$activeGatewayProfile`
+ * — the only place a live busy→idle edge can come from.
  *
  * Both records are BOUNDED: markers cap per profile (oldest evicted),
  * watermarks cap in total (unlisted, unmarked entries dropped first), and
@@ -173,11 +175,19 @@ function resolveLoadedRow(storedSessionId: string): SessionInfo | undefined {
   return matches.find(row => profileKeyForRow(row) === gateway) ?? matches[0]
 }
 
+/** Bucket for a stored id with NO loaded row. The live gateway's profile is
+ *  the right answer for anything born of a live turn, but a permanently
+ *  hidden session (a Bot Mode canonical chat) is never in any list and can
+ *  belong to a profile the gateway isn't homed on — those callers pass the
+ *  owning profile they already know. */
+const unlistedProfile = (hint?: null | string): string =>
+  normalizeProfileKey((hint ?? '').trim() || $activeGatewayProfile.get())
+
 /** Bucket for a bare stored id: its row's profile, else the live gateway's. */
 const resolveProfile = (storedSessionId: string): string => {
   const row = resolveLoadedRow(storedSessionId)
 
-  return row ? profileKeyForRow(row) : normalizeProfileKey($activeGatewayProfile.get())
+  return row ? profileKeyForRow(row) : unlistedProfile()
 }
 
 /** Write a profile's marker bucket, dropping the key when it empties so we
@@ -195,12 +205,13 @@ function setMarkerBucket(profile: string, ids: readonly string[]): void {
   $unreadFinishedMarkers.set(next)
 }
 
-/** LIVE-EDGE WRITER — called by session-states.ts on a background busy→idle
- *  transition. Flags the transient atom (immediate paint) AND persists the
- *  marker so the dot survives a restart. The marker lands in the row's own
- *  profile; with no loaded row we use the active gateway's profile, which is
- *  the only place a live edge can come from. */
-export function markSessionUnreadFinished(storedSessionId: string): void {
+/** UNREAD WRITER — the live busy→idle edge (session-states.ts) and any surface
+ *  that learns out-of-band that a session produced something the user hasn't
+ *  seen. Flags the transient atom (immediate paint) AND persists the marker so
+ *  the dot survives a restart. The marker lands in the row's own profile; with
+ *  no loaded row it lands in `profileHint`'s, falling back to the active
+ *  gateway's — the only place a live edge can come from. */
+export function markSessionUnreadFinished(storedSessionId: string, profileHint?: null | string): void {
   const current = $unreadFinishedSessionIds.get()
 
   if (!current.includes(storedSessionId)) {
@@ -208,7 +219,7 @@ export function markSessionUnreadFinished(storedSessionId: string): void {
   }
 
   const row = resolveLoadedRow(storedSessionId)
-  const profile = row ? profileKeyForRow(row) : normalizeProfileKey($activeGatewayProfile.get())
+  const profile = row ? profileKeyForRow(row) : unlistedProfile(profileHint)
   const durableId = row ? sessionPinId(row) : storedSessionId
   const bucket = $unreadFinishedMarkers.get()[profile] ?? []
 
@@ -251,10 +262,13 @@ function ackSessionRow(row: SessionInfo): void {
 
 /** Clear persisted unread for a stored id even when its row isn't loaded —
  *  the marker alone can be retired; the watermark needs the row's count. With
- *  no row there is no profile to read, so we retire it from the active
- *  gateway's bucket (the profile whose sessions you can actually be opening);
- *  other profiles' identically-named ids stay untouched. */
-export function ackStoredSessionId(storedSessionId: null | string): void {
+ *  no row there is no profile to read, so we retire it from `profileHint`'s
+ *  bucket, falling back to the active gateway's (the profile whose sessions
+ *  you can actually be opening); other profiles' identically-named ids stay
+ *  untouched. Pass the hint whenever the caller knows the owner — a hidden
+ *  session can be opened without the gateway ever moving onto its profile,
+ *  which would otherwise ack a bucket that never held the marker. */
+export function ackStoredSessionId(storedSessionId: null | string, profileHint?: null | string): void {
   if (!storedSessionId) {
     return
   }
@@ -267,7 +281,7 @@ export function ackStoredSessionId(storedSessionId: null | string): void {
     return
   }
 
-  const profile = normalizeProfileKey($activeGatewayProfile.get())
+  const profile = unlistedProfile(profileHint)
   const markers = $unreadFinishedMarkers.get()[profile]
 
   if (!markers) {
@@ -561,5 +575,7 @@ if (!isSecondaryWindow() && !isBrowserWindow()) {
 
   // Opening a session acks it durably (the transient atom is already cleared
   // synchronously by setSelectedStoredSessionId — this is the persisted half).
-  $selectedStoredSessionId.listen(ackStoredSessionId)
+  // Unary on purpose: nanostores hands a listener (value, oldValue), and the
+  // old selection would otherwise arrive as the profile hint.
+  $selectedStoredSessionId.listen(id => ackStoredSessionId(id))
 }
diff --git a/apps/desktop/src/styles.css b/apps/desktop/src/styles.css
index 7109409ffd5f..00b9c88af1b9 100644
--- a/apps/desktop/src/styles.css
+++ b/apps/desktop/src/styles.css
@@ -1621,6 +1621,19 @@ body.guest-pointer-lock :is(webview, iframe) {
   container-type: inline-size;
 }
 
+/* The display lettering an empty chat is titled with. Kept here beside
+   `.fit-text` rather than as utilities on the element: the two always travel
+   together, and the face is the whole point of the treatment — it must not be
+   something a class-merge or a missed scan can quietly drop, leaving the
+   wordmark rendered in body text. */
+.wordmark {
+  font-family: 'Collapse', var(--font-sans);
+  font-weight: 700;
+  line-height: 0.9;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+
 .fit-text > [aria-hidden] {
   visibility: hidden;
 }
diff --git a/hermes_cli/profiles.py b/hermes_cli/profiles.py
index 76d3f9c36ef0..40fb3a31dabb 100644
--- a/hermes_cli/profiles.py
+++ b/hermes_cli/profiles.py
@@ -764,6 +764,41 @@ def _read_config_model(profile_dir: Path) -> tuple:
         return None, None
 
 
+def _seed_model_config(profile_dir: Path) -> None:
+    """Give a profile created without a clone source a usable model block.
+
+    Such a profile gets its directory tree but no ``config.yaml`` at all, so it
+    resolves no provider and its first turn dies with "No LLM provider
+    configured" — created, but unable to run. Copy the active profile's
+    ``model`` block over at creation time.
+
+    This is a copy, not a link: profiles remain independent islands, and
+    editing either one afterwards never touches the other. "Fresh" means fresh
+    skills and SOUL, not unreachable.
+    """
+    config_path = profile_dir / "config.yaml"
+    if config_path.exists():
+        return
+    try:
+        import yaml
+        from hermes_constants import get_hermes_home
+        from hermes_cli.config import read_user_config_raw
+
+        source = get_hermes_home() / "config.yaml"
+        if not source.is_file():
+            return
+        model_cfg = read_user_config_raw(source).get("model")
+        if not model_cfg:
+            return
+        config_path.write_text(
+            yaml.safe_dump({"model": model_cfg}, sort_keys=False),
+            encoding="utf-8",
+        )
+    except Exception:
+        # Creation must not fail over this; `hermes model` still sets it later.
+        pass
+
+
 def _check_gateway_running(profile_dir: Path) -> bool:
     """Check if a gateway is running for a given profile directory.
 
@@ -1226,6 +1261,9 @@ def create_profile(
         for subdir in _PROFILE_DIRS:
             (profile_dir / subdir).mkdir(parents=True, exist_ok=True)
 
+        if source_dir is None:
+            _seed_model_config(profile_dir)
+
         # Clone config files from source
         if source_dir is not None:
             for filename in _CLONE_CONFIG_FILES:
diff --git a/tests/hermes_cli/test_profiles.py b/tests/hermes_cli/test_profiles.py
index 21971ab84b17..ac5e1e27948f 100644
--- a/tests/hermes_cli/test_profiles.py
+++ b/tests/hermes_cli/test_profiles.py
@@ -133,6 +133,46 @@ def test_seeds_placeholder_env_file(self, profile_env):
         assert mode == 0o600
 
 
+    def test_fresh_profile_inherits_a_usable_model(self, profile_env):
+        """A profile created without a clone source still resolves a provider.
+
+        Without this it gets no config.yaml at all, so its very first turn dies
+        with "No LLM provider configured" — created, but unable to run. Fresh
+        means fresh skills and SOUL, not unreachable.
+        """
+        default_home = profile_env / ".hermes"
+        (default_home / "config.yaml").write_text(
+            "model:\n  provider: nous\n  default: some/model\n"
+        )
+
+        profile_dir = create_profile("coder", no_alias=True)
+
+        cfg = yaml.safe_load((profile_dir / "config.yaml").read_text())
+        assert cfg["model"]["provider"] == "nous"
+        assert cfg["model"]["default"] == "some/model"
+
+
+    def test_fresh_profile_model_is_copied_not_linked(self, profile_env):
+        """Profiles stay independent islands.
+
+        The model block is copied at creation, so later edits to the source
+        profile never reach one already created from it.
+        """
+        default_home = profile_env / ".hermes"
+        (default_home / "config.yaml").write_text(
+            "model:\n  provider: nous\n  default: some/model\n"
+        )
+        profile_dir = create_profile("coder", no_alias=True)
+
+        (default_home / "config.yaml").write_text(
+            "model:\n  provider: other\n  default: changed/model\n"
+        )
+
+        cfg = yaml.safe_load((profile_dir / "config.yaml").read_text())
+        assert cfg["model"]["provider"] == "nous"
+        assert cfg["model"]["default"] == "some/model"
+
+
 
 
     def test_clone_config_copies_files(self, profile_env):