From 28bf1444f7f13c6bb28fdcbaf6ae23bf9b69dbf8 Mon Sep 17 00:00:00 2001
From: Ivan Zatevakhin <zatevaxin.ivan@gmail.com>
Date: Wed, 30 Sep 2026 03:43:11 +0100
Subject: [PATCH 1/4] feat(session): integrate remote sessions into desktop
 catalog

---
 src/app.css                                   | 194 +++++---
 src/lib/components/mesh/MeshNodeList.svelte   | 192 ++------
 .../primitives/DesktopSessionList.svelte      | 126 +++--
 .../primitives/DesktopSessionList.test.ts     | 101 +++-
 .../components/session/SessionHeader.svelte   |  22 +-
 .../components/session/SessionHeader.test.ts  |  22 +
 .../settings/GeneralSettingsPanel.svelte      |  16 +
 src/lib/domain/sessions.test.ts               |  25 +
 src/lib/domain/sessions.ts                    |  10 +-
 src/lib/domain/types.ts                       |   3 +
 src/lib/querymt/generated/types.ts            |   5 +-
 src/lib/stores/agents.svelte.test.ts          | 462 +++++++++++++++++-
 src/lib/stores/agents.svelte.ts               | 202 +++++++-
 .../stores/chat-preferences.svelte.test.ts    |  49 +-
 src/lib/stores/chat-preferences.svelte.ts     |  23 +
 src/routes/+page.svelte                       |   1 +
 .../__tests__/landing-session-start.test.ts   |  94 +++-
 src/routes/mesh/+page.svelte                  |  89 +---
 src/routes/mesh/__tests__/mesh-page.test.ts   | 140 +++---
 src/routes/sessions/+page.svelte              |  19 +-
 .../[agentId]/[sessionId]/+page.svelte        |   5 +
 21 files changed, 1330 insertions(+), 470 deletions(-)

diff --git a/src/app.css b/src/app.css
index 6cc5196..ddbc177 100644
--- a/src/app.css
+++ b/src/app.css
@@ -2736,6 +2736,13 @@ summary:focus-visible {
   gap: 0.55rem;
 }
 
+.mesh-node-list .mesh-item-title {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 .mesh-node-session-count {
   flex: 0 0 auto;
   border-radius: 999px;
@@ -2818,72 +2825,43 @@ summary:focus-visible {
   gap: 0.35rem;
 }
 
-.mesh-node-feedback,
-.mesh-remote-session-list {
-  grid-column: 1 / -1;
-}
-
-.mesh-node-feedback {
+.mesh-node-inclusion {
   display: flex;
   align-items: center;
-  gap: 0.45rem;
-  margin-top: 0.15rem;
+  justify-content: flex-end;
+  gap: 0.35rem;
   color: var(--muted);
   font-size: 0.76rem;
+  white-space: nowrap;
 }
 
-.mesh-node-feedback-error {
-  color: var(--danger);
-}
-
-.mesh-node-feedback button {
-  color: currentColor;
-  font-weight: 650;
-  text-decoration: underline;
-  text-underline-offset: 0.15rem;
-}
-
-.mesh-remote-session-list {
-  display: grid;
-  margin-top: 0.35rem;
-  border-top: 1px solid var(--subtle-border);
-  padding-top: 0.25rem;
-}
-
-.mesh-remote-session-empty {
-  padding: 0.7rem 0.55rem 0.45rem;
+.mesh-node-inclusion-info {
+  display: inline-flex;
+  width: 1.5rem;
+  height: 1.5rem;
+  align-items: center;
+  justify-content: center;
+  border-radius: var(--radius-sm);
   color: var(--muted);
-  font-size: 0.76rem;
 }
 
-.mesh-remote-session-row {
-  display: flex;
-  margin: 0.12rem 0;
+.mesh-node-inclusion-info:hover,
+.mesh-node-inclusion-info:focus-visible {
+  color: var(--text);
+  background: var(--subtle-surface-hover);
 }
 
-.mesh-remote-session-row + .mesh-remote-session-row::before {
-  position: absolute;
-  top: -0.12rem;
-  right: 0.55rem;
-  left: 0.55rem;
-  height: 1px;
-  background: var(--subtle-border);
-  content: '';
-  pointer-events: none;
+.mesh-node-inclusion-info:focus-visible {
+  outline: 2px solid var(--accent);
 }
 
-.mesh-remote-session-side {
-  gap: 0.35rem;
-  pointer-events: auto;
+.mesh-node-inclusion .app-switch-control {
+  margin-left: 0.3rem;
 }
 
-.mesh-remote-session-pending {
-  display: inline-flex;
-  width: 1.8rem;
-  height: 1.8rem;
-  align-items: center;
-  justify-content: center;
-  color: var(--accent);
+.mesh-node-inclusion-tooltip {
+  max-width: min(18rem, calc(100vw - 2rem));
+  line-height: 1.35;
 }
 
 @media (max-width: 800px) {
@@ -2940,12 +2918,6 @@ summary:focus-visible {
     gap: 0.6rem;
     padding: 0.75rem;
   }
-
-  .mesh-node-list .mesh-item-row-stacked > .mesh-item-actions {
-    justify-content: flex-end;
-    flex-wrap: nowrap;
-    gap: 0.3rem;
-  }
 }
 
 .provider-connection-list {
@@ -5542,6 +5514,37 @@ summary:focus-visible {
   display: none;
 }
 
+.session-header-remote-indicator {
+  display: inline-flex;
+  width: 1.125rem;
+  height: 1.125rem;
+  flex: 0 0 auto;
+  align-items: center;
+  justify-content: center;
+  border-radius: var(--radius-sm);
+  color: inherit;
+}
+
+.session-header-remote-indicator:hover,
+.session-header-remote-indicator:focus-visible {
+  background: var(--subtle-surface-hover);
+  color: var(--text);
+}
+
+.session-header-remote-indicator:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 1px;
+}
+
+.session-header-meta > .session-header-remote-indicator + .session-header-workspace {
+  margin-left: -0.2rem;
+  padding-left: 0.12rem;
+}
+
+.session-header-mobile-meta > .session-header-remote-indicator {
+  margin-right: -0.15rem;
+}
+
 .session-header-meta span:not([aria-hidden]):not(.session-context-dial):not(.session-context-dial-figure) {
   overflow: hidden;
   text-overflow: ellipsis;
@@ -8620,6 +8623,14 @@ summary:focus-visible {
   display: none;
 }
 
+.session-browser-filter-scroll {
+  min-width: 0;
+  max-width: 100%;
+  overflow-x: auto;
+  overscroll-behavior-inline: contain;
+  scrollbar-width: thin;
+}
+
 .session-browser-search {
   display: flex;
   align-items: center;
@@ -8643,7 +8654,8 @@ summary:focus-visible {
 }
 
 .session-browser-filters {
-  display: inline-flex;
+  display: flex;
+  width: max-content;
   overflow: hidden;
   border: 1px solid var(--subtle-border);
   border-radius: var(--radius-control);
@@ -8651,6 +8663,8 @@ summary:focus-visible {
 }
 
 .session-browser-filter {
+  flex: 0 0 auto;
+  white-space: nowrap;
   border: 0;
   border-left: 1px solid transparent;
   background: transparent;
@@ -8670,6 +8684,13 @@ summary:focus-visible {
   color: var(--text);
 }
 
+.session-browser-filter:focus-visible {
+  position: relative;
+  z-index: 1;
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+}
+
 .session-browser-body {
   display: grid;
   gap: 0.75rem;
@@ -8737,6 +8758,45 @@ summary:focus-visible {
   outline: none;
 }
 
+.session-workspace-target-picker > summary {
+  list-style: none;
+  cursor: pointer;
+}
+
+.session-workspace-target-picker > summary::-webkit-details-marker {
+  display: none;
+}
+
+.session-workspace-target-options {
+  position: absolute;
+  z-index: 5;
+  top: calc(100% - 0.2rem);
+  right: 0.65rem;
+  display: grid;
+  min-width: 9rem;
+  max-width: min(16rem, calc(100vw - 2rem));
+  border: 1px solid var(--border);
+  border-radius: var(--radius-control);
+  background: var(--bg-panel-strong);
+  padding: 0.3rem;
+  box-shadow: var(--shadow-lg);
+}
+
+.session-workspace-target-options button {
+  overflow: hidden;
+  border-radius: var(--radius-sm);
+  padding: 0.4rem 0.6rem;
+  text-align: left;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.session-workspace-target-options button:hover,
+.session-workspace-target-options button:focus-visible {
+  background: var(--subtle-surface-hover);
+  outline: none;
+}
+
 .session-workspace-trigger-main,
 .session-workspace-meta,
 .session-workspace-updated {
@@ -8759,12 +8819,6 @@ summary:focus-visible {
   color: var(--text-muted);
 }
 
-.session-workspace-icon-remote {
-  border-color: color-mix(in srgb, var(--accent) 32%, var(--subtle-border));
-  background: color-mix(in srgb, var(--accent-dim), var(--icon-surface) 76%);
-  color: var(--accent);
-}
-
 .session-workspace-copy {
   display: grid;
   min-width: 0;
@@ -8779,6 +8833,7 @@ summary:focus-visible {
 
 .session-workspace-path {
   display: flex;
+  gap: 0.5rem;
   min-width: 0;
   overflow: hidden;
   color: var(--muted);
@@ -8792,8 +8847,10 @@ summary:focus-visible {
 }
 
 .session-workspace-machine {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
   flex: 0 0 auto;
-  margin-left: 0.35rem;
   color: var(--text-dim);
   font-weight: 550;
 }
@@ -10557,7 +10614,7 @@ summary:focus-visible {
     background: var(--accent);
   }
 
-  .session-browser-filters {
+  .session-browser-filter-scroll {
     position: absolute;
     top: calc(100% + 0.4rem);
     right: 0;
@@ -10566,11 +10623,12 @@ summary:focus-visible {
     width: max-content;
     max-width: calc(100vw - 1rem);
     background: var(--bg-panel-strong);
+    border-radius: var(--radius-control);
     box-shadow: var(--shadow-lg);
   }
 
-  .session-browser-filters-expanded {
-    display: inline-flex;
+  .session-browser-filter-scroll-expanded {
+    display: block;
   }
 
   .agent-list-row-inner {
diff --git a/src/lib/components/mesh/MeshNodeList.svelte b/src/lib/components/mesh/MeshNodeList.svelte
index fa0382d..06e6fa9 100644
--- a/src/lib/components/mesh/MeshNodeList.svelte
+++ b/src/lib/components/mesh/MeshNodeList.svelte
@@ -1,46 +1,20 @@
 <script lang="ts">
-  import { Check, Copy, Ellipsis, Link, LoaderCircle, Plus, RefreshCw, XCircle } from '@lucide/svelte';
-  import IconTooltipButton from '$lib/components/primitives/IconTooltipButton.svelte';
-  import { formatSessionTimestamp } from '$lib/domain/sessions';
-  import type { RemoteNodeInfo, RemoteSessionListInfo } from '$lib/querymt/generated/types';
-  import { createRoundIdenticon } from '$lib/vendor/round-identicon';
+  import { Check, Copy, Info } from '@lucide/svelte';
+  import { Tooltip } from 'bits-ui';
+  import AppSwitch from '$lib/components/primitives/AppSwitch.svelte';
+  import { chatPreferencesStore } from '$lib/stores/chat-preferences.svelte';
+  import type { RemoteNodeInfo } from '$lib/querymt/generated/types';
 
   let {
     nodes,
-    sessionsByNode,
-    loadingNodeId = null,
-    attachingSessionKey = null,
-    dismissingSessionKey = null,
-    nodeErrors = {},
-    canCreate = false,
-    canAttach = false,
-    canListSessions = false,
-    canDismiss = false,
-    onCreate,
-    onOpenAttach,
-    onAttachSession,
-    onLoadSessions,
-    onDismiss
+    onIncludeSessions
   }: {
     nodes: RemoteNodeInfo[];
-    sessionsByNode: Record<string, RemoteSessionListInfo | undefined>;
-    loadingNodeId?: string | null;
-    attachingSessionKey?: string | null;
-    dismissingSessionKey?: string | null;
-    nodeErrors?: Record<string, string | undefined>;
-    canCreate?: boolean;
-    canAttach?: boolean;
-    canListSessions?: boolean;
-    canDismiss?: boolean;
-    onCreate: (nodeId: string) => void;
-    onOpenAttach: (nodeId: string) => void;
-    onAttachSession: (nodeId: string, sessionId: string) => void;
-    onLoadSessions: (nodeId: string) => void;
-    onDismiss: (nodeId: string, sessionId: string) => void;
+    onIncludeSessions: (nodeId: string, enabled: boolean) => void;
   } = $props();
 
   let copiedNodeId = $state<string | null>(null);
-  let copiedSessionId = $state<string | null>(null);
+  const sortedNodes = $derived([...nodes].sort((a, b) => a.id.localeCompare(b.id)));
 
   function compactNodeId(nodeId: string) {
     if (nodeId.length <= 24) return nodeId;
@@ -59,30 +33,6 @@
     }
   }
 
-  async function copySessionId(event: MouseEvent, sessionId: string) {
-    event.stopPropagation();
-    (event.currentTarget as HTMLElement).closest('details')?.removeAttribute('open');
-    try {
-      await navigator.clipboard.writeText(sessionId);
-      copiedSessionId = sessionId;
-      window.setTimeout(() => {
-        if (copiedSessionId === sessionId) copiedSessionId = null;
-      }, 1200);
-    } catch (error) {
-      console.error('Failed to copy remote session ID', error);
-    }
-  }
-
-  function dismissSession(event: MouseEvent, nodeId: string, sessionId: string) {
-    event.stopPropagation();
-    (event.currentTarget as HTMLElement).closest('details')?.removeAttribute('open');
-    onDismiss(nodeId, sessionId);
-  }
-
-  function sessionKey(nodeId: string, sessionId: string) {
-    return `${nodeId}:${sessionId}`;
-  }
-
   function visibleTransport(value: string) {
     const transport = value.trim();
     return transport && transport.toLowerCase() !== 'unknown' ? transport : null;
@@ -108,8 +58,7 @@
   <div class="mesh-empty-row">No mesh nodes reported. Refresh the mesh to check for available peers.</div>
 {:else}
   <div class="mesh-item-list mesh-node-list">
-    {#each nodes as node}
-      {@const loadedSessions = sessionsByNode[node.id]}
+    {#each sortedNodes as node (node.id)}
       <article class="mesh-item-row mesh-item-row-stacked">
         <div class="mesh-item-main">
           <div class="mesh-node-title-line">
@@ -137,96 +86,41 @@
             {/if}
           </div>
         </div>
-        <div class="mesh-item-actions">
-          <IconTooltipButton label={`Create session on ${node.label || node.id}`} icon={Plus} disabled={!canCreate} onclick={() => onCreate(node.id)} />
-          <IconTooltipButton label={`Attach session from ${node.label || node.id}`} icon={Link} disabled={!canAttach} onclick={() => onOpenAttach(node.id)} />
-          <IconTooltipButton
-            label={loadingNodeId === node.id ? `Loading sessions from ${node.label || node.id}` : `${loadedSessions ? 'Refresh' : 'Load'} sessions from ${node.label || node.id}`}
-            icon={loadingNodeId === node.id ? LoaderCircle : RefreshCw}
-            iconClass={loadingNodeId === node.id ? 'animate-spin' : ''}
-            disabled={!canListSessions || loadingNodeId === node.id}
-            onclick={() => onLoadSessions(node.id)}
-          />
-        </div>
-
-        {#if nodeErrors[node.id]}
-          <div class="mesh-node-feedback mesh-node-feedback-error" role="alert">
-            <span>{nodeErrors[node.id]}</span>
-            <button type="button" onclick={() => onLoadSessions(node.id)}>Retry</button>
+        {#if chatPreferencesStore.showRemoteSessions}
+          <div class="mesh-node-inclusion">
+            <span>Include</span>
+            <Tooltip.Provider delayDuration={250} skipDelayDuration={80}>
+              <Tooltip.Root disableHoverableContent>
+                <Tooltip.Trigger class="mesh-node-inclusion-info" type="button" aria-label={`About including sessions from ${node.label || node.id}`}>
+                  <Info size={14} aria-hidden="true" />
+                </Tooltip.Trigger>
+                <Tooltip.Portal>
+                  <Tooltip.Content class="app-tooltip-content mesh-node-inclusion-tooltip" sideOffset={6}>
+                    Include sessions from remote host {node.label || node.id} in the Sessions list.
+                  </Tooltip.Content>
+                </Tooltip.Portal>
+              </Tooltip.Root>
+            </Tooltip.Provider>
+            <AppSwitch
+              checked={chatPreferencesStore.remoteSessionPeers.includes(node.id)}
+              ariaLabel={`Include ${node.label || node.id} in Sessions`}
+              onCheckedChange={(enabled) => onIncludeSessions(node.id, enabled)}
+            />
           </div>
-        {:else if loadingNodeId === node.id && !loadedSessions}
-          <div class="mesh-node-feedback" role="status"><LoaderCircle size={13} class="animate-spin" /> Loading remote sessions…</div>
-        {:else if loadedSessions}
-          <div class="mesh-remote-session-list">
-            {#if loadedSessions.sessions.length === 0}
-              <div class="mesh-remote-session-empty">No remote sessions on this node.</div>
-            {:else}
-              {#each loadedSessions.sessions as session}
-                {@const pendingAttach = attachingSessionKey === sessionKey(node.id, session.id)}
-                {@const pendingDismiss = dismissingSessionKey === sessionKey(node.id, session.id)}
-                {@const sessionTitle = session.title ?? session.id}
-                {@const identicon = createRoundIdenticon(session.id)}
-                <div class="model-picker-row session-row mesh-remote-session-row">
-                  <button
-                    class="session-row-navigation"
-                    type="button"
-                    aria-label={`Attach remote session ${sessionTitle}`}
-                    disabled={!canAttach || pendingAttach || pendingDismiss}
-                    onclick={() => onAttachSession(node.id, session.id)}
-                  ></button>
-                  <span class="session-row-identicon" aria-hidden="true">
-                    <svg
-                      class="session-identicon-svg"
-                      style={`--identicon-color: ${identicon.color}`}
-                      width={identicon.width}
-                      height={identicon.width}
-                      viewBox={`0 0 ${identicon.width} ${identicon.width}`}
-                      preserveAspectRatio="xMinYMin"
-                    >
-                      <circle cx={identicon.center} cy={identicon.center} r={identicon.centerRadius} fill="currentColor" />
-                      <g fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round">
-                        {#each identicon.arcs as arc}
-                          <path d={arc.d} stroke-width={arc.strokeWidth} />
-                        {/each}
-                      </g>
-                    </svg>
-                  </span>
-                  <span class="session-row-main">
-                    <span class="session-row-title-line">
-                      <span class="session-row-title">{sessionTitle}</span>
-                    </span>
-                    <span class="session-row-meta">
-                      <span>{session.cwd ?? 'No working directory'}</span>
-                      <span>{formatSessionTimestamp(session.updated_at ?? null)}</span>
-                    </span>
-                  </span>
-                  <span class="session-row-side mesh-remote-session-side">
-                    {#if pendingAttach}
-                      <span class="mesh-remote-session-pending" role="status" aria-label={`Attaching ${sessionTitle}`}>
-                        <LoaderCircle size={15} class="animate-spin" aria-hidden="true" />
-                      </span>
-                    {/if}
-                    <details class="session-row-menu">
-                      <summary class="session-row-menu-trigger" aria-label={`Session actions for ${sessionTitle}`} title="Session actions"><Ellipsis size={16} /></summary>
-                      <div class="session-row-menu-content">
-                        <button type="button" aria-label={`Copy remote session ID for ${sessionTitle}`} onclick={(event) => copySessionId(event, session.id)}>
-                          {#if copiedSessionId === session.id}<Check size={14} />Copied{:else}<Copy size={14} />Copy session ID{/if}
-                        </button>
-                        <button
-                          class="session-row-menu-danger"
-                          type="button"
-                          aria-label={pendingDismiss ? `Dismissing ${sessionTitle}` : `Dismiss ${sessionTitle}`}
-                          disabled={!canDismiss || pendingDismiss}
-                          onclick={(event) => dismissSession(event, node.id, session.id)}
-                        >
-                          {#if pendingDismiss}<LoaderCircle size={14} class="animate-spin" />Dismissing{:else}<XCircle size={14} />Dismiss session{/if}
-                        </button>
-                      </div>
-                    </details>
-                  </span>
-                </div>
-              {/each}
-            {/if}
+        {:else}
+          <div class="mesh-node-inclusion">
+            <Tooltip.Provider delayDuration={250} skipDelayDuration={80}>
+              <Tooltip.Root disableHoverableContent>
+                <Tooltip.Trigger class="mesh-node-inclusion-info" type="button" aria-label="About enabling remote sessions">
+                  <Info size={14} aria-hidden="true" />
+                </Tooltip.Trigger>
+                <Tooltip.Portal>
+                  <Tooltip.Content class="app-tooltip-content mesh-node-inclusion-tooltip" sideOffset={6}>
+                    To include sessions from remote hosts in the Sessions list, enable Show remote sessions in Settings.
+                  </Tooltip.Content>
+                </Tooltip.Portal>
+              </Tooltip.Root>
+            </Tooltip.Provider>
           </div>
         {/if}
       </article>
diff --git a/src/lib/components/primitives/DesktopSessionList.svelte b/src/lib/components/primitives/DesktopSessionList.svelte
index 523350c..582086f 100644
--- a/src/lib/components/primitives/DesktopSessionList.svelte
+++ b/src/lib/components/primitives/DesktopSessionList.svelte
@@ -1,11 +1,11 @@
 <script lang="ts">
   import { getContext } from 'svelte';
   import { Accordion } from 'bits-ui';
-  import { AlertTriangle, Bot, Check, ChevronDown, Clock3, Copy, Ellipsis, FolderKanban, FolderSync, GitFork, LoaderCircle, MessageSquarePlus, PlugZap, Plus, RefreshCw, Search, SearchX, SlidersHorizontal, Trash2 } from '@lucide/svelte';
+  import { AlertTriangle, Bot, Check, ChevronDown, Clock3, Copy, Ellipsis, FolderKanban, FolderSync, GitFork, LoaderCircle, MessageSquarePlus, Network, PlugZap, Plus, RefreshCw, Search, SearchX, SlidersHorizontal, Trash2 } from '@lucide/svelte';
   import AppConfirmDialog from '$lib/components/primitives/AppConfirmDialog.svelte';
   import CopyTextChip from '$lib/components/primitives/CopyTextChip.svelte';
   import SessionIdChip from '$lib/components/primitives/SessionIdChip.svelte';
-  import { compactRemoteNodeId, formatSessionTimestamp, formatSessionTimestampAbsolute, groupSessionsByWorkspace, type WorkspaceSessionGroup } from '$lib/domain/sessions';
+  import { compactRemoteNodeId, formatSessionTimestamp, formatSessionTimestampAbsolute, getWorkspaceLocation, getWorkspaceRemoteMachines, groupSessionsByWorkspace, type WorkspaceSessionGroup } from '$lib/domain/sessions';
   import { createRoundIdenticon } from '$lib/vendor/round-identicon';
   import type { DesktopSessionSummary, SessionStatus } from '$lib/domain/types';
 
@@ -17,6 +17,7 @@
     emptyMessage = 'No sessions returned yet.',
     disconnected = false,
     showAgentNames = true,
+    showRemoteSessions = false,
     showToolbarRefresh = true,
     onRefresh = null,
     onCreateSession = null,
@@ -35,22 +36,23 @@
     emptyMessage?: string;
     disconnected?: boolean;
     showAgentNames?: boolean;
+    showRemoteSessions?: boolean;
     showToolbarRefresh?: boolean;
     onRefresh?: (() => void | Promise<void>) | null;
     onCreateSession?: (() => void | Promise<void>) | null;
     onOpenAgents?: (() => void | Promise<void>) | null;
     onOpenWorkspace?: ((cwd: string) => void | Promise<void>) | null;
-    onCreateWorkspaceSession?: ((cwd: string) => void | Promise<void>) | null;
+    onCreateWorkspaceSession?: ((group: WorkspaceSessionGroup, nodeId?: string) => void | Promise<void>) | null;
     onLoadMoreWorkspace?: ((cwd: string) => void | Promise<void>) | null;
     onOpenSession?: ((session: DesktopSessionSummary) => void) | null;
     canDeleteSession?: ((session: DesktopSessionSummary) => boolean) | null;
     onDeleteSession?: ((session: DesktopSessionSummary) => Promise<void>) | null;
   } = $props();
 
-  type SessionFilter = 'all' | 'active' | 'needs-input' | 'completed';
+  type SessionFilter = 'all' | 'active' | 'needs-input' | 'completed' | 'remote';
 
   let query = $state('');
-  let statusFilter = $state<SessionFilter>('all');
+  let sessionFilter = $state<SessionFilter>('all');
   let filtersExpanded = $state(false);
   let openGroups = $state<string[]>([]);
   let lastWorkspaceKeySignature = $state('');
@@ -72,9 +74,9 @@
   function workspaceMachineText(group: WorkspaceSessionGroup) {
     const machines = group.remoteMachines ?? [];
     if (machines.length === 0) return null;
-    if (machines.length > 1) return group.location === 'mixed' ? `local + ${machines.length} machines` : `on ${machines.length} machines`;
+    if (machines.length > 1) return group.location === 'mixed' ? `local + ${machines.length} machines` : `${machines.length} machines`;
     const name = machineName(machines[0]);
-    return group.location === 'mixed' ? `local + ${name}` : `on ${name}`;
+    return group.location === 'mixed' ? `local + ${name}` : name;
   }
 
   function workspaceMachineTitle(group: WorkspaceSessionGroup) {
@@ -84,7 +86,11 @@
   }
   const initialLoading = $derived(loading && sourceWorkspaceGroups.length === 0);
   const refreshing = $derived(loading && sourceWorkspaceGroups.length > 0);
-  const hasActiveFilters = $derived(query.trim().length > 0 || statusFilter !== 'all');
+  const hasActiveFilters = $derived(query.trim().length > 0 || sessionFilter !== 'all');
+
+  $effect(() => {
+    if (!showRemoteSessions && sessionFilter === 'remote') sessionFilter = 'all';
+  });
 
   function workspaceMatchesGroup(group: WorkspaceSessionGroup, normalizedQuery: string): boolean {
     return (
@@ -100,17 +106,22 @@
       .map((group) => {
         const workspaceMatches = workspaceMatchesGroup(group, normalizedQuery);
         const filteredSessions = group.sessions.filter((session) => {
-           const matchesStatus = sessionMatchesFilter(session.status, statusFilter);
+          const matchesFilter = sessionMatchesFilter(session, sessionFilter);
           const matchesQuery =
             workspaceMatches ||
             session.title.toLowerCase().includes(normalizedQuery) ||
             session.agentName.toLowerCase().includes(normalizedQuery) ||
             session.sessionId.toLowerCase().includes(normalizedQuery);
-          return matchesStatus && matchesQuery;
+          return matchesFilter && matchesQuery;
         });
-        return { ...group, sessions: filteredSessions };
+        return {
+          ...group,
+          sessions: filteredSessions,
+          location: filteredSessions.length ? getWorkspaceLocation(filteredSessions) : group.location,
+          remoteMachines: filteredSessions.length ? getWorkspaceRemoteMachines(filteredSessions) : group.remoteMachines
+        };
       })
-      .filter((group) => group.sessions.length > 0 || (statusFilter === 'all' && workspaceMatchesGroup(group, normalizedQuery)));
+      .filter((group) => group.sessions.length > 0 || (sessionFilter === 'all' && workspaceMatchesGroup(group, normalizedQuery)));
   });
 
   $effect(() => {
@@ -138,32 +149,34 @@
     }
   });
 
-  const statusFilters: Array<{ value: SessionFilter; label: string }> = [
+  const sessionFilters: Array<{ value: SessionFilter; label: string }> = [
     { value: 'all', label: 'All' },
     { value: 'active', label: 'Active' },
     { value: 'needs-input', label: 'Needs input' },
-    { value: 'completed', label: 'Completed' }
+    { value: 'completed', label: 'Completed' },
+    { value: 'remote', label: 'Remote' }
   ];
 
-  function sessionMatchesFilter(status: SessionStatus, filter: SessionFilter): boolean {
+  function sessionMatchesFilter(session: DesktopSessionSummary, filter: SessionFilter): boolean {
     if (filter === 'all') return true;
-    if (filter === 'active') return status === 'thinking' || status === 'cancelling';
-    if (filter === 'needs-input') return status === 'waiting';
-    return status === 'completed';
+    if (filter === 'remote') return session.location === 'remote';
+    if (filter === 'active') return session.status === 'thinking' || session.status === 'cancelling';
+    if (filter === 'needs-input') return session.status === 'waiting';
+    return session.status === 'completed';
   }
 
   function countWorkspaceSessions(group: WorkspaceSessionGroup, filter: SessionFilter): number {
-    return group.sessions.filter((session) => sessionMatchesFilter(session.status, filter)).length;
+    return group.sessions.filter((session) => sessionMatchesFilter(session, filter)).length;
   }
 
   function clearFilters() {
     query = '';
-    statusFilter = 'all';
+    sessionFilter = 'all';
     filtersExpanded = false;
   }
 
-  function setStatusFilter(filter: SessionFilter) {
-    statusFilter = filter;
+  function setSessionFilter(filter: SessionFilter) {
+    sessionFilter = filter;
     filtersExpanded = false;
   }
 
@@ -254,30 +267,35 @@
         class="session-browser-filter-toggle"
         type="button"
         aria-label={filtersExpanded ? 'Hide session filters' : 'Show session filters'}
-        aria-controls="session-status-filters"
+        aria-controls="session-filters"
         aria-expanded={filtersExpanded}
         onclick={() => (filtersExpanded = !filtersExpanded)}
       >
         <SlidersHorizontal size={15} />
         <span>Filters</span>
-        {#if statusFilter !== 'all'}<span class="session-browser-filter-indicator" aria-hidden="true"></span>{/if}
+        {#if sessionFilter !== 'all'}<span class="session-browser-filter-indicator" aria-hidden="true"></span>{/if}
         <ChevronDown size={14} class={filtersExpanded ? 'rotate-180' : ''} />
       </button>
       <div
-        id="session-status-filters"
-        class={`session-browser-filters ${filtersExpanded ? 'session-browser-filters-expanded' : ''}`}
-        aria-label="Session status filter"
+        id="session-filters"
+        class={`session-browser-filter-scroll ${filtersExpanded ? 'session-browser-filter-scroll-expanded' : ''}`}
+        role="group"
+        aria-label="Filter sessions"
       >
-        {#each statusFilters as filter}
-          <button
-            class={`session-browser-filter ${statusFilter === filter.value ? 'session-browser-filter-active' : ''}`}
-            type="button"
-            aria-pressed={statusFilter === filter.value}
-            onclick={() => setStatusFilter(filter.value)}
-          >
-            {filter.label}
-          </button>
-        {/each}
+        <div class="session-browser-filters">
+          {#each sessionFilters as filter}
+            {#if filter.value !== 'remote' || showRemoteSessions}
+              <button
+                class={`session-browser-filter ${sessionFilter === filter.value ? 'session-browser-filter-active' : ''}`}
+                type="button"
+                aria-pressed={sessionFilter === filter.value}
+                onclick={() => setSessionFilter(filter.value)}
+              >
+                {filter.label}
+              </button>
+            {/if}
+          {/each}
+        </div>
       </div>
       {#if showToolbarRefresh && onRefresh}
         <button class="icon-btn" type="button" aria-label={refreshing ? 'Refreshing sessions' : 'Refresh sessions'} disabled={loading} onclick={onRefresh}>
@@ -319,7 +337,7 @@
     {:else if filteredWorkspaceGroups.length === 0}
       <div class="state-panel">
         <span class="state-panel-icon"><SearchX size={17} /></span>
-        <div class="state-panel-copy"><strong>No matching sessions</strong><p>Try another search or clear the current status filter.</p></div>
+        <div class="state-panel-copy"><strong>No matching sessions</strong><p>Try another search or choose a different filter.</p></div>
         {#if hasActiveFilters}<button class="action-btn" type="button" onclick={clearFilters}>Clear filters</button>{/if}
       </div>
     {:else}
@@ -349,7 +367,7 @@
                          <span class="session-workspace-path">
                            <CopyTextChip value={group.path} title="Copy project path" />
                            {#if workspaceMachineText(group)}
-                             <span class="session-workspace-machine" title={workspaceMachineTitle(group)}>· {workspaceMachineText(group)}</span>
+                             <span class="session-workspace-machine" title={workspaceMachineTitle(group)}><Network size={12} aria-hidden="true" />{workspaceMachineText(group)}</span>
                            {/if}
                          </span>
                       </span>
@@ -371,9 +389,23 @@
                    </span>
                  </Accordion.Trigger>
                </Accordion.Header>
-               {#if onCreateWorkspaceSession}
-                 <button class="session-workspace-new" type="button" aria-label={`New session in ${group.name}`} title={`New session in ${group.name}`} onclick={() => onCreateWorkspaceSession?.(group.cwd)}><Plus size={15} /></button>
-               {/if}
+                {#if onCreateWorkspaceSession}
+                  {#if group.location === 'mixed' || (group.remoteMachines?.length ?? 0) > 1}
+                    <details class="session-workspace-target-picker">
+                      <summary class="session-workspace-new" aria-label={`New session in ${group.name}`} title={`Choose target for ${group.name}`}><Plus size={15} /></summary>
+                      <div class="session-workspace-target-options">
+                        {#if group.location === 'mixed'}
+                          <button type="button" onclick={() => onCreateWorkspaceSession?.(group, 'local')}>Local</button>
+                        {/if}
+                        {#each group.remoteMachines ?? [] as machine (machine.id)}
+                          <button type="button" title={machine.id} onclick={() => onCreateWorkspaceSession?.(group, machine.id)}>{machine.label || compactRemoteNodeId(machine.id)}</button>
+                        {/each}
+                      </div>
+                    </details>
+                  {:else}
+                    <button class="session-workspace-new" type="button" aria-label={`New session in ${group.name}`} title={`New session in ${group.name}`} onclick={() => onCreateWorkspaceSession?.(group)}><Plus size={15} /></button>
+                  {/if}
+                {/if}
              </div>
             <Accordion.Content class="session-workspace-content">
               {#if group.loading && group.sessions.length === 0}
@@ -411,10 +443,12 @@
                     <span class="session-row-main">
                        <span class="session-row-title-line">
                           <span class="session-row-title">{session.title}</span>
-                          {#if group.location === 'mixed' && session.location === 'remote'}
-                            <span class="session-relationship-badge session-relationship-badge-remote">Remote</span>
-                          {/if}
-                         {#if session.parentSessionId}
+                           {#if session.location === 'remote' && session.remoteConnectionState === 'disconnected'}
+                             <span class="session-relationship-badge session-relationship-badge-remote">Remote · disconnected</span>
+                           {:else if group.location === 'mixed' && session.location === 'remote'}
+                             <span class="session-relationship-badge session-relationship-badge-remote">Remote</span>
+                           {/if}
+                          {#if session.parentSessionId}
                           {#if session.forkOrigin === 'user'}
                             <span class="session-relationship-badge session-relationship-badge-fork"><GitFork size={11} />Fork</span>
                           {:else if session.forkOrigin === 'delegation'}
diff --git a/src/lib/components/primitives/DesktopSessionList.test.ts b/src/lib/components/primitives/DesktopSessionList.test.ts
index 889ff7a..9a7cbc4 100644
--- a/src/lib/components/primitives/DesktopSessionList.test.ts
+++ b/src/lib/components/primitives/DesktopSessionList.test.ts
@@ -157,12 +157,14 @@ describe('DesktopSessionList', () => {
       ]
     });
 
-    expect(screen.getByText('· on sapr')).toHaveAttribute('title', 'Remote workspace on sapr');
-    expect(screen.getByText('· local + 12D3KooWPtRj...unWZUT62')).toHaveAttribute(
+    expect(screen.getByText('sapr')).toHaveAttribute('title', 'Remote workspace on sapr');
+    expect(screen.getByText('sapr').querySelector('.lucide-network')).not.toBeNull();
+    expect(screen.getByText('local + 12D3KooWPtRj...unWZUT62')).toHaveAttribute(
       'title',
       'Local workspace and remote workspace on 12D3KooWPtRj...unWZUT62'
     );
-    expect(screen.getByText('· on 2 machines')).toHaveAttribute('title', 'Remote workspace on alpha, beta');
+    expect(screen.getByText('2 machines')).toHaveAttribute('title', 'Remote workspace on alpha, beta');
+    expect(screen.getAllByText(/^(sapr|local \+ 12D3KooWPtRj\.\.\.unWZUT62|2 machines)$/).every((item) => item.querySelector('.lucide-network'))).toBe(true);
   });
 
   it('shows a copyable session id chip after the row status dot', async () => {
@@ -267,17 +269,83 @@ describe('DesktopSessionList', () => {
     expect(screen.getByRole('button', { name: 'Needs input' })).toBeInTheDocument();
     expect(screen.queryByRole('button', { name: 'Thinking' })).not.toBeInTheDocument();
 
-    const filterToggle = screen.getByRole('button', { name: 'Show session filters' });
-    expect(filterToggle).toHaveAttribute('aria-expanded', 'false');
-    await fireEvent.click(filterToggle);
+    const toggle = screen.getByRole('button', { name: 'Show session filters' });
+    const group = screen.getByRole('group', { name: 'Filter sessions' });
+    expect(toggle).toHaveAttribute('aria-expanded', 'false');
+    expect(toggle).toHaveAttribute('aria-controls', group.id);
+    expect(group).not.toHaveClass('session-browser-filter-scroll-expanded');
+    await fireEvent.click(toggle);
     expect(screen.getByRole('button', { name: 'Hide session filters' })).toHaveAttribute('aria-expanded', 'true');
-
+    expect(group).toHaveClass('session-browser-filter-scroll-expanded');
     await fireEvent.click(screen.getByRole('button', { name: 'Needs input' }));
     expect(screen.getByRole('button', { name: 'Show session filters' })).toHaveAttribute('aria-expanded', 'false');
+    expect(group).not.toHaveClass('session-browser-filter-scroll-expanded');
+    expect(screen.getByRole('button', { name: 'Needs input' })).toHaveAttribute('aria-pressed', 'true');
+    expect(screen.getByRole('button', { name: 'All' })).toHaveAttribute('aria-pressed', 'false');
     expect(screen.getByText('Needs approval')).toBeInTheDocument();
     expect(screen.queryByText('Active work')).not.toBeInTheDocument();
   });
 
+  it('switches between status and remote in one exclusive segmented filter', async () => {
+    const mixedSessions: DesktopSessionSummary[] = [
+      { ...sessions[0], sessionId: 'local-active', title: 'Local active', status: 'thinking', location: 'local' },
+      { ...sessions[0], sessionId: 'remote-waiting', title: 'Remote waiting', status: 'waiting', location: 'remote', remoteNodeId: 'node-1', remoteNodeLabel: 'Laptop' },
+      { ...sessions[0], sessionId: 'remote-completed', title: 'Remote completed', status: 'completed', location: 'remote', remoteNodeId: 'node-1', remoteNodeLabel: 'Laptop' }
+    ];
+    const { container } = render(DesktopSessionList, { sessions: mixedSessions, showRemoteSessions: true });
+    const remote = screen.getByRole('button', { name: 'Remote' });
+
+    await fireEvent.click(screen.getByRole('button', { name: 'Active' }));
+    expect(screen.getByText('Local active')).toBeInTheDocument();
+    expect(screen.queryByText('Remote waiting')).not.toBeInTheDocument();
+
+    await fireEvent.click(remote);
+    expect(remote).toHaveAttribute('aria-pressed', 'true');
+    expect(screen.getByRole('button', { name: 'Show session filters' })).toHaveAttribute('aria-expanded', 'false');
+    expect(container.querySelector('.session-browser-filter-indicator')).not.toBeNull();
+    expect(screen.getByRole('button', { name: 'Active' })).toHaveAttribute('aria-pressed', 'false');
+    expect(screen.queryByText('Local active')).not.toBeInTheDocument();
+    expect(screen.getByText('Remote waiting')).toBeInTheDocument();
+    expect(screen.getByText('Remote completed')).toBeInTheDocument();
+    expect(container.querySelector('.session-workspace-icon-remote')).not.toBeNull();
+    expect(screen.getByText('Laptop').querySelector('.lucide-network')).not.toBeNull();
+
+    await fireEvent.click(screen.getByRole('button', { name: 'All' }));
+    expect(screen.getByText('Local active')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'All' })).toHaveAttribute('aria-pressed', 'true');
+  });
+
+  it('clears search and remote selection when no sessions match', async () => {
+    render(DesktopSessionList, { sessions, showRemoteSessions: true });
+    await fireEvent.click(screen.getByRole('button', { name: 'Remote' }));
+    expect(screen.getByText('No matching sessions')).toBeInTheDocument();
+    await fireEvent.input(screen.getByPlaceholderText('Search sessions, workspaces, agents…'), {
+      target: { value: 'missing' }
+    });
+    await fireEvent.click(screen.getByRole('button', { name: 'Clear filters' }));
+    expect(screen.getByRole('button', { name: 'All' })).toHaveAttribute('aria-pressed', 'true');
+    expect(screen.getByPlaceholderText('Search sessions, workspaces, agents…')).toHaveValue('');
+    expect(screen.getByText('Inspect workspace')).toBeInTheDocument();
+  });
+
+  it('hides Remote when disabled and resets an active Remote filter when disabled', async () => {
+    const { rerender } = render(DesktopSessionList, { sessions, showRemoteSessions: false });
+    expect(screen.queryByRole('button', { name: 'Remote' })).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'All' })).toHaveAttribute('aria-pressed', 'true');
+
+    await rerender({ sessions, showRemoteSessions: true });
+    await fireEvent.click(screen.getByRole('button', { name: 'Remote' }));
+    expect(screen.getByText('No matching sessions')).toBeInTheDocument();
+
+    await rerender({ sessions, showRemoteSessions: false });
+    await waitFor(() => expect(screen.getByRole('button', { name: 'All' })).toHaveAttribute('aria-pressed', 'true'));
+    expect(screen.queryByRole('button', { name: 'Remote' })).not.toBeInTheDocument();
+    expect(screen.getByText('Inspect workspace')).toBeInTheDocument();
+
+    await rerender({ sessions, showRemoteSessions: true });
+    expect(screen.getByRole('button', { name: 'Remote' })).toHaveAttribute('aria-pressed', 'false');
+  });
+
   it('hides agent names for a single-agent session list while preserving agent search', async () => {
     render(DesktopSessionList, { sessions, showAgentNames: false });
 
@@ -404,7 +472,24 @@ describe('DesktopSessionList', () => {
     await waitFor(() => expect(onOpenWorkspace).toHaveBeenCalledTimes(1));
     expect(onOpenWorkspace).toHaveBeenCalledWith('/recent');
     await fireEvent.click(screen.getByRole('button', { name: 'New session in recent' }));
-    expect(onCreateWorkspaceSession).toHaveBeenCalledWith('/recent');
+    expect(onCreateWorkspaceSession).toHaveBeenCalledWith(expect.objectContaining({ cwd: '/recent' }));
+  });
+
+  it('passes the workspace host along when creating a remote session', async () => {
+    const onCreateWorkspaceSession = vi.fn();
+    const remoteGroup = createWorkspaceGroup({
+      key: '/remote', cwd: '/remote', name: 'remote',
+      sessions: [{ ...sessions[0], cwd: '/remote', location: 'remote', remoteNodeId: 'peer-1', remoteNodeLabel: 'Laptop' }]
+    });
+    render(DesktopSessionList, {
+      workspaceGroups: [{ ...remoteGroup, location: 'remote', remoteMachines: [{ id: 'peer-1', label: 'Laptop' }] }],
+      onCreateWorkspaceSession
+    });
+
+    await fireEvent.click(screen.getByRole('button', { name: 'New session in remote' }));
+    expect(onCreateWorkspaceSession).toHaveBeenCalledWith(expect.objectContaining({
+      cwd: '/remote', location: 'remote', remoteMachines: [{ id: 'peer-1', label: 'Laptop' }]
+    }));
   });
 
   it('retries an uninitialized workspace after the catalog generation changes', async () => {
diff --git a/src/lib/components/session/SessionHeader.svelte b/src/lib/components/session/SessionHeader.svelte
index e02b517..820e158 100644
--- a/src/lib/components/session/SessionHeader.svelte
+++ b/src/lib/components/session/SessionHeader.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
-  import { ArrowLeft, Bug, FileCog, Info, RefreshCw } from '@lucide/svelte';
+  import { ArrowLeft, Bug, FileCog, Info, Network, RefreshCw } from '@lucide/svelte';
+  import { Tooltip } from 'bits-ui';
   import CopyTextChip from '$lib/components/primitives/CopyTextChip.svelte';
   import SessionIdChip from '$lib/components/primitives/SessionIdChip.svelte';
   import SessionContextDial from '$lib/components/session/SessionContextDial.svelte';
@@ -12,6 +13,7 @@
     title,
     workspace,
     workspacePath = null,
+    remoteHost = null,
     agentName,
     profileLabel = null,
     updatedAt,
@@ -28,6 +30,7 @@
     workspace: string;
     /** Full project path; when present the workspace name becomes click-to-copy. */
     workspacePath?: string | null;
+    remoteHost?: string | null;
     agentName?: string;
     /** Display label of the profile this session was started with; null hides the chip. */
     profileLabel?: string | null;
@@ -62,6 +65,21 @@
   });
 </script>
 
+{#snippet remoteHostIcon()}
+  {#if remoteHost}
+    <Tooltip.Provider delayDuration={250} skipDelayDuration={80}>
+      <Tooltip.Root disableHoverableContent>
+        <Tooltip.Trigger class="session-header-remote-indicator" type="button" aria-label={`Remote session on ${remoteHost}`}>
+          <Network size={12} aria-hidden="true" />
+        </Tooltip.Trigger>
+        <Tooltip.Portal>
+          <Tooltip.Content class="app-tooltip-content" sideOffset={6}>Remote session on {remoteHost}</Tooltip.Content>
+        </Tooltip.Portal>
+      </Tooltip.Root>
+    </Tooltip.Provider>
+  {/if}
+{/snippet}
+
 <header class="session-header">
   <button class="icon-btn session-header-back" type="button" aria-label="Back to sessions" title="Back to sessions" onclick={onBack}>
     <ArrowLeft size={17} />
@@ -70,6 +88,7 @@
   <div class="session-header-identity">
     <h1>{title}</h1>
     <div class="session-header-mobile-meta" aria-label="Session context">
+      {@render remoteHostIcon()}
       <span class="session-header-mobile-workspace" title={workspace}>{workspace}</span>
       {#if session.sessionId}
         <span aria-hidden="true">·</span>
@@ -85,6 +104,7 @@
         ></span>
         <span class="session-row-status-tooltip" role="tooltip">{status.label}</span>
       </span>
+      {@render remoteHostIcon()}
       <CopyTextChip class="session-header-workspace" value={workspacePath ?? workspace} display={workspace} title="Copy project path" />
       {#if session.sessionId}
         <span class="session-header-session-id"><span aria-hidden="true">·</span><SessionIdChip sessionId={session.sessionId} /></span>
diff --git a/src/lib/components/session/SessionHeader.test.ts b/src/lib/components/session/SessionHeader.test.ts
index db9a44d..7ae7480 100644
--- a/src/lib/components/session/SessionHeader.test.ts
+++ b/src/lib/components/session/SessionHeader.test.ts
@@ -34,9 +34,31 @@ describe('SessionHeader', () => {
     expect(within(mobileContext).getByText('querymt-desktop')).toBeInTheDocument();
     expect(within(mobileContext).getByText('session-1')).toBeInTheDocument();
     expect(screen.getByLabelText('Status: Ready')).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: /Remote session on/ })).not.toBeInTheDocument();
     expect(document.querySelector('.session-header-context')).toBeNull();
   });
 
+  it('shows an icon-only remote host tooltip before the workspace on desktop and mobile', async () => {
+    const props = {
+      session: session(), title: 'Remote task', workspace: 'querymt-desktop',
+      updatedAt: 'Just now', remoteHost: 'flkr'
+    };
+    const { rerender } = render(SessionHeader, props);
+    const desktopMeta = document.querySelector<HTMLElement>('.session-header-meta');
+    const mobileMeta = screen.getByLabelText('Session context');
+    const desktopIcon = within(desktopMeta!).getByRole('button', { name: 'Remote session on flkr' });
+    const mobileIcon = within(mobileMeta).getByRole('button', { name: 'Remote session on flkr' });
+    expect(desktopIcon.querySelector('.lucide-network')).not.toBeNull();
+    expect(mobileIcon.querySelector('.lucide-network')).not.toBeNull();
+    expect(desktopIcon.nextElementSibling).toHaveClass('session-header-workspace');
+    expect(mobileIcon.nextElementSibling).toHaveClass('session-header-mobile-workspace');
+    await fireEvent.pointerEnter(desktopIcon);
+    expect(await screen.findByText('Remote session on flkr', { selector: '.app-tooltip-content' })).toBeInTheDocument();
+
+    await rerender({ ...props, remoteHost: null });
+    expect(screen.queryByRole('button', { name: 'Remote session on flkr' })).not.toBeInTheDocument();
+  });
+
   it('packs header widgets left in status, path, id, profile, context, time order', () => {
     render(SessionHeader, {
       session: session({
diff --git a/src/lib/components/settings/GeneralSettingsPanel.svelte b/src/lib/components/settings/GeneralSettingsPanel.svelte
index 403a0d3..1729b11 100644
--- a/src/lib/components/settings/GeneralSettingsPanel.svelte
+++ b/src/lib/components/settings/GeneralSettingsPanel.svelte
@@ -4,6 +4,7 @@
   import AppSwitch from '$lib/components/primitives/AppSwitch.svelte';
   import type { ImageSendMode } from '$lib/domain/types';
   import { chatPreferencesStore } from '$lib/stores/chat-preferences.svelte';
+  import { agentsStore } from '$lib/stores/agents.svelte';
   import { windowDecorationsStore } from '$lib/stores/window-decorations.svelte';
 
   let advancedOpen = $state(false);
@@ -29,6 +30,21 @@
     <p>Everyday preferences for how QueryMT looks and behaves.</p>
   </div>
 
+  <div class="settings-simple-row">
+    <div class="settings-simple-main">
+      <h3>Show remote sessions</h3>
+      <p>Include sessions from peers selected in Mesh.</p>
+    </div>
+    <AppSwitch
+      checked={chatPreferencesStore.showRemoteSessions}
+      ariaLabel="Show remote sessions"
+      onCheckedChange={(checked) => {
+        chatPreferencesStore.setShowRemoteSessions(checked);
+        void agentsStore.refreshAllSessions();
+      }}
+    />
+  </div>
+
   <div class="settings-advanced">
     <button class="settings-advanced-trigger" type="button" aria-expanded={advancedOpen} onclick={() => (advancedOpen = !advancedOpen)}>
       <span>
diff --git a/src/lib/domain/sessions.test.ts b/src/lib/domain/sessions.test.ts
index f738a4b..d90f695 100644
--- a/src/lib/domain/sessions.test.ts
+++ b/src/lib/domain/sessions.test.ts
@@ -45,10 +45,35 @@ describe('session list request meta', () => {
       cwd: '/tmp/work',
       cursor: '10'
     });
+    expect(buildListSessionsRequest({ remoteNodeIds: ['node-1'] })._meta).toEqual({
+      session_scope: 'root', remoteNodeIds: ['node-1']
+    });
   });
 });
 
 describe('session relationship metadata', () => {
+  it('maps remote location and peer identity without attachment', () => {
+    const [session] = mapAcpSessionsToDesktopSessions(
+      [createSession({ location: 'remote', nodeId: 'peer-1', nodeLabel: 'Laptop', connectionState: 'disconnected' })],
+      { agentId: 'agent-1', agentName: 'QueryMT' }
+    );
+    expect(session).toMatchObject({ location: 'remote', remoteNodeId: 'peer-1', remoteNodeLabel: 'Laptop', remoteConnectionState: 'disconnected' });
+  });
+
+  it('maps only owner-supplied remote profile metadata', () => {
+    const [remote] = mapAcpSessionsToDesktopSessions(
+      [createSession({ location: 'remote', nodeId: 'peer-1', profileId: 'owner-profile', profileLabel: 'Owner Profile' })],
+      { agentId: 'agent-1', agentName: 'QueryMT' }
+    );
+    expect(remote).toMatchObject({ remoteProfileId: 'owner-profile', remoteProfileLabel: 'Owner Profile' });
+    const [local] = mapAcpSessionsToDesktopSessions(
+      [createSession({ profileId: 'owner-profile', profileLabel: 'Owner Profile' })],
+      { agentId: 'agent-1', agentName: 'QueryMT' }
+    );
+    expect(local.remoteProfileId).toBeUndefined();
+    expect(local.remoteProfileLabel).toBeUndefined();
+  });
+
   it('maps durable fork hierarchy metadata from ACP session info', () => {
     const [session] = mapAcpSessionsToDesktopSessions(
       [
diff --git a/src/lib/domain/sessions.ts b/src/lib/domain/sessions.ts
index 0ccc703..8d435c9 100644
--- a/src/lib/domain/sessions.ts
+++ b/src/lib/domain/sessions.ts
@@ -87,10 +87,12 @@ export function buildSessionKey(agentId: string, sessionId: string): string {
 export function buildListSessionsRequest(input: {
   cwd?: string | null;
   cursor?: string | null;
+  remoteNodeIds?: string[];
 } = {}): ListSessionsRequest {
   const request: ListSessionsRequest = {
     _meta: { session_scope: DEFAULT_SESSION_LIST_SCOPE }
   };
+  if (input.remoteNodeIds?.length) request._meta = { ...request._meta, remoteNodeIds: input.remoteNodeIds };
   if (input.cwd) request.cwd = input.cwd;
   if (input.cursor) request.cursor = input.cursor;
   return request;
@@ -122,7 +124,13 @@ export function mapAcpSessionsToDesktopSessions(
     runtimeId: agent.agentId,
     runtimeName: agent.agentName,
     source: 'acp',
-    location: 'local',
+    location: session._meta?.location === 'remote' && typeof session._meta.nodeId === 'string' ? 'remote' : 'local',
+    remoteNodeId: typeof session._meta?.nodeId === 'string' ? session._meta.nodeId : undefined,
+    remoteNodeLabel: typeof session._meta?.nodeLabel === 'string' ? session._meta.nodeLabel : undefined,
+    remoteProfileId: session._meta?.location === 'remote' && typeof session._meta.profileId === 'string' ? session._meta.profileId : undefined,
+    remoteProfileLabel: session._meta?.location === 'remote' && typeof session._meta.profileLabel === 'string' ? session._meta.profileLabel : undefined,
+    remoteConnectionState: session._meta?.connectionState === 'disconnected' ? 'disconnected' :
+      session._meta?.connectionState === 'available' ? 'available' : undefined,
     status: inferSessionStatus(session),
     ...readSessionRelationshipMeta(session)
   }));
diff --git a/src/lib/domain/types.ts b/src/lib/domain/types.ts
index 4ee3eef..a2fde71 100644
--- a/src/lib/domain/types.ts
+++ b/src/lib/domain/types.ts
@@ -87,6 +87,9 @@ export interface DesktopSessionSummary {
   location?: 'local' | 'remote';
   remoteNodeId?: string;
   remoteNodeLabel?: string;
+  remoteProfileId?: string;
+  remoteProfileLabel?: string;
+  remoteConnectionState?: 'available' | 'disconnected';
   status: SessionStatus;
   parentSessionId?: string | null;
   forkOrigin?: string | null;
diff --git a/src/lib/querymt/generated/types.ts b/src/lib/querymt/generated/types.ts
index d3411bc..e170562 100644
--- a/src/lib/querymt/generated/types.ts
+++ b/src/lib/querymt/generated/types.ts
@@ -1158,6 +1158,8 @@ export interface RemoteSessionAttachInfo {
 	node_id: string;
 	attached: boolean;
 	config_options: Array<any>;
+	profile_id?: string | null;
+	profile_label?: string | null;
 	snapshot: any;
 }
 
@@ -1173,7 +1175,8 @@ export interface RemoteSessionInfo {
 	title?: string;
 	cwd?: string;
 	updated_at?: string;
-	profile_id?: string;
+	profile_id?: string | null;
+	profile_label?: string | null;
 	model_id?: string;
 }
 
diff --git a/src/lib/stores/agents.svelte.test.ts b/src/lib/stores/agents.svelte.test.ts
index b317405..6ec3a22 100644
--- a/src/lib/stores/agents.svelte.test.ts
+++ b/src/lib/stores/agents.svelte.test.ts
@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { RequestError, type InitializeResponse, type PromptResponse, type SessionConfigOption, type SessionNotification, type SetSessionConfigOptionRequest } from '@agentclientprotocol/sdk';
-import type { AgentConfig, ModelEntry, PromptAttachment, PromptSendOptions } from '$lib/domain/types';
+import { RequestError, type InitializeResponse, type PromptResponse, type SessionConfigOption, type SessionInfo, type SessionNotification, type SetSessionConfigOptionRequest } from '@agentclientprotocol/sdk';
+import type { AgentConfig, DesktopSessionSummary, ModelEntry, PromptAttachment, PromptSendOptions } from '$lib/domain/types';
 import { findModeConfigOption, findReasoningConfigOption, getModelSelectionKey } from '$lib/querymt/config-options';
 import { QMT_METHOD_MESH_NODES, QMT_METHOD_MESH_STATUS } from '$lib/querymt/querymt-extensions';
 import {
@@ -11,6 +11,7 @@ import {
   type MeshInviteListInfo,
   type MeshNodesInfo,
   type MeshStatusInfo,
+  type RemoteSessionAttachInfo,
   type SetDelegateModelRequest,
   SessionInputDelivery,
   SessionInputState,
@@ -25,6 +26,7 @@ import { tick } from 'svelte';
 import { DesktopAcpClient } from '$lib/querymt/acp-client';
 import { startAgent } from '$native';
 import { AgentsStore } from './agents.svelte';
+import { chatPreferencesStore } from './chat-preferences.svelte';
 import { inboxStore } from './inbox.svelte';
 import { DEFAULT_SESSION_LIST_SCOPE } from '$lib/domain/sessions';
 
@@ -59,9 +61,7 @@ const mockClient = vi.hoisted(() => {
       sessionId: 'session-1',
       configOptions: []
     })),
-    listSessions: vi.fn(async (): Promise<{
-      sessions: Array<{ sessionId: string; title: string; cwd: string; updatedAt: string }>
-    }> => ({ sessions: [] })),
+    listSessions: vi.fn(async (): Promise<{ sessions: SessionInfo[]; nextCursor?: string }> => ({ sessions: [] })),
     deleteSession: vi.fn(async () => undefined),
     loadSession: vi.fn(async (_sessionId?: string, _cwd?: string): Promise<{
       response: { configOptions: SessionConfigOption[]; _meta?: Record<string, unknown> };
@@ -212,7 +212,7 @@ const mockClient = vi.hoisted(() => {
     })),
     listMeshNodes: vi.fn(async (): Promise<MeshNodesInfo> => ({ nodes: [] })),
     listMeshInvites: vi.fn(async (): Promise<MeshInviteListInfo> => ({ invites: [] })),
-    attachRemoteSession: vi.fn(async () => ({
+    attachRemoteSession: vi.fn(async (): Promise<RemoteSessionAttachInfo> => ({
       session_id: 'remote-session-1',
       node_id: 'node-1',
       attached: true,
@@ -435,6 +435,7 @@ beforeEach(() => {
     queued_input_count: 0,
     run_started_at_ms: undefined
   });
+  mockClient.listSessions.mockReset().mockResolvedValue({ sessions: [] });
   mockClient.loadSession.mockReset().mockResolvedValue({ response: { configOptions: [] }, replay: [] });
   mockClient.createSession.mockReset().mockResolvedValue({ sessionId: 'session-1', configOptions: [] });
 });
@@ -448,6 +449,25 @@ afterEach(() => {
 });
 
 describe('AgentsStore connections', () => {
+  it('keeps a selected workspace peer visible as the target when it goes offline', () => {
+    const store = createStore();
+    store.setComposerAgent('agent-1');
+    store.setComposerTarget('peer-offline');
+    store.sessionsByAgent = {
+      'agent-1': [{
+        agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'remote-1', title: 'Remote task',
+        cwd: '/remote/work', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+        source: 'acp', location: 'remote', remoteNodeId: 'peer-offline',
+        remoteNodeLabel: 'Laptop', status: 'idle'
+      } satisfies DesktopSessionSummary]
+    };
+
+    expect(store.getTargetOptions('agent-1')).toEqual(expect.arrayContaining([
+      expect.objectContaining({ id: 'peer-offline', label: 'Laptop' })
+    ]));
+    expect(store.getTargetOptions(null).map((target) => target.id)).toEqual(['local']);
+  });
+
   it('subscribes to live agent logs and retains the latest 200 entries', async () => {
     type LogEvent = { payload: { agentId: string; entry: { timestamp: string; stream: 'system'; message: string } } };
     let handleLog: ((event: LogEvent) => void) | undefined;
@@ -593,8 +613,8 @@ describe('AgentsStore connections', () => {
     await store.connectAgent('agent-1');
     await store.loadSession('agent-1', 'session-child');
 
-    expect(mockClient.listSessions).toHaveBeenCalledWith(listSessionsRequest());
-    expect(mockClient.loadSession).toHaveBeenCalledWith('session-child', '/tmp/work');
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
+    expect(mockClient.loadSession).toHaveBeenCalledWith('session-child', '');
     expect(store.error).toBeNull();
     expect(store.activeSessionId).toBe('session-child');
     expect(store.sessionsByAgent['agent-1']).toEqual(expect.arrayContaining([
@@ -653,7 +673,7 @@ describe('AgentsStore connections', () => {
     await store.connectAgent('agent-1');
     await store.loadSession('agent-1', 'session-child');
 
-    expect(mockClient.listSessions).toHaveBeenCalledWith(listSessionsRequest());
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
     expect(store.error).toBeNull();
     expect(store.activeSessionId).toBe('session-child');
     expect(store.activeSession.transcript).toEqual([
@@ -714,8 +734,387 @@ describe('AgentsStore connections', () => {
     ]);
   });
 
+  it('loads a bookmarked remote deep link without scanning the session catalog', async () => {
+    const store = createStore();
+    mockClient.loadSession.mockResolvedValueOnce({
+      response: { configOptions: [], _meta: {
+        location: 'remote', nodeId: 'node-1', nodeLabel: 'Laptop',
+        cwd: '/remote/work', title: 'Remote task',
+        'querymt/sessionLoadSnapshot.v1': { audit: { events: [
+          { seq: 1, timestamp: 1, kind: { type: 'prompt_received', data: { message_id: 'm1', content: 'Remote prompt' } } }
+        ] } }
+      } }, replay: []
+    });
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(mockClient.loadSession).toHaveBeenCalledWith('remote-session-1', '');
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
+    expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
+    expect(store.sessionsByAgent['agent-1']).toEqual(expect.arrayContaining([
+      expect.objectContaining({ sessionId: 'remote-session-1', location: 'remote', remoteNodeId: 'node-1', cwd: '/remote/work' })
+    ]));
+    expect(store.activeSession.transcript).toEqual(expect.arrayContaining([
+      expect.objectContaining({ text: 'Remote prompt' })
+    ]));
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(mockClient.loadSession).toHaveBeenCalledTimes(2);
+    expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    { responseTitle: null, expectedTitle: 'Catalog title' },
+    { responseTitle: 'Response title', expectedTitle: 'Response title' }
+  ])('keeps the right remote title when discovery finishes during load ($expectedTitle)', async ({ responseTitle, expectedTitle }) => {
+    const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    await store.connectAgent('agent-1');
+
+    let resolveLoad!: (value: {
+      response: { configOptions: SessionConfigOption[]; _meta?: Record<string, unknown> };
+      replay: SessionNotification[];
+    }) => void;
+    mockClient.loadSession.mockImplementationOnce(() => new Promise((resolve) => { resolveLoad = resolve; }));
+    const loading = store.loadSession('agent-1', 'remote-session-1');
+    await vi.waitFor(() => expect(mockClient.loadSession).toHaveBeenCalledWith('remote-session-1', ''));
+
+    mockClient.listSessions.mockResolvedValueOnce({ sessions: [{
+      sessionId: 'remote-session-1', title: 'Catalog title', cwd: '/remote/work',
+      _meta: { location: 'remote', nodeId: 'node-1' }
+    }] });
+    await store.refreshSessionsForAgent('agent-1', true);
+    expect(store.sessionsByAgent['agent-1'][0].title).toBe('Catalog title');
+
+    resolveLoad({ response: { configOptions: [], _meta: {
+      location: 'remote', nodeId: 'node-1', title: responseTitle, cwd: '/remote/work'
+    } }, replay: [] });
+    await loading;
+
+    expect(store.sessionsByAgent['agent-1'][0]).toMatchObject({
+      title: expectedTitle, location: 'remote', remoteNodeId: 'node-1'
+    });
+    expect(store.workspaceSessionGroupsForLocation('remote')[0].sessions[0].title).toBe(expectedTitle);
+    expect(mockClient.listSessions).toHaveBeenCalledTimes(1);
+    expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+  });
+
+  it('uses the owner profile from remote load metadata without inventing local config options', async () => {
+    const store = createStore();
+    mockClient.loadSession.mockResolvedValueOnce({ response: { configOptions: [], _meta: {
+      location: 'remote', nodeId: 'node-1', profileId: 'owner-profile', profileLabel: 'Owner Profile'
+    } }, replay: [] });
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(store.sessionsByAgent['agent-1'][0]).toMatchObject({
+      remoteProfileId: 'owner-profile', remoteProfileLabel: 'Owner Profile'
+    });
+    expect(store.activeSession.configOptions).toEqual([]);
+    expect(store.getProfileOptions().some((option) => option.id === 'owner-profile')).toBe(false);
+  });
+
+  it('clears a stale remote profile when the owner reports no binding', async () => {
+    const store = createStore();
+    store.sessionsByAgent = { 'agent-1': [{
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'remote-session-1', title: 'Remote task',
+      cwd: '/remote', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+      source: 'acp', location: 'remote', remoteNodeId: 'node-1',
+      remoteProfileId: 'stale', remoteProfileLabel: 'Stale', status: 'idle'
+    }] };
+    mockClient.loadSession.mockResolvedValueOnce({ response: { configOptions: [], _meta: {
+      location: 'remote', nodeId: 'node-1', profileId: null, profileLabel: null
+    } }, replay: [] });
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(store.sessionsByAgent['agent-1'][0].remoteProfileId).toBeUndefined();
+    expect(store.sessionsByAgent['agent-1'][0].remoteProfileLabel).toBeUndefined();
+  });
+
+  it('does not reuse an old profile label when the owner reports a different ID', async () => {
+    const store = createStore();
+    store.sessionsByAgent = { 'agent-1': [{
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'remote-session-1', title: 'Remote task',
+      cwd: '/remote', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+      source: 'acp', location: 'remote', remoteNodeId: 'node-1',
+      remoteProfileId: 'old', remoteProfileLabel: 'Old Profile', status: 'idle'
+    }] };
+    mockClient.loadSession.mockResolvedValueOnce({ response: { configOptions: [], _meta: {
+      location: 'remote', nodeId: 'node-1', profileId: 'new'
+    } }, replay: [] });
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(store.sessionsByAgent['agent-1'][0].remoteProfileId).toBe('new');
+    expect(store.sessionsByAgent['agent-1'][0].remoteProfileLabel).toBeUndefined();
+  });
+
+  it('uses the owner profile from remote attach without local profile options', async () => {
+    const store = createStore();
+    mockClient.attachRemoteSession.mockResolvedValueOnce({
+      session_id: 'remote-session-1', node_id: 'node-1', attached: true,
+      config_options: [], profile_id: 'owner-profile', profile_label: 'Owner Profile',
+      snapshot: { audit: { events: [{ seq: 1, timestamp: 1, kind: { type: 'prompt_received', data: {
+        message_id: 'm1', content: 'Review deployment'
+      } } }] } }
+    });
+
+    await store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1');
+    expect(store.sessionsByAgent['agent-1'][0]).toMatchObject({
+      remoteProfileId: 'owner-profile', remoteProfileLabel: 'Owner Profile'
+    });
+    expect(store.activeSession.configOptions).toEqual([]);
+  });
+
+  it('shows the owner mode on remote load and updates it from a confirmed write and reload', async () => {
+    const store = createStore();
+    const modeOption = (mode: string): SessionConfigOption => ({
+      id: 'mode', name: 'Session Mode', type: 'select', currentValue: mode,
+      options: [{ value: 'build', name: 'Build' }, { value: 'plan', name: 'Plan' }, { value: 'review', name: 'Review' }]
+    });
+    mockClient.loadSession.mockResolvedValueOnce({ response: {
+      configOptions: [modeOption('plan')], _meta: { location: 'remote', nodeId: 'node-1' }
+    }, replay: [] });
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(store.activeSession.configOptions).toEqual([modeOption('plan')]);
+    expect(store.getSessionModeId('agent-1', 'remote-session-1')).toBe('plan');
+
+    mockClient.setSessionConfigOption.mockResolvedValueOnce([modeOption('review')]);
+    await store.setActiveSessionConfigOption('mode', 'review');
+    expect(mockClient.setSessionConfigOption).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 'remote-session-1', configId: 'mode', value: 'review'
+    }));
+    expect(store.getSessionModeId('agent-1', 'remote-session-1')).toBe('review');
+
+    mockClient.loadSession.mockResolvedValueOnce({ response: {
+      configOptions: [modeOption('review')], _meta: { location: 'remote', nodeId: 'node-1' }
+    }, replay: [] });
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(store.activeSession.configOptions).toEqual([modeOption('review')]);
+    expect(store.getSessionModeId('agent-1', 'remote-session-1')).toBe('review');
+  });
+
+  it('shows the confirmed owner mode after remote attach', async () => {
+    const store = createStore();
+    const modeOption: SessionConfigOption = {
+      id: 'mode', name: 'Session Mode', type: 'select', currentValue: 'plan',
+      options: [{ value: 'build', name: 'Build' }, { value: 'plan', name: 'Plan' }]
+    };
+    mockClient.attachRemoteSession.mockResolvedValueOnce({
+      session_id: 'remote-session-1', node_id: 'node-1', attached: true,
+      config_options: [modeOption], snapshot: { audit: { events: [] } }
+    });
+
+    await store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1');
+    expect(store.activeSession.configOptions).toEqual([modeOption]);
+    expect(store.getSessionModeId('agent-1', 'remote-session-1')).toBe('plan');
+  });
+
+  it('loads an unknown local deep link without remote discovery even when peers are selected', async () => {
+    const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    await store.loadSession('agent-1', 'local-session-1');
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
+    expect(mockClient.loadSession).toHaveBeenCalled();
+    expect(store.sessionsByAgent['agent-1']).toEqual(expect.arrayContaining([
+      expect.objectContaining({ sessionId: 'local-session-1', location: 'local' })
+    ]));
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+  });
+
+  it('does not scan remote peers after a known local session is missing', async () => {
+    const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    store.sessionsByAgent = { 'agent-1': [{
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'local-session-1', title: 'Local task',
+      cwd: '/tmp/work', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+      source: 'acp', location: 'local', status: 'idle'
+    }] };
+    mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32602, 'Invalid params', { message: 'session not found' }));
+
+    await store.loadSession('agent-1', 'local-session-1');
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
+    expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
+    expect(store.sessionsByAgent['agent-1'][0].location).toBe('local');
+    expect(store.activeSession.lastError).toBe('Invalid params');
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+  });
+
+  it('uses an explicit local load result over stale remote catalog metadata', async () => {
+    const store = createStore();
+    store.sessionsByAgent = { 'agent-1': [{
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'session-1', title: 'Task',
+      cwd: '/tmp/work', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+      source: 'acp', location: 'remote', remoteNodeId: 'node-1', status: 'idle'
+    }] };
+    mockClient.loadSession.mockResolvedValueOnce({ response: { configOptions: [], _meta: { location: 'local' } }, replay: [] });
+
+    await store.loadSession('agent-1', 'session-1');
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
+    expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
+    expect(store.sessionsByAgent['agent-1'][0]).toMatchObject({ location: 'local', remoteNodeId: undefined });
+  });
+
+  it('moves a corrected local session out of its stale remote workspace', async () => {
+    const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    mockClient.listSessions.mockResolvedValueOnce({ sessions: [{
+      sessionId: 'session-1', title: 'Remote task', cwd: '/remote',
+      _meta: { location: 'remote', nodeId: 'node-1' }
+    }] });
+    await store.refreshSessionsForAgent('agent-1', true);
+    mockClient.loadSession.mockResolvedValueOnce({ response: { configOptions: [], _meta: {
+      location: 'local', title: 'Local task', cwd: '/local'
+    } }, replay: [] });
+
+    await store.loadSession('agent-1', 'session-1');
+    expect(store.sessionsByAgent['agent-1'][0]).toMatchObject({ location: 'local', cwd: '/local', title: 'Local task' });
+    expect(store.workspaceSessionGroupsForLocation('remote')).toEqual([]);
+    expect(store.workspaceSessionGroupsForLocation('local')).toEqual(expect.arrayContaining([
+      expect.objectContaining({ cwd: '/local' })
+    ]));
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+  });
+
+  it('uses the direct load metadata to correct a stale local catalog entry', async () => {
+    const store = createStore();
+    store.sessionsByAgent = { 'agent-1': [{
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'session-1', title: 'Local task',
+      cwd: '/local', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+      source: 'acp', location: 'local', status: 'idle'
+    }] };
+    mockClient.loadSession.mockResolvedValueOnce({ response: { configOptions: [], _meta: {
+      location: 'remote', nodeId: 'node-1', nodeLabel: 'Laptop', title: 'Remote task', cwd: '/remote'
+    } }, replay: [] });
+
+    await store.loadSession('agent-1', 'session-1');
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
+    expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
+    expect(store.sessionsByAgent['agent-1'][0]).toMatchObject({
+      location: 'remote', remoteNodeId: 'node-1', title: 'Remote task', cwd: '/remote'
+    });
+  });
+
+  it('does not turn an offline remote into a local session or scan peers', async () => {
+    const store = createStore();
+    store.sessionsByAgent = { 'agent-1': [{
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'remote-session-1', title: 'Remote task',
+      cwd: '/remote/work', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+      source: 'acp', location: 'remote', remoteNodeId: 'node-1', status: 'idle'
+    }] };
+    mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32603, 'Remote node unavailable', {
+      category: 'remote_session_connect', code: 'node_unavailable'
+    }));
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
+    expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
+    expect(store.sessionsByAgent['agent-1'][0]).toMatchObject({ location: 'remote', remoteNodeId: 'node-1' });
+    expect(store.activeSession.lastError).toBe('Remote node unavailable');
+  });
+
+  it('discovers an unbookmarked remote only after the direct load reports it missing', async () => {
+    const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32602, 'Invalid params', { message: 'session not found' }));
+    mockClient.listSessions.mockResolvedValueOnce({ sessions: [{
+      sessionId: 'remote-session-1', title: 'Remote task', cwd: '/remote/work',
+      _meta: { location: 'remote', nodeId: 'node-1', nodeLabel: 'Laptop' }
+    }] });
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(mockClient.loadSession).toHaveBeenCalledTimes(1);
+    expect(mockClient.listSessions).toHaveBeenCalledTimes(1);
+    expect(mockClient.loadSession.mock.invocationCallOrder[0]).toBeLessThan(mockClient.listSessions.mock.invocationCallOrder[0]);
+    expect(mockClient.listSessions.mock.invocationCallOrder[0]).toBeLessThan(mockClient.attachRemoteSession.mock.invocationCallOrder[0]);
+    expect(mockClient.attachRemoteSession).toHaveBeenCalledWith({ node_id: 'node-1', session_id: 'remote-session-1' });
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+  });
+
+  it('stops remote discovery at the matching page without loading the full catalog or models', async () => {
+    const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32602, 'Invalid params', { message: 'session not found' }));
+    mockClient.listSessions
+      .mockResolvedValueOnce({ sessions: [{ sessionId: 'remote-session-1', title: 'Local collision', cwd: '/local' }], nextCursor: 'next' })
+      .mockResolvedValueOnce({ sessions: [{ sessionId: 'remote-session-1', title: 'Remote task', cwd: '/remote',
+        _meta: { location: 'remote', nodeId: 'node-1' } }], nextCursor: 'more' });
+
+    await store.connectAgent('agent-1');
+    mockClient.listModels.mockClear();
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(mockClient.listSessions).toHaveBeenCalledTimes(2);
+    expect(mockClient.listSessions).toHaveBeenNthCalledWith(2, { _meta: { session_scope: 'root', remoteNodeIds: ['node-1'] }, cursor: 'next' });
+    expect(mockClient.attachRemoteSession).toHaveBeenCalledWith({ node_id: 'node-1', session_id: 'remote-session-1' });
+    expect(mockClient.listModels).not.toHaveBeenCalled();
+    expect(store.sessionsByAgent['agent-1']).toEqual(expect.arrayContaining([
+      expect.objectContaining({ sessionId: 'remote-session-1', location: 'remote', remoteNodeId: 'node-1', cwd: '/remote' })
+    ]));
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+  });
+
+  it('uses a cached remote listing before making another catalog request', async () => {
+    const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    store.remoteSessionsByAgent = { 'agent-1': { 'node-1': {
+      node_id: 'node-1', total_count: 1,
+      sessions: [{ id: 'remote-session-1', node_id: 'node-1', title: 'Cached task', cwd: '/remote' }]
+    } } };
+    mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32602, 'Invalid params', { message: 'session not found' }));
+
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(mockClient.listSessions).not.toHaveBeenCalled();
+    expect(mockClient.attachRemoteSession).toHaveBeenCalledWith({ node_id: 'node-1', session_id: 'remote-session-1' });
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+  });
+
+  it('discovers selected remote sessions and attaches only when direct load finds no bookmark', async () => {
+    const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    mockClient.listSessions.mockResolvedValueOnce({
+      sessions: [{
+        sessionId: 'remote-session-1', title: 'Review deployment', cwd: '/srv/app',
+        updatedAt: '2026-07-29T22:30:00Z',
+        _meta: { location: 'remote', nodeId: 'node-1', nodeLabel: 'Laptop', connectionState: 'available' }
+      }]
+    });
+
+    await store.refreshSessionsForAgent('agent-1', true);
+    expect(mockClient.listSessions).toHaveBeenCalledWith({
+      _meta: { session_scope: 'root', remoteNodeIds: ['node-1'] }
+    });
+    expect(store.workspaceSessionGroupsForLocation('remote')).toEqual(expect.arrayContaining([
+      expect.objectContaining({ cwd: '/srv/app', location: 'remote' })
+    ]));
+    expect(store.workspaceSessionGroupsForLocation('local')).toEqual([]);
+    mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32602, 'Invalid params', { message: 'session not found' }));
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(mockClient.loadSession).toHaveBeenCalledWith('remote-session-1', '/srv/app');
+    expect(mockClient.listSessions).toHaveBeenCalledTimes(1);
+    expect(mockClient.loadSession.mock.invocationCallOrder[0]).toBeLessThan(mockClient.attachRemoteSession.mock.invocationCallOrder[0]);
+    expect(mockClient.attachRemoteSession).toHaveBeenCalledWith({ node_id: 'node-1', session_id: 'remote-session-1' });
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+  });
+
   it('hydrates and activates an attached remote session without reloading it immediately', async () => {
     const store = createStore();
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
     store.remoteSessionsByAgent = {
       'agent-1': {
         'node-1': {
@@ -755,6 +1154,8 @@ describe('AgentsStore connections', () => {
 
     await store.loadSession('agent-1', 'remote-session-1');
     expect(mockClient.loadSession).not.toHaveBeenCalled();
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('forks at the selected message, refreshes sessions, and inserts a fallback summary', async () => {
@@ -1979,6 +2380,45 @@ describe('AgentsStore delegate model assignments', () => {
     expect(store.canConfigureDelegateModels('agent-1')).toBe(true);
   });
 
+  it('does not offer delegate routing for a remote session when the local assignment read fails', async () => {
+    const store = createStore();
+    store.sessionsByAgent = { 'agent-1': [{
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'session-1', title: 'Remote task',
+      cwd: '/remote', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+      source: 'acp', location: 'remote', remoteNodeId: 'node-1', status: 'idle'
+    }] };
+    mockClient.loadSession.mockResolvedValueOnce({ response: { configOptions: [], _meta: {
+      location: 'remote', nodeId: 'node-1'
+    } }, replay: [] });
+    mockClient.getDelegateModels.mockRejectedValue(new Error('session is not bound to an available profile'));
+
+    await store.loadSession('agent-1', 'session-1');
+    await vi.waitFor(() => expect(store.activeDelegateAssignmentsError).toBe('session is not bound to an available profile'));
+    expect(mockClient.getDelegateModels).toHaveBeenCalledWith({ session_id: 'session-1' });
+    expect(store.canConfigureDelegateModels('agent-1')).toBe(false);
+  });
+
+  it('keeps routing available for confirmed remote roles or saved routes despite a refresh error', async () => {
+    const store = createStore();
+    selectSession(store);
+    store.sessionsByAgent = { 'agent-1': [{
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'session-1', title: 'Remote task',
+      cwd: '/remote', updatedAt: null, runtimeId: 'agent-1', runtimeName: 'QMTCODE',
+      source: 'acp', location: 'remote', remoteNodeId: 'node-1', status: 'idle'
+    }] };
+    mockClient.getDelegateModels.mockRejectedValueOnce(new Error('Transient failure'));
+    await store.connectAgent('agent-1');
+    expect(store.canConfigureDelegateModels('agent-1')).toBe(false);
+
+    store.delegateAssignmentsBySession = { 'agent-1:session-1': assignmentState };
+    expect(store.canConfigureDelegateModels('agent-1')).toBe(true);
+    store.delegateAssignmentsBySession = { 'agent-1:session-1': {
+      ...assignmentState, assignments: [],
+      orphaned_overrides: [{ agent_id: 'removed-role', model: { model_id: 'legacy/model' }, reasoning_effort: null }]
+    } };
+    expect(store.canConfigureDelegateModels('agent-1')).toBe(true);
+  });
+
   it('loads authoritative assignments with session history and writes with the current revision', async () => {
     const store = createStore();
     store.sessionsByAgent = {
@@ -4433,7 +4873,7 @@ describe('AgentsStore prompt session start', () => {
     expect(mockClient.connect).toHaveBeenCalledTimes(1);
     expect(mockClient.disconnect).not.toHaveBeenCalled();
     expect(mockClient.listSessions).toHaveBeenCalled();
-    expect(mockClient.loadSession).toHaveBeenCalledWith('session-1', '/tmp/work');
+    expect(mockClient.loadSession).toHaveBeenCalledWith('session-1', '');
     expect(store.loading).toBe(false);
     expect(store.connectionStates['remote-agent']).toBe('initialized');
     expect(store.error).toBeNull();
@@ -4482,7 +4922,7 @@ describe('AgentsStore prompt session start', () => {
     expect(mockClient.connect).toHaveBeenCalledTimes(1);
     expect(mockClient.disconnect).not.toHaveBeenCalled();
     expect(mockClient.listSessions).toHaveBeenCalled();
-    expect(mockClient.loadSession).toHaveBeenCalledWith('session-1', '/tmp/work');
+    expect(mockClient.loadSession).toHaveBeenCalledWith('session-1', '');
     expect(store.loading).toBe(false);
     expect(store.connectionStates['remote-agent']).toBe('initialized');
     expect(store.error).toBeNull();
diff --git a/src/lib/stores/agents.svelte.ts b/src/lib/stores/agents.svelte.ts
index 1cb63f9..8db8286 100644
--- a/src/lib/stores/agents.svelte.ts
+++ b/src/lib/stores/agents.svelte.ts
@@ -1,3 +1,4 @@
+import { RequestError } from '@agentclientprotocol/sdk';
 import type {
   InitializeResponse,
   ListSessionsResponse,
@@ -334,6 +335,7 @@ export class AgentsStore {
   composerModeId = $state<string>('build');
   composerReasoningId = $state<string>('auto');
   composerTargetId = $state<string>('local');
+  composerAgentId = $state<string | null>(null);
   get sessionConfigPending(): Record<string, boolean> {
     const key = this.activeAgentId && this.activeSessionId
       ? buildSessionKey(this.activeAgentId, this.activeSessionId)
@@ -446,8 +448,13 @@ export class AgentsStore {
     return this.delegateAssignmentConflictBySession[key] ?? false;
   }
 
+  private sessionVisibleInCatalog(session: DesktopSessionSummary): boolean {
+    return session.location !== 'remote' || (chatPreferencesStore.showRemoteSessions &&
+      chatPreferencesStore.remoteSessionPeers.includes(session.remoteNodeId ?? ''));
+  }
+
   get sessions(): DesktopSessionSummary[] {
-    return Object.values(this.sessionsByAgent).flat().sort((a, b) => {
+    return Object.values(this.sessionsByAgent).flat().filter((session) => this.sessionVisibleInCatalog(session)).sort((a, b) => {
       const aValue = a.updatedAt ?? '';
       const bValue = b.updatedAt ?? '';
       return bValue.localeCompare(aValue);
@@ -455,6 +462,10 @@ export class AgentsStore {
   }
 
   get workspaceSessionGroups(): WorkspaceSessionGroup[] {
+    return this.workspaceSessionGroupsForLocation('all');
+  }
+
+  workspaceSessionGroupsForLocation(location: 'all' | 'local' | 'remote'): WorkspaceSessionGroup[] {
     const sourceGroups = new Map<string, WorkspaceSessionSource[]>();
     for (const sourcesByWorkspace of Object.values(this.workspaceSessionSources)) {
       for (const source of Object.values(sourcesByWorkspace)) {
@@ -466,9 +477,13 @@ export class AgentsStore {
 
     return [...sourceGroups.entries()]
       .map(([cwd, sources]) => {
-        const sessions = deduplicateSessions(sources.flatMap((source) => source.sessions)).sort(compareSessionsByActivity);
+        const sessions = deduplicateSessions(sources.flatMap((source) => source.sessions))
+          .filter((session) => {
+            return this.sessionVisibleInCatalog(session) &&
+              (location === 'all' || (location === 'remote' ? session.location === 'remote' : session.location !== 'remote'));
+          }).sort(compareSessionsByActivity);
         const visibleLimit = this.workspaceVisibleLimits[cwd] ?? WORKSPACE_SESSION_PAGE_SIZE;
-        const latestActivity = maxTimestamp(sources.map((source) => source.latestActivity));
+        const latestActivity = maxTimestamp(sessions.map((session) => session.updatedAt));
         return {
           key: getSessionWorkspaceKey(cwd),
           cwd,
@@ -488,6 +503,7 @@ export class AgentsStore {
           )
         };
       })
+      .filter((group) => group.sessions.length > 0)
       .sort((a, b) => (b.latestActivity ?? '').localeCompare(a.latestActivity ?? ''));
   }
 
@@ -547,11 +563,12 @@ export class AgentsStore {
     if (this.activeAgentId !== agentId) return false;
     const client = this.clients.get(agentId)?.client;
     const assignments = this.activeDelegateAssignments;
+    const isRemoteSession = getSessionById(this.sessionsByAgent[agentId] ?? [], this.activeSessionId ?? '')?.location === 'remote';
     return Boolean(
       client?.supportsQuerymtMethod(QMT_METHOD_SESSION_DELEGATE_MODELS) &&
         client.supportsQuerymtMethod(QMT_METHOD_SESSION_SET_DELEGATE_MODEL) &&
         (
-          this.activeDelegateAssignmentsError !== null ||
+          (!isRemoteSession && this.activeDelegateAssignmentsError !== null) ||
           (assignments &&
             (assignments.assignments.length > 0 || assignments.orphaned_overrides.length > 0))
         )
@@ -678,6 +695,10 @@ export class AgentsStore {
     this.composerTargetId = targetId;
   }
 
+  setComposerAgent(agentId: string | null) {
+    this.composerAgentId = agentId;
+  }
+
     addPromptAttachments(attachments: PromptAttachment[]) {
     const existingIds = new Set(this.promptAttachments.map((attachment) => attachment.id));
     this.promptAttachments = [...this.promptAttachments, ...attachments.filter((attachment) => !existingIds.has(attachment.id))];
@@ -738,7 +759,7 @@ export class AgentsStore {
 
   getTargetOptions(agentId: string | null): ComposerOption[] {
     const targets: ComposerOption[] = [isEmbedded
-      ? { id: 'local', label: 'qmtcode server', description: 'Create the session on the serving qmtcode instance.' }
+      ? { id: 'local', label: 'Local', description: 'Create the session on the serving qmtcode instance.' }
       : { id: 'local', label: 'Local', description: 'Create the session on this machine.' }];
     if (!agentId) {
       return targets;
@@ -752,6 +773,16 @@ export class AgentsStore {
       });
     }
 
+    if (agentId === this.composerAgentId && this.composerTargetId !== 'local' &&
+      !targets.some((target) => target.id === this.composerTargetId)) {
+      const knownSession = this.sessionsByAgent[agentId]?.find((session) => session.remoteNodeId === this.composerTargetId);
+      targets.push({
+        id: this.composerTargetId,
+        label: knownSession?.remoteNodeLabel || this.composerTargetId,
+        description: 'Remote peer is currently unavailable.'
+      });
+    }
+
     return targets;
   }
 
@@ -1498,7 +1529,9 @@ export class AgentsStore {
   }
 
   private buildSessionListRequest(input: { cwd?: string | null; cursor?: string | null } = {}) {
-    return buildListSessionsRequest(input);
+    chatPreferencesStore.initialize();
+    const remoteNodeIds = chatPreferencesStore.showRemoteSessions ? chatPreferencesStore.remoteSessionPeers : [];
+    return buildListSessionsRequest({ ...input, remoteNodeIds });
   }
 
   private ensureSessionLoadTarget(agentId: string, sessionId: string): DesktopSessionSummary | null {
@@ -1536,6 +1569,70 @@ export class AgentsStore {
     return fallback;
   }
 
+  private async findRemoteNodeForMissingSession(agentId: string, sessionId: string, client: DesktopAcpClient): Promise<string | null> {
+    chatPreferencesStore.initialize();
+    const selectedPeers = chatPreferencesStore.showRemoteSessions ? chatPreferencesStore.remoteSessionPeers : [];
+    if (selectedPeers.length === 0) return null;
+
+    for (const nodeId of selectedPeers) {
+      if (this.remoteSessionsByAgent[agentId]?.[nodeId]?.sessions.some((session) => session.id === sessionId)) {
+        return nodeId;
+      }
+    }
+
+    if (this.completedWorkspaceDiscoveries.has(agentId)) return null;
+    const config = this.configs.find((candidate) => candidate.id === agentId);
+    if (!config) return null;
+
+    // Search only until the requested remote ID is found; a full catalog
+    // refresh also fetches every page and models before returning.
+    const seenCursors = new Set<string>();
+    let cursor: string | null = null;
+    do {
+      if (!this.isSelectedSession(agentId, sessionId)) return null;
+      const page = await client.listSessions(this.buildSessionListRequest({ cursor }));
+      if (!this.isSelectedSession(agentId, sessionId)) return null;
+      const match = page.sessions.find((session) => session.sessionId === sessionId &&
+        session._meta?.location === 'remote' && typeof session._meta.nodeId === 'string' &&
+        selectedPeers.includes(session._meta.nodeId));
+      if (match) {
+        const summary = mapAcpSessionsToDesktopSessions([match], { agentId, agentName: config.name })[0];
+        this.sessionsByAgent = {
+          ...this.sessionsByAgent,
+          [agentId]: mergeSessions(this.sessionsByAgent[agentId] ?? [], [summary])
+        };
+        this.upsertWorkspaceSessions(agentId, [summary]);
+        return summary.remoteNodeId ?? null;
+      }
+      cursor = page.nextCursor ?? null;
+      if (cursor && seenCursors.has(cursor)) break;
+      if (cursor) seenCursors.add(cursor);
+    } while (cursor);
+    return null;
+  }
+
+  private syncLoadedSessionSummary(agentId: string, summary: DesktopSessionSummary) {
+    const previous = getSessionById(this.sessionsByAgent[agentId] ?? [], summary.sessionId);
+    this.sessionsByAgent = {
+      ...this.sessionsByAgent,
+      [agentId]: mergeSessions(this.sessionsByAgent[agentId] ?? [], [summary])
+    };
+    if (previous && previous.cwd !== summary.cwd) {
+      const source = this.workspaceSessionSources[agentId]?.[previous.cwd];
+      if (source) {
+        const sessions = source.sessions.filter((session) => session.sessionId !== summary.sessionId);
+        this.workspaceSessionSources = {
+          ...this.workspaceSessionSources,
+          [agentId]: {
+            ...this.workspaceSessionSources[agentId],
+            [previous.cwd]: { ...source, sessions, latestActivity: maxTimestamp(sessions.map((session) => session.updatedAt)) }
+          }
+        };
+      }
+    }
+    this.upsertWorkspaceSessions(agentId, [summary]);
+  }
+
   private hydrateLoadedSessionSummary(agentId: string, sessionId: string, replay: SessionNotification[]) {
     const current = getSessionById(this.sessionsByAgent[agentId] ?? [], sessionId);
     if (!current) return;
@@ -2399,17 +2496,9 @@ export class AgentsStore {
       return;
     }
 
-    const summary = getSessionById(this.sessionsByAgent[agentId] ?? [], sessionId);
-    if (!summary) {
-      await this.refreshSessionsForAgent(agentId);
-    }
-
-    const target = this.ensureSessionLoadTarget(agentId, sessionId);
-    if (!target) {
-      this.error = `Unable to locate session ${sessionId}.`;
-      return;
-    }
-
+    // A deep link may arrive before catalog discovery. Do not create a local
+    // placeholder or scan every peer before the backend checks the bookmark.
+    let target = getSessionById(this.sessionsByAgent[agentId] ?? [], sessionId);
     this.acknowledgeSession(agentId, sessionId);
 
     const record = await this.connectInitializedRecord(agentId);
@@ -2417,6 +2506,7 @@ export class AgentsStore {
       this.error = 'Failed to connect to the agent.';
       return;
     }
+    target ??= getSessionById(this.sessionsByAgent[agentId] ?? [], sessionId);
 
     if (!record.initializeResponse?.agentCapabilities?.loadSession) {
       this.error = 'This agent does not support session/load.';
@@ -2474,9 +2564,29 @@ export class AgentsStore {
       this.activeSession.lastError = null;
       await tick();
       checkpoint('frontend.prepare');
-      const loaded = telemetryOperationId
-        ? await record.client.loadSession(target.sessionId, target.cwd, telemetryOperationId)
-        : await record.client.loadSession(target.sessionId, target.cwd);
+      let loaded;
+      try {
+        loaded = telemetryOperationId
+          ? await record.client.loadSession(sessionId, target?.cwd ?? '', telemetryOperationId)
+          : await record.client.loadSession(sessionId, target?.cwd ?? '');
+      } catch (error) {
+        // A never-attached remote session has no bookmark yet. Only if the
+        // direct load reports a missing ID do we fall back to discovery.
+        const message = error instanceof RequestError && error.data && typeof error.data === 'object'
+          ? (error.data as Record<string, unknown>).message : null;
+        if (error instanceof RequestError && error.code === -32602 &&
+          (message === 'session not found' || message === 'Session has no profile binding') &&
+          target?.location !== 'local' && this.isSelectedSession(agentId, sessionId)) {
+          const nodeId = target?.location === 'remote' && target.remoteNodeId
+            ? target.remoteNodeId
+            : await this.findRemoteNodeForMissingSession(agentId, sessionId, record.client);
+          if (nodeId && this.isSelectedSession(agentId, sessionId)) {
+            await this.attachRemoteSession(agentId, nodeId, sessionId);
+            return;
+          }
+        }
+        throw error;
+      }
       const loadedSession = 'response' in loaded ? loaded.response : (loaded as unknown as LoadSessionResponse);
       let replay = 'replay' in loaded ? loaded.replay : [];
       if ('finishReplay' in loaded && typeof loaded.finishReplay === 'function') {
@@ -2488,6 +2598,40 @@ export class AgentsStore {
         return;
       }
       this.lastLoadedSession = loadedSession;
+      const loadMeta = loadedSession._meta;
+      if (loadMeta?.location === 'remote' && typeof loadMeta.nodeId === 'string') {
+        const config = this.configs.find((candidate) => candidate.id === agentId);
+        if (config) {
+          // Discovery may have populated or refreshed the summary while session/load was in flight.
+          const current = getSessionById(this.sessionsByAgent[agentId] ?? [], sessionId) ?? target;
+          const summary: DesktopSessionSummary = {
+            agentId, agentName: config.name, sessionId,
+            title: typeof loadMeta.title === 'string' ? loadMeta.title : current?.title ?? sessionId,
+            cwd: typeof loadMeta.cwd === 'string' ? loadMeta.cwd : current?.cwd ?? '',
+            updatedAt: current?.updatedAt ?? null, runtimeId: agentId,
+            runtimeName: config.name, source: 'acp', location: 'remote',
+            remoteNodeId: loadMeta.nodeId,
+            remoteNodeLabel: typeof loadMeta.nodeLabel === 'string' ? loadMeta.nodeLabel : current?.remoteNodeLabel,
+            remoteProfileId: loadMeta.profileId === undefined ? current?.remoteProfileId :
+              typeof loadMeta.profileId === 'string' ? loadMeta.profileId : undefined,
+            remoteProfileLabel: loadMeta.profileLabel === undefined &&
+              (loadMeta.profileId === undefined || loadMeta.profileId === current?.remoteProfileId)
+              ? current?.remoteProfileLabel : typeof loadMeta.profileLabel === 'string' ? loadMeta.profileLabel : undefined,
+            status: current?.status ?? 'idle'
+          };
+          this.syncLoadedSessionSummary(agentId, summary);
+        }
+      } else if (loadMeta?.location === 'local' && target?.location === 'remote') {
+        this.syncLoadedSessionSummary(agentId, {
+          ...target, location: 'local',
+          title: typeof loadMeta.title === 'string' ? loadMeta.title : target.title,
+          cwd: typeof loadMeta.cwd === 'string' ? loadMeta.cwd : target.cwd,
+          remoteNodeId: undefined, remoteNodeLabel: undefined, remoteConnectionState: undefined,
+          remoteProfileId: undefined, remoteProfileLabel: undefined
+        });
+      } else if (!target) {
+        this.ensureSessionLoadTarget(agentId, sessionId);
+      }
       await Promise.resolve();
       await tick();
       await new Promise((resolve) => setTimeout(resolve, 0));
@@ -3122,6 +3266,10 @@ export class AgentsStore {
           notification.method === 'querymt/mesh/peerExpired'
         ) {
           void this.refreshMeshAvailability(agentId);
+          chatPreferencesStore.initialize();
+          if (chatPreferencesStore.showRemoteSessions && chatPreferencesStore.remoteSessionPeers.length > 0) {
+            void this.refreshSessionsForAgent(agentId, true);
+          }
         }
         if (notification.method.startsWith('querymt/auth/')) {
           void this.refreshAuthProviders(agentId);
@@ -3514,14 +3662,19 @@ export class AgentsStore {
       ...this.lastRemoteAttachByAgent,
       [agentId]: result
     };
-    return this.hydrateRemoteAttach(agentId, node_id, result, remoteSession ?? { id: session_id, node_id });
+    const discovered = this.sessionsByAgent[agentId]?.find((session) => session.sessionId === session_id && session.remoteNodeId === node_id);
+    return this.hydrateRemoteAttach(agentId, node_id, result, remoteSession ?? {
+      id: session_id, node_id, title: discovered?.title, cwd: discovered?.cwd, updated_at: discovered?.updatedAt ?? undefined,
+      profile_id: discovered?.remoteProfileId, profile_label: discovered?.remoteProfileLabel
+    });
   }
 
   private async hydrateRemoteAttach(
     agentId: string,
     nodeId: string,
     result: RemoteSessionAttachInfo,
-    remoteSession: { id: string; node_id: string; title?: string; cwd?: string; updated_at?: string }
+    remoteSession: { id: string; node_id: string; title?: string; cwd?: string; updated_at?: string;
+      profile_id?: string | null; profile_label?: string | null }
   ): Promise<string> {
     const config = this.configs.find((candidate) => candidate.id === agentId);
     if (!config) throw new Error(`Unable to locate agent ${agentId}.`);
@@ -3557,13 +3710,16 @@ export class AgentsStore {
       location: 'remote',
       remoteNodeId: nodeId,
       remoteNodeLabel: this.meshNodesByAgent[agentId]?.nodes.find((node) => node.id === nodeId)?.label,
+      remoteProfileId: result.profile_id === undefined ? remoteSession.profile_id ?? undefined : result.profile_id ?? undefined,
+      remoteProfileLabel: result.profile_label === undefined &&
+        (result.profile_id === undefined || result.profile_id === remoteSession.profile_id)
+        ? remoteSession.profile_label ?? undefined : result.profile_label ?? undefined,
       status: 'idle'
     };
     this.sessionsByAgent = {
       ...this.sessionsByAgent,
       [agentId]: mergeSessions(this.sessionsByAgent[agentId] ?? [], [summary])
     };
-    // Remote workspace origin is runtime-only until session/list exposes persisted remote bookmarks.
     this.updateWorkspaceDiscovery(config, [summary], false);
     this.hydratedRemoteSessionKeys.add(buildSessionKey(agentId, sessionId));
     await this.refreshRemoteSessionsForAgent(agentId, nodeId);
diff --git a/src/lib/stores/chat-preferences.svelte.test.ts b/src/lib/stores/chat-preferences.svelte.test.ts
index 87f5505..8032ad4 100644
--- a/src/lib/stores/chat-preferences.svelte.test.ts
+++ b/src/lib/stores/chat-preferences.svelte.test.ts
@@ -1,5 +1,8 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { ChatPreferencesStore } from './chat-preferences.svelte';
+import '@testing-library/jest-dom/vitest';
+import { cleanup, render, screen, waitFor } from '@testing-library/svelte';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import MeshNodeList from '$lib/components/mesh/MeshNodeList.svelte';
+import { ChatPreferencesStore, chatPreferencesStore } from './chat-preferences.svelte';
 
 const storageKey = 'querymt.sendShortcut';
 const imageModeStorageKey = 'querymt.imageAttachmentMode';
@@ -95,6 +98,48 @@ describe('ChatPreferencesStore', () => {
     expect(window.localStorage.getItem(inputDeliveryStorageKey)).toBe('steer');
   });
 
+  it('keeps remote listings disabled until both preferences opt in', () => {
+    const store = new ChatPreferencesStore();
+    store.initialize();
+    expect(store.showRemoteSessions).toBe(false);
+    expect(store.remoteSessionPeers).toEqual([]);
+
+    store.setRemoteSessionPeer('node-1', true);
+    store.setRemoteSessionPeer('node-1', true);
+    store.setShowRemoteSessions(true);
+    const restored = new ChatPreferencesStore();
+    restored.initialize();
+    expect(restored.showRemoteSessions).toBe(true);
+    expect(restored.remoteSessionPeers).toEqual(['node-1']);
+    restored.setRemoteSessionPeer('node-1', false);
+    expect(restored.remoteSessionPeers).toEqual([]);
+  });
+
+  it('only shows the Mesh inclusion switch while remote sessions are enabled', async () => {
+    chatPreferencesStore.setShowRemoteSessions(false);
+    chatPreferencesStore.setRemoteSessionPeer('peer-1', true);
+    const onIncludeSessions = vi.fn();
+    try {
+      render(MeshNodeList, {
+        nodes: [{ id: 'peer-1', label: 'Laptop', capabilities: [], active_sessions: 0, transport: 'lan' }],
+        onIncludeSessions
+      });
+      expect(screen.queryByRole('switch', { name: 'Include Laptop in Sessions' })).toBeNull();
+
+      chatPreferencesStore.setShowRemoteSessions(true);
+      await waitFor(() => expect(screen.getByRole('switch', { name: 'Include Laptop in Sessions' })).toHaveAttribute('aria-checked', 'true'));
+
+      chatPreferencesStore.setShowRemoteSessions(false);
+      await waitFor(() => expect(screen.queryByRole('switch', { name: 'Include Laptop in Sessions' })).toBeNull());
+      expect(onIncludeSessions).not.toHaveBeenCalled();
+      expect(chatPreferencesStore.remoteSessionPeers).toContain('peer-1');
+    } finally {
+      cleanup();
+      chatPreferencesStore.setShowRemoteSessions(false);
+      chatPreferencesStore.setRemoteSessionPeer('peer-1', false);
+    }
+  });
+
   it('ignores invalid saved input delivery values', () => {
     window.localStorage.setItem(inputDeliveryStorageKey, 'bogus');
     const store = new ChatPreferencesStore();
diff --git a/src/lib/stores/chat-preferences.svelte.ts b/src/lib/stores/chat-preferences.svelte.ts
index 0a22e01..68e58c6 100644
--- a/src/lib/stores/chat-preferences.svelte.ts
+++ b/src/lib/stores/chat-preferences.svelte.ts
@@ -7,6 +7,8 @@ const storageKey = 'querymt.sendShortcut';
 const imageModeStorageKey = 'querymt.imageAttachmentMode';
 const developerModeStorageKey = 'querymt.developerMode';
 const inputDeliveryStorageKey = 'querymt.inputDelivery';
+const showRemoteSessionsKey = 'querymt.showRemoteSessions';
+const remoteSessionPeersKey = 'querymt.remoteSessionPeers';
 
 function isSendShortcut(value: string | null): value is SendShortcut {
   return value === 'enter' || value === 'shift-enter' || value === 'ctrl-enter' || value === 'cmd-enter';
@@ -45,6 +47,8 @@ export class ChatPreferencesStore {
   imageSendMode = $state<ImageSendMode>('image');
   developerMode = $state(false);
   inputDelivery = $state<SessionInputDeliveryMode>('steer');
+  showRemoteSessions = $state(false);
+  remoteSessionPeers = $state<string[]>([]);
   initialized = $state(false);
 
   initialize() {
@@ -69,9 +73,28 @@ export class ChatPreferencesStore {
       this.inputDelivery = savedInputDelivery;
     }
 
+    this.showRemoteSessions = readStorage(showRemoteSessionsKey) === 'true';
+    try {
+      const peers: unknown = JSON.parse(readStorage(remoteSessionPeersKey) ?? '[]');
+      if (Array.isArray(peers)) this.remoteSessionPeers = peers.filter((id): id is string => typeof id === 'string' && id.length > 0);
+    } catch {
+      this.remoteSessionPeers = [];
+    }
     this.initialized = true;
   }
 
+  setShowRemoteSessions(enabled: boolean) {
+    this.showRemoteSessions = enabled;
+    writeStorage(showRemoteSessionsKey, String(enabled));
+  }
+
+  setRemoteSessionPeer(nodeId: string, enabled: boolean) {
+    this.remoteSessionPeers = enabled
+      ? [...new Set([...this.remoteSessionPeers, nodeId])]
+      : this.remoteSessionPeers.filter((id) => id !== nodeId);
+    writeStorage(remoteSessionPeersKey, JSON.stringify(this.remoteSessionPeers));
+  }
+
   setSendShortcut(shortcut: SendShortcut) {
     this.sendShortcut = shortcut;
     writeStorage(storageKey, shortcut);
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 9d5694f..1a8c0e9 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -9,6 +9,7 @@
   const onlineAgents = $derived(agentsStore.connectedAgents);
 
   const primaryAgentId = $derived(
+    agentsStore.configs.find((config) => config.enabled && config.id === agentsStore.composerAgentId)?.id ??
     onlineAgents[0]?.id ?? agentsStore.configs.find((config) => config.enabled)?.id ?? null
   );
   const showAgentBadges = $derived(onlineAgents.length > 1);
diff --git a/src/routes/__tests__/landing-session-start.test.ts b/src/routes/__tests__/landing-session-start.test.ts
index 22fb1f5..5da84dc 100644
--- a/src/routes/__tests__/landing-session-start.test.ts
+++ b/src/routes/__tests__/landing-session-start.test.ts
@@ -3,6 +3,9 @@ import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/sv
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { PromptAttachment } from '$lib/domain/types';
 import LandingPage from '../+page.svelte';
+import SessionsPage from '../sessions/+page.svelte';
+import { groupSessionsByWorkspace } from '$lib/domain/sessions';
+import type { DesktopSessionSummary } from '$lib/domain/types';
 
 function createAgentsStore() {
   return {
@@ -35,7 +38,7 @@ function createAgentsStore() {
         autoStart: true
       }
     ],
-    meshNodesByAgent: {},
+    meshNodesByAgent: {} as Record<string, { nodes: Array<{ id: string; label: string; active_sessions: number }> }>,
     activeSessionId: null as string | null,
     activeAgentId: null as string | null,
     activeSession: { runState: 'idle' },
@@ -46,6 +49,8 @@ function createAgentsStore() {
     composerModeId: 'build',
     composerReasoningId: 'auto',
     composerTargetId: 'local',
+    composerAgentId: null as string | null,
+    workspaceSessionGroups: [] as ReturnType<typeof groupSessionsByWorkspace>,
     promptAttachments: [] as PromptAttachment[],
     promptFocusToken: 0,
     loading: false,
@@ -83,13 +88,23 @@ function createAgentsStore() {
     setComposerReasoning: vi.fn((value: string) => {
       agentsStore.composerReasoningId = value;
     }),
-    setComposerTarget: vi.fn(),
+    setComposerTarget: vi.fn((value: string) => { agentsStore.composerTargetId = value; }),
+    setComposerAgent: vi.fn((value: string | null) => { agentsStore.composerAgentId = value; }),
+    requestPromptFocus: vi.fn(),
+    refreshAllSessions: vi.fn(),
+    loadWorkspaceSessions: vi.fn(),
+    loadMoreWorkspaceSessions: vi.fn(),
+    canDeleteSession: vi.fn(() => true),
+    deleteSession: vi.fn(),
     createSession: vi.fn(async () => 'session-1'),
     startSessionWithPrompt: vi.fn(async () => 'session-1'),
     getRecentModels: vi.fn(() => []),
     getRecentWorkspaces: vi.fn(() => []),
     getProfileOptions: vi.fn(() => []),
-    getTargetOptions: vi.fn(() => [{ id: 'local', label: 'Local' }])
+    getTargetOptions: vi.fn((agentId: string | null) => [
+      { id: 'local', label: 'Local' },
+      ...(agentsStore.meshNodesByAgent[agentId ?? '']?.nodes ?? []).map((node: { id: string; label: string }) => ({ id: node.id, label: node.label }))
+    ])
   };
 }
 
@@ -180,6 +195,79 @@ describe('Landing page session start', () => {
     await waitFor(() => expect(goto).toHaveBeenCalledWith('/sessions/agent-1/session-1'));
   });
 
+  it('preselects the owning remote host and agent when creating from a remote workspace', async () => {
+    agentsStore.connectedAgents.push({ ...agentsStore.connectedAgents[0], id: 'agent-2', name: 'Second agent' });
+    agentsStore.configs.push({ ...agentsStore.configs[0], id: 'agent-2', name: 'Second agent' });
+    agentsStore.meshNodesByAgent['agent-2'] = { nodes: [{ id: 'peer-2', label: 'Laptop', active_sessions: 1 }] };
+    const remoteSession: DesktopSessionSummary = {
+      agentId: 'agent-2', agentName: 'Second agent', sessionId: 'remote-1', title: 'Remote task',
+      cwd: '/remote/work', updatedAt: '2026-07-18T01:23:00Z', runtimeId: 'agent-2',
+      runtimeName: 'Second agent', source: 'acp', location: 'remote', remoteNodeId: 'peer-2',
+      remoteNodeLabel: 'Laptop', status: 'idle'
+    };
+    agentsStore.workspaceSessionGroups = groupSessionsByWorkspace([remoteSession]);
+
+    render(SessionsPage);
+    await fireEvent.click(screen.getByRole('button', { name: 'New session in work' }));
+    expect(agentsStore.setComposerCwd).toHaveBeenCalledWith('/remote/work');
+    expect(agentsStore.setComposerAgent).toHaveBeenCalledWith('agent-2');
+    expect(agentsStore.setComposerTarget).toHaveBeenCalledWith('peer-2');
+    expect(goto).toHaveBeenCalledWith('/');
+
+    cleanup();
+    render(LandingPage);
+    await fireEvent.click(screen.getByLabelText('Session options'));
+    expect(screen.getByRole('button', { name: 'Session target' })).toHaveTextContent('Laptop');
+    await fireEvent.click(screen.getByRole('button', { name: 'Start blank session' }));
+    expect(agentsStore.startSessionWithPrompt).toHaveBeenCalledWith('agent-2');
+  });
+
+  it('resets the target to local for a mixed workspace after selecting a remote host', async () => {
+    const localSession: DesktopSessionSummary = {
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'local-1', title: 'Local task',
+      cwd: '/shared', updatedAt: '2026-07-18T01:23:00Z', runtimeId: 'agent-1',
+      runtimeName: 'QMTCODE', source: 'acp', location: 'local', status: 'idle'
+    };
+    agentsStore.workspaceSessionGroups = groupSessionsByWorkspace([
+      localSession,
+      { ...localSession, sessionId: 'remote-1', location: 'remote', remoteNodeId: 'peer-1', remoteNodeLabel: 'Laptop' }
+    ]);
+    agentsStore.composerTargetId = 'peer-1';
+    agentsStore.composerAgentId = 'agent-2';
+
+    render(SessionsPage);
+    await fireEvent.click(screen.getByLabelText('New session in shared'));
+    await fireEvent.click(screen.getByRole('button', { name: 'Local' }));
+    expect(agentsStore.setComposerCwd).toHaveBeenCalledWith('/shared');
+    expect(agentsStore.setComposerTarget).toHaveBeenCalledWith('local');
+    expect(agentsStore.setComposerAgent).toHaveBeenCalledWith('agent-1');
+
+    await fireEvent.click(screen.getByLabelText('New session in shared'));
+    await fireEvent.click(screen.getByRole('button', { name: 'Laptop' }));
+    expect(agentsStore.setComposerTarget).toHaveBeenLastCalledWith('peer-1');
+    expect(agentsStore.setComposerAgent).toHaveBeenLastCalledWith('agent-1');
+  });
+
+  it('asks for the host when a remote workspace spans multiple peers', async () => {
+    const remoteSession: DesktopSessionSummary = {
+      agentId: 'agent-1', agentName: 'QMTCODE', sessionId: 'remote-1', title: 'Remote task',
+      cwd: '/shared', updatedAt: '2026-07-18T01:23:00Z', runtimeId: 'agent-1',
+      runtimeName: 'QMTCODE', source: 'acp', location: 'remote', remoteNodeId: 'peer-1',
+      remoteNodeLabel: 'Laptop', status: 'idle'
+    };
+    agentsStore.workspaceSessionGroups = groupSessionsByWorkspace([
+      remoteSession,
+      { ...remoteSession, sessionId: 'remote-2', agentId: 'agent-2', remoteNodeId: 'peer-2', remoteNodeLabel: 'Server' }
+    ]);
+
+    render(SessionsPage);
+    await fireEvent.click(screen.getByLabelText('New session in shared'));
+    expect(agentsStore.setComposerTarget).not.toHaveBeenCalled();
+    await fireEvent.click(screen.getByRole('button', { name: 'Server' }));
+    expect(agentsStore.setComposerTarget).toHaveBeenCalledWith('peer-2');
+    expect(agentsStore.setComposerAgent).toHaveBeenCalledWith('agent-2');
+  });
+
   it('hides the agent suffix when stopped or disabled agents are also configured', () => {
     agentsStore.configs.push(
       {
diff --git a/src/routes/mesh/+page.svelte b/src/routes/mesh/+page.svelte
index 9a01b48..cd77c3c 100644
--- a/src/routes/mesh/+page.svelte
+++ b/src/routes/mesh/+page.svelte
@@ -1,6 +1,5 @@
 <script lang="ts">
-  import { goto } from '$app/navigation';
-  import { LoaderCircle, Network, Plus, RefreshCw, Ticket } from '@lucide/svelte';
+  import { LoaderCircle, Network, RefreshCw, Ticket } from '@lucide/svelte';
   import MeshInviteDialog from '$lib/components/mesh/MeshInviteDialog.svelte';
   import MeshInviteList from '$lib/components/mesh/MeshInviteList.svelte';
   import MeshNodeList from '$lib/components/mesh/MeshNodeList.svelte';
@@ -10,7 +9,9 @@
   import SectionHeader from '$lib/components/primitives/SectionHeader.svelte';
   import type { CreateMeshInviteRequest, MeshInviteCreatedInfo, MeshInviteInfo } from '$lib/querymt/generated/types';
   import { agentsStore } from '$lib/stores/agents.svelte';
-  import { commandPaletteStore } from '$lib/stores/command-palette.svelte';
+  import { chatPreferencesStore } from '$lib/stores/chat-preferences.svelte';
+
+  $effect(() => chatPreferencesStore.initialize());
 
   const meshAgents = $derived.by(() =>
     agentsStore.configs.filter((config) => {
@@ -21,18 +22,14 @@
 
   let selectedAgentId = $state('');
   let refreshingMesh = $state(false);
-  let loadingNodeId = $state<string | null>(null);
   let creatingInvite = $state(false);
   let inviteDialogOpen = $state(false);
   let inviteDialogError = $state<string | null>(null);
   let inviteResult = $state<MeshInviteCreatedInfo | null>(null);
   let revokingInviteId = $state<string | null>(null);
-  let attachingSessionKey = $state<string | null>(null);
-  let dismissingSessionKey = $state<string | null>(null);
   let copiedInviteId = $state<string | null>(null);
   let copiedCreatedInvite = $state(false);
   let actionError = $state<string | null>(null);
-  let nodeErrors = $state<Record<string, string | undefined>>({});
 
   $effect(() => {
     if (!selectedAgentId && meshAgents.length > 0) selectedAgentId = meshAgents[0].id;
@@ -47,7 +44,6 @@
   const meshStatus = $derived.by(() => selectedAgentId ? agentsStore.meshStatusByAgent[selectedAgentId] ?? null : null);
   const meshNodes = $derived.by(() => selectedAgentId ? agentsStore.meshNodesByAgent[selectedAgentId]?.nodes ?? [] : []);
   const meshInvites = $derived.by(() => selectedAgentId ? agentsStore.meshInvitesByAgent[selectedAgentId]?.invites ?? [] : []);
-  const sessionsByNode = $derived.by(() => selectedAgentId ? agentsStore.remoteSessionsByAgent[selectedAgentId] ?? {} : {});
   const activeSessionCount = $derived(meshNodes.reduce((total, node) => total + node.active_sessions, 0));
   const activeInviteCount = $derived(meshInvites.filter((invite) => invite.status.toLowerCase() === 'active' && invite.expires_at * 1000 > Date.now()).length);
 
@@ -68,17 +64,10 @@
     }
   }
 
-  async function loadRemoteSessions(nodeId: string) {
-    if (!selectedAgentId) return;
-    loadingNodeId = nodeId;
-    nodeErrors = { ...nodeErrors, [nodeId]: undefined };
-    try {
-      await agentsStore.refreshRemoteSessionsForAgent(selectedAgentId, nodeId);
-    } catch (error) {
-      nodeErrors = { ...nodeErrors, [nodeId]: error instanceof Error ? error.message : 'Failed to load remote sessions.' };
-    } finally {
-      loadingNodeId = null;
-    }
+  function includeRemoteSessions(nodeId: string, enabled: boolean) {
+    if (!chatPreferencesStore.showRemoteSessions) return;
+    chatPreferencesStore.setRemoteSessionPeer(nodeId, enabled);
+    void agentsStore.refreshAllSessions();
   }
 
   function openInviteDialog() {
@@ -101,29 +90,6 @@
     }
   }
 
-  function openRemoteCreate(nodeId: string | null = null) {
-    commandPaletteStore.openRemoteCreate({ agentId: selectedAgentId || null, nodeId });
-  }
-
-  function openRemoteAttach(nodeId: string) {
-    commandPaletteStore.openRemoteAttach({ agentId: selectedAgentId || null, nodeId, sessionId: null });
-  }
-
-  async function attachRemoteSession(nodeId: string, sessionId: string) {
-    if (!selectedAgentId) return;
-    const key = `${nodeId}:${sessionId}`;
-    attachingSessionKey = key;
-    nodeErrors = { ...nodeErrors, [nodeId]: undefined };
-    try {
-      const attachedSessionId = await agentsStore.attachRemoteSession(selectedAgentId, nodeId, sessionId);
-      await goto(`/sessions/${encodeURIComponent(selectedAgentId)}/${encodeURIComponent(attachedSessionId)}`);
-    } catch (error) {
-      nodeErrors = { ...nodeErrors, [nodeId]: error instanceof Error ? error.message : 'Failed to attach remote session.' };
-    } finally {
-      if (attachingSessionKey === key) attachingSessionKey = null;
-    }
-  }
-
   async function revokeInvite(invite: MeshInviteInfo) {
     if (!selectedAgentId || !window.confirm(`Revoke invite ${invite.invite_id}? It can no longer be used to join the mesh.`)) return;
     revokingInviteId = invite.invite_id;
@@ -137,20 +103,6 @@
     }
   }
 
-  async function dismissRemoteSession(nodeId: string, sessionId: string) {
-    if (!selectedAgentId) return;
-    const key = `${nodeId}:${sessionId}`;
-    dismissingSessionKey = key;
-    nodeErrors = { ...nodeErrors, [nodeId]: undefined };
-    try {
-      await agentsStore.dismissRemoteSession(selectedAgentId, nodeId, sessionId);
-    } catch (error) {
-      nodeErrors = { ...nodeErrors, [nodeId]: error instanceof Error ? error.message : 'Failed to dismiss remote session.' };
-    } finally {
-      dismissingSessionKey = null;
-    }
-  }
-
   async function copyText(id: string, value: string, created = false) {
     try {
       await navigator.clipboard.writeText(value);
@@ -169,7 +121,7 @@
 
 <div class="settings-page mesh-page">
   <div class="page-toolbar mesh-page-toolbar">
-    <SectionHeader title="Mesh" description="Nodes, invites, and remote sessions." />
+    <SectionHeader title="Mesh" description="Manage remote nodes and invites." />
     <div class="mesh-page-actions">
       {#if meshAgents.length > 1}
         <AppSelect bind:value={selectedAgentId} options={meshAgents.map((agent) => ({ value: agent.id, label: agent.name }))} pill ariaLabel="Mesh agent" />
@@ -192,7 +144,7 @@
           <span class="state-panel-icon"><Network size={17} /></span>
           <div class="state-panel-copy">
             <strong>Mesh is not available</strong>
-            <p>Connect an agent that supports mesh status to manage nodes, invites, and remote sessions.</p>
+            <p>Connect an agent that supports mesh status to manage nodes and invites.</p>
           </div>
         </div>
       </section>
@@ -202,30 +154,13 @@
       {#if actionError}<div class="alert-error settings-section-message" role="alert">{actionError}</div>{/if}
 
       <section class="settings-section" aria-labelledby="mesh-nodes-title">
-        <div class="settings-section-header settings-section-header-action mesh-section-header">
+        <div class="settings-section-header mesh-section-header">
           <div>
             <h2 id="mesh-nodes-title">Nodes</h2>
             <p>Remote peers available through the selected agent.</p>
           </div>
-          <IconTooltipButton label="Create remote session" icon={Plus} disabled={!canRun('querymt/remote/createSession') || meshNodes.length === 0} onclick={() => openRemoteCreate()} />
         </div>
-        <MeshNodeList
-          nodes={meshNodes}
-          {sessionsByNode}
-          {loadingNodeId}
-          {attachingSessionKey}
-          {dismissingSessionKey}
-          {nodeErrors}
-          canCreate={canRun('querymt/remote/createSession')}
-          canAttach={canRun('querymt/remote/attachSession')}
-          canListSessions={canRun('querymt/remote/sessions')}
-          canDismiss={canRun('querymt/remote/dismissSession')}
-          onCreate={openRemoteCreate}
-          onOpenAttach={openRemoteAttach}
-          onAttachSession={attachRemoteSession}
-          onLoadSessions={loadRemoteSessions}
-          onDismiss={dismissRemoteSession}
-        />
+        <MeshNodeList nodes={meshNodes} onIncludeSessions={includeRemoteSessions} />
       </section>
 
       {#if selectedCapabilities?.features.mesh_invites || meshInvites.length > 0}
diff --git a/src/routes/mesh/__tests__/mesh-page.test.ts b/src/routes/mesh/__tests__/mesh-page.test.ts
index 590e1ad..42d1ecc 100644
--- a/src/routes/mesh/__tests__/mesh-page.test.ts
+++ b/src/routes/mesh/__tests__/mesh-page.test.ts
@@ -2,6 +2,7 @@ import '@testing-library/jest-dom/vitest';
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/svelte';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import MeshPage from '../+page.svelte';
+import { chatPreferencesStore } from '$lib/stores/chat-preferences.svelte';
 
 function capabilities() {
   return {
@@ -48,28 +49,26 @@ function createAgentsStore() {
     },
     remoteSessionsByAgent: {} as Record<string, Record<string, unknown>>,
     refreshMeshForAgent: vi.fn(async () => undefined),
-    refreshRemoteSessionsForAgent: vi.fn(async () => undefined),
-    attachRemoteSession: vi.fn(async () => 'remote-session-1'),
+    refreshAllSessions: vi.fn(async () => undefined),
     createMeshInvite: vi.fn(async () => ({ invite_id: 'invite-new', url: 'https://mesh.invalid/invite-new', expires_at: 0, max_uses: 1 })),
-    revokeMeshInvite: vi.fn(async () => undefined),
-    dismissRemoteSession: vi.fn(async () => undefined)
+    revokeMeshInvite: vi.fn(async () => undefined)
   };
 }
 
-const goto = vi.hoisted(() => vi.fn(async () => undefined));
 const agentsStore = vi.hoisted(() => createAgentsStore());
-const commandPaletteStore = vi.hoisted(() => ({
-  openRemoteCreate: vi.fn(),
-  openRemoteAttach: vi.fn()
-}));
 
-vi.mock('$app/navigation', () => ({ goto }));
 vi.mock('$lib/stores/agents.svelte', () => ({ agentsStore }));
-vi.mock('$lib/stores/command-palette.svelte', () => ({ commandPaletteStore }));
 
-afterEach(() => cleanup());
+afterEach(() => {
+  cleanup();
+  chatPreferencesStore.setShowRemoteSessions(false);
+  chatPreferencesStore.setRemoteSessionPeer('node-1', false);
+});
 
 beforeEach(() => {
+  chatPreferencesStore.initialize();
+  chatPreferencesStore.setShowRemoteSessions(false);
+  chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   Object.assign(agentsStore, createAgentsStore());
   vi.clearAllMocks();
   vi.stubGlobal('confirm', vi.fn(() => true));
@@ -138,99 +137,88 @@ describe('Mesh page', () => {
     expect(screen.getByRole('button', { name: 'Remote peer ID copied' })).toBeInTheDocument();
   });
 
-  it('opens node actions with selected agent and node context', async () => {
-    render(MeshPage);
+  it('orders nodes by peer ID rather than label or discovery order', () => {
+    const original = agentsStore.meshNodesByAgent['agent-1'].nodes[0];
+    agentsStore.meshNodesByAgent['agent-1'] = {
+      nodes: [
+        { ...original, id: 'peer-z', label: 'Alpha' },
+        { ...original, id: 'peer-a', label: 'Zulu' },
+        { ...original, id: 'peer-m', label: 'Beta' }
+      ]
+    };
 
-    await fireEvent.click(screen.getByRole('button', { name: 'Create session on Build server' }));
-    expect(commandPaletteStore.openRemoteCreate).toHaveBeenCalledWith({ agentId: 'agent-1', nodeId: 'node-1' });
+    render(MeshPage);
 
-    await fireEvent.click(screen.getByRole('button', { name: 'Attach session from Build server' }));
-    expect(commandPaletteStore.openRemoteAttach).toHaveBeenCalledWith({ agentId: 'agent-1', nodeId: 'node-1', sessionId: null });
+    expect(screen.getAllByRole('button', { name: /^Copy remote peer ID/ }).map((button) => button.getAttribute('title')))
+      .toEqual(['peer-a', 'peer-m', 'peer-z']);
+    expect(agentsStore.meshNodesByAgent['agent-1'].nodes.map((node) => node.id))
+      .toEqual(['peer-z', 'peer-a', 'peer-m']);
   });
 
-  it('loads sessions for only the selected node', async () => {
+  it('shows a per-node switch only while remote sessions are enabled and preserves peer choice', async () => {
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
     render(MeshPage);
-
-    await fireEvent.click(screen.getByRole('button', { name: 'Load sessions from Build server' }));
-    expect(agentsStore.refreshRemoteSessionsForAgent).toHaveBeenCalledWith('agent-1', 'node-1');
+    expect(screen.queryByRole('switch', { name: 'Include Build server in Sessions' })).not.toBeInTheDocument();
+
+    chatPreferencesStore.setShowRemoteSessions(true);
+    const inclusion = await screen.findByRole('switch', { name: 'Include Build server in Sessions' });
+    expect(inclusion).toHaveAttribute('aria-checked', 'true');
+    await fireEvent.click(inclusion);
+    expect(chatPreferencesStore.remoteSessionPeers).not.toContain('node-1');
+    expect(agentsStore.refreshAllSessions).toHaveBeenCalledOnce();
+
+    chatPreferencesStore.setShowRemoteSessions(false);
+    await waitFor(() => expect(screen.queryByRole('switch', { name: 'Include Build server in Sessions' })).not.toBeInTheDocument());
+    chatPreferencesStore.setShowRemoteSessions(true);
+    expect(await screen.findByRole('switch', { name: 'Include Build server in Sessions' })).toHaveAttribute('aria-checked', 'false');
   });
 
-  it('renders loaded remote sessions like session-list rows with attach and menu actions', async () => {
-    agentsStore.remoteSessionsByAgent = {
-      'agent-1': {
-        'node-1': {
-          node_id: 'node-1',
-          total_count: 1,
-          sessions: [{ id: 'remote-session-1', node_id: 'node-1', title: 'Review the deployment', cwd: '/srv/app', updated_at: '2026-07-29T22:30:00Z' }]
-        }
-      }
-    };
-
+  it('explains how to enable remote session inclusion when it is disabled', async () => {
     render(MeshPage);
 
-    expect(screen.getByText('Review the deployment')).toBeInTheDocument();
-    expect(screen.queryByText('Remote')).not.toBeInTheDocument();
-    expect(screen.getByText('/srv/app')).toBeInTheDocument();
-    expect(screen.queryByRole('button', { name: 'Attach Review the deployment' })).not.toBeInTheDocument();
-
-    await fireEvent.click(screen.getByRole('button', { name: 'Attach remote session Review the deployment' }));
-    await waitFor(() => expect(agentsStore.attachRemoteSession).toHaveBeenCalledWith('agent-1', 'node-1', 'remote-session-1'));
-    expect(commandPaletteStore.openRemoteAttach).not.toHaveBeenCalled();
-    expect(goto).toHaveBeenCalledWith('/sessions/agent-1/remote-session-1');
+    const info = screen.getByRole('button', { name: 'About enabling remote sessions' });
+    expect(screen.queryByRole('switch', { name: 'Include Build server in Sessions' })).not.toBeInTheDocument();
+    await fireEvent.pointerEnter(info);
+    expect(await screen.findByText('To include sessions from remote hosts in the Sessions list, enable Show remote sessions in Settings.')).toBeInTheDocument();
 
-    await fireEvent.click(screen.getByText('Review the deployment').closest('.session-row')!.querySelector('summary')!);
-    await fireEvent.click(screen.getByRole('button', { name: 'Copy remote session ID for Review the deployment' }));
-    expect(navigator.clipboard.writeText).toHaveBeenCalledWith('remote-session-1');
+    chatPreferencesStore.setShowRemoteSessions(true);
+    await waitFor(() => expect(screen.queryByRole('button', { name: 'About enabling remote sessions' })).not.toBeInTheDocument());
+    expect(screen.getByRole('switch', { name: 'Include Build server in Sessions' })).toBeInTheDocument();
   });
 
-  it('shows row-level pending feedback while a remote session attaches', async () => {
-    let resolveAttach: (() => void) | undefined;
-    agentsStore.attachRemoteSession.mockImplementationOnce(() => new Promise<string>((resolve) => (resolveAttach = () => resolve('remote-session-1'))));
-    agentsStore.remoteSessionsByAgent = {
-      'agent-1': {
-        'node-1': {
-          node_id: 'node-1',
-          total_count: 1,
-          sessions: [{ id: 'remote-session-1', node_id: 'node-1', title: 'Review the deployment' }]
-        }
-      }
-    };
-
+  it('explains the per-host inclusion switch on info icon hover', async () => {
+    chatPreferencesStore.setShowRemoteSessions(true);
     render(MeshPage);
-    await fireEvent.click(screen.getByRole('button', { name: 'Attach remote session Review the deployment' }));
-
-    expect(screen.getByRole('status', { name: 'Attaching Review the deployment' })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: 'Attach remote session Review the deployment' })).toBeDisabled();
 
-    expect(goto).not.toHaveBeenCalled();
-    resolveAttach?.();
-    await waitFor(() => expect(goto).toHaveBeenCalledWith('/sessions/agent-1/remote-session-1'));
-    expect(screen.queryByRole('status', { name: 'Attaching Review the deployment' })).not.toBeInTheDocument();
+    expect(screen.getByText('Include', { selector: '.mesh-node-inclusion span' })).toBeInTheDocument();
+    const info = screen.getByRole('button', { name: 'About including sessions from Build server' });
+    await fireEvent.pointerEnter(info);
+    expect(await screen.findByText('Include sessions from remote host Build server in the Sessions list.')).toBeInTheDocument();
   });
 
-  it('stays on Mesh and shows the node error when remote attach fails', async () => {
-    agentsStore.attachRemoteSession.mockRejectedValueOnce(new Error('Remote session unavailable'));
+  it('does not expose or fetch remote sessions within Mesh', () => {
     agentsStore.remoteSessionsByAgent = {
       'agent-1': {
         'node-1': {
-          node_id: 'node-1',
-          total_count: 1,
+          node_id: 'node-1', total_count: 1,
           sessions: [{ id: 'remote-session-1', node_id: 'node-1', title: 'Review the deployment' }]
         }
       }
     };
-
+    chatPreferencesStore.setShowRemoteSessions(true);
     render(MeshPage);
-    await fireEvent.click(screen.getByRole('button', { name: 'Attach remote session Review the deployment' }));
 
-    expect(await screen.findByText('Remote session unavailable')).toBeInTheDocument();
-    expect(goto).not.toHaveBeenCalled();
+    expect(screen.queryByText('Review the deployment')).not.toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Create session on Build server' })).not.toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Attach session from Build server' })).not.toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Load sessions from Build server' })).not.toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Create remote session' })).not.toBeInTheDocument();
   });
 
-  it('keeps management creates neutral and invite revoke visible', () => {
+  it('keeps invite management available without remote session controls', () => {
     render(MeshPage);
 
-    expect(screen.getByRole('button', { name: 'Create remote session' })).not.toHaveClass('icon-btn-primary');
+    expect(screen.queryByRole('button', { name: 'Create remote session' })).not.toBeInTheDocument();
     expect(screen.getByRole('button', { name: 'Create mesh invite' })).not.toHaveClass('icon-btn-primary');
     expect(screen.getByRole('button', { name: 'Revoke invite-1' })).toHaveClass('icon-btn-danger');
     expect(screen.queryByLabelText('More actions for invite invite-1')).not.toBeInTheDocument();
diff --git a/src/routes/sessions/+page.svelte b/src/routes/sessions/+page.svelte
index b80d1b8..7733a48 100644
--- a/src/routes/sessions/+page.svelte
+++ b/src/routes/sessions/+page.svelte
@@ -4,15 +4,25 @@
   import DesktopSessionList from '$lib/components/primitives/DesktopSessionList.svelte';
   import IconTooltipButton from '$lib/components/primitives/IconTooltipButton.svelte';
   import SectionHeader from '$lib/components/primitives/SectionHeader.svelte';
+  import type { WorkspaceSessionGroup } from '$lib/domain/sessions';
   import type { DesktopSessionSummary } from '$lib/domain/types';
   import { agentsStore } from '$lib/stores/agents.svelte';
+  import { chatPreferencesStore } from '$lib/stores/chat-preferences.svelte';
 
   const connectedAgentCount = $derived(agentsStore.connectedAgents.length);
   const disconnected = $derived(connectedAgentCount === 0);
   const refreshing = $derived(agentsStore.loading && agentsStore.workspaceSessionGroups.length > 0);
 
-  async function createWorkspaceSession(cwd: string) {
-    agentsStore.setComposerCwd(cwd);
+  async function createWorkspaceSession(group: WorkspaceSessionGroup, targetNodeId?: string) {
+    const remoteNodeId = targetNodeId && targetNodeId !== 'local' ? targetNodeId
+      : !targetNodeId && group.location === 'remote' && group.remoteMachines?.length === 1
+        ? group.remoteMachines[0].id : null;
+    const owner = group.sessions.find((session) => remoteNodeId
+      ? session.location === 'remote' && session.remoteNodeId === remoteNodeId
+      : session.location !== 'remote');
+    agentsStore.setComposerCwd(group.cwd);
+    agentsStore.setComposerAgent(owner?.agentId ?? null);
+    agentsStore.setComposerTarget(remoteNodeId ?? 'local');
     await goto('/');
     agentsStore.requestPromptFocus();
   }
@@ -49,15 +59,16 @@
       emptyMessage="Start a task and its conversation will appear here."
       {disconnected}
       showAgentNames={connectedAgentCount > 1}
+      showRemoteSessions={chatPreferencesStore.showRemoteSessions}
       showToolbarRefresh={false}
       onRefresh={() => agentsStore.refreshAllSessions()}
       onCreateSession={() => goto('/')}
       onOpenAgents={() => goto('/agents')}
       onOpenWorkspace={(cwd: string) => agentsStore.loadWorkspaceSessions(cwd)}
-      onCreateWorkspaceSession={(cwd: string) => createWorkspaceSession(cwd)}
+      onCreateWorkspaceSession={createWorkspaceSession}
       onLoadMoreWorkspace={(cwd: string) => agentsStore.loadMoreWorkspaceSessions(cwd)}
       onOpenSession={(session: DesktopSessionSummary) => openSession(session)}
-      canDeleteSession={(session: DesktopSessionSummary) => agentsStore.canDeleteSession(session.agentId)}
+      canDeleteSession={(session: DesktopSessionSummary) => session.location !== 'remote' && agentsStore.canDeleteSession(session.agentId)}
       onDeleteSession={(session: DesktopSessionSummary) => agentsStore.deleteSession(session.agentId, session.sessionId)}
     />
   </div>
diff --git a/src/routes/sessions/[agentId]/[sessionId]/+page.svelte b/src/routes/sessions/[agentId]/[sessionId]/+page.svelte
index 004fc41..eb518de 100644
--- a/src/routes/sessions/[agentId]/[sessionId]/+page.svelte
+++ b/src/routes/sessions/[agentId]/[sessionId]/+page.svelte
@@ -51,6 +51,10 @@
     return getConfigOptionChoices(option).find((choice) => choice.value === option.currentValue)?.name ?? option.currentValue;
   });
   const sessionProfileLabel = $derived.by(() => {
+    if (selectedSession?.location === 'remote') {
+      return selectedSession.remoteProfileId
+        ? selectedSession.remoteProfileLabel?.trim() || selectedSession.remoteProfileId : null;
+    }
     if (!sessionProfileId) return null;
     const option = agentsStore.getProfileOptions().find((candidate) => candidate.id === sessionProfileId);
     return option?.label ?? (sessionProfileId === 'default' ? 'Default' : sessionProfileId);
@@ -521,6 +525,7 @@
     title={selectedSession?.title ?? 'Session'}
     workspace={selectedSession ? getSessionWorkspaceName(selectedSession.cwd) : 'Unknown workspace'}
     workspacePath={selectedSession?.cwd ?? null}
+    remoteHost={selectedSession?.location === 'remote' ? (selectedSession.remoteNodeLabel?.trim() || selectedSession.remoteNodeId || 'remote host') : null}
     agentName={activeAgentCount > 1 ? (selectedSession?.agentName ?? 'Unknown agent') : undefined}
     profileLabel={sessionProfileLabel}
     updatedAt={selectedSession ? formatSessionTimestamp(selectedSession.updatedAt, relativeTimeNow) : 'Not loaded'}

From f9c40c6ec04151e400d33267b897adc0989a9d70 Mon Sep 17 00:00:00 2001
From: Ivan Zatevakhin <zatevaxin.ivan@gmail.com>
Date: Wed, 30 Sep 2026 20:11:28 +0100
Subject: [PATCH 2/4] fix(session): reject stale remote attachments and isolate
 preferences

---
 src/lib/domain/sessions.ts                |   2 +
 src/lib/stores/agents.svelte.test.ts      | 141 +++++++++++++++++++---
 src/lib/stores/agents.svelte.ts           |  74 +++++++++---
 src/lib/stores/chat-preferences.svelte.ts |   2 +
 4 files changed, 182 insertions(+), 37 deletions(-)

diff --git a/src/lib/domain/sessions.ts b/src/lib/domain/sessions.ts
index 8d435c9..2d77653 100644
--- a/src/lib/domain/sessions.ts
+++ b/src/lib/domain/sessions.ts
@@ -84,6 +84,7 @@ export function buildSessionKey(agentId: string, sessionId: string): string {
   return `${agentId}:${sessionId}`;
 }
 
+/** Build a root-session catalog request with optional workspace and selected remote peers. */
 export function buildListSessionsRequest(input: {
   cwd?: string | null;
   cursor?: string | null;
@@ -110,6 +111,7 @@ export function isRootSession(session: Pick<DesktopSessionSummary, 'parentSessio
   return !session.parentSessionId?.trim();
 }
 
+/** Preserve owner-sourced location, profile, and availability metadata in desktop summaries. */
 export function mapAcpSessionsToDesktopSessions(
   sessions: SessionInfo[],
   agent: { agentId: string; agentName: string }
diff --git a/src/lib/stores/agents.svelte.test.ts b/src/lib/stores/agents.svelte.test.ts
index 6ec3a22..08f79aa 100644
--- a/src/lib/stores/agents.svelte.test.ts
+++ b/src/lib/stores/agents.svelte.test.ts
@@ -444,6 +444,10 @@ afterEach(() => {
   while (createdStores.length > 0) {
     createdStores.pop()?.dispose();
   }
+  chatPreferencesStore.setShowRemoteSessions(false);
+  for (const nodeId of chatPreferencesStore.remoteSessionPeers) {
+    chatPreferencesStore.setRemoteSessionPeer(nodeId, false);
+  }
   vi.unstubAllGlobals();
   vi.useRealTimers();
 });
@@ -797,8 +801,6 @@ describe('AgentsStore connections', () => {
     expect(store.workspaceSessionGroupsForLocation('remote')[0].sessions[0].title).toBe(expectedTitle);
     expect(mockClient.listSessions).toHaveBeenCalledTimes(1);
     expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('uses the owner profile from remote load metadata without inventing local config options', async () => {
@@ -866,6 +868,125 @@ describe('AgentsStore connections', () => {
     expect(store.activeSession.configOptions).toEqual([]);
   });
 
+  it.each(['fallback', 'explicit'] as const)('ignores a delayed %s attach after navigating to another session', async (kind) => {
+    const store = createStore();
+    await store.connectAgent('agent-1');
+    store.remoteSessionsByAgent = { 'agent-1': { 'node-1': {
+      node_id: 'node-1', total_count: 1,
+      sessions: [{ id: 'remote-session-1', node_id: 'node-1', cwd: '/remote' }]
+    } } };
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    let resolveAttach!: (value: RemoteSessionAttachInfo) => void;
+    mockClient.attachRemoteSession.mockImplementationOnce(() => new Promise((resolve) => { resolveAttach = resolve; }));
+    if (kind === 'fallback') {
+      mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32602, 'Invalid params', { message: 'session not found' }));
+    }
+    const attaching = kind === 'fallback'
+      ? store.loadSession('agent-1', 'remote-session-1')
+      : store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1');
+    await vi.waitFor(() => expect(mockClient.attachRemoteSession).toHaveBeenCalled());
+    await store.loadSession('agent-1', 'local-session-2');
+    const selected = store.activeSession;
+    resolveAttach({
+      session_id: 'remote-session-1', node_id: 'node-1', attached: true,
+      config_options: [], snapshot: { audit: { events: [] } }
+    });
+    await attaching;
+    expect(store.activeSessionId).toBe('local-session-2');
+    expect(store.activeSession).toBe(selected);
+    expect(store.lastRemoteAttachByAgent['agent-1']).toBeUndefined();
+    store.setComposerPrompt('Stay on the selected host');
+    await store.sendPromptToActiveSession();
+    expect(mockClient.sendPrompt).toHaveBeenCalledWith('local-session-2', 'Stay on the selected host', [], expect.any(Object));
+  });
+
+  it('does not let an older load failure or cleanup change a newer pending load', async () => {
+    const store = createStore();
+    let rejectOlder!: (error: Error) => void;
+    let resolveNewer!: (value: { response: { configOptions: SessionConfigOption[] }; replay: SessionNotification[] }) => void;
+    mockClient.loadSession
+      .mockImplementationOnce(() => new Promise((_resolve, reject) => { rejectOlder = reject; }))
+      .mockImplementationOnce(() => new Promise((resolve) => { resolveNewer = resolve; }));
+    const older = store.loadSession('agent-1', 'older');
+    await vi.waitFor(() => expect(mockClient.loadSession).toHaveBeenCalledTimes(1));
+    const newer = store.loadSession('agent-1', 'newer');
+    await vi.waitFor(() => expect(mockClient.loadSession).toHaveBeenCalledTimes(2));
+    rejectOlder(new Error('Old session unavailable'));
+    await older;
+    expect(store.activeSessionId).toBe('newer');
+    expect(store.activeSession.runState).toBe('thinking');
+    expect(store.activeSession.lastError).toBeNull();
+    expect(store.sessionHistoryLoading).toBe(true);
+    expect(store.error).toBeNull();
+    resolveNewer({ response: { configOptions: [] }, replay: [] });
+    await newer;
+    expect(store.sessionHistoryLoading).toBe(false);
+  });
+
+  it('clears history loading when an explicit attach supersedes a pending load', async () => {
+    const store = createStore();
+    let resolveLoad!: (value: { response: { configOptions: SessionConfigOption[] }; replay: SessionNotification[] }) => void;
+    mockClient.loadSession.mockImplementationOnce(() => new Promise((resolve) => { resolveLoad = resolve; }));
+    const loading = store.loadSession('agent-1', 'local-session-2');
+    await vi.waitFor(() => expect(mockClient.loadSession).toHaveBeenCalled());
+    expect(store.sessionHistoryLoading).toBe(true);
+    await store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1');
+    expect(store.activeSessionId).toBe('remote-session-1');
+    expect(store.sessionHistoryLoading).toBe(false);
+    resolveLoad({ response: { configOptions: [] }, replay: [] });
+    await loading;
+    expect(store.activeSessionId).toBe('remote-session-1');
+    expect(store.sessionHistoryLoading).toBe(false);
+  });
+
+  it('ignores an older attach when navigating away and back to the same remote session', async () => {
+    const store = createStore();
+    let resolveAttach!: (value: RemoteSessionAttachInfo) => void;
+    mockClient.attachRemoteSession.mockImplementationOnce(() => new Promise((resolve) => { resolveAttach = resolve; }));
+    const attaching = store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1');
+    await vi.waitFor(() => expect(mockClient.attachRemoteSession).toHaveBeenCalled());
+    await store.loadSession('agent-1', 'local-session-2');
+    await store.loadSession('agent-1', 'remote-session-1');
+    const selected = store.activeSession;
+    resolveAttach({ session_id: 'remote-session-1', node_id: 'node-1', attached: true,
+      config_options: [], snapshot: { audit: { events: [] } } });
+    await attaching;
+    expect(store.activeSessionId).toBe('remote-session-1');
+    expect(store.activeSession).toBe(selected);
+  });
+
+  it('keeps a newer snapshot when an older load for the same session completes last', async () => {
+    const store = createStore();
+    let resolveLoad!: (value: { response: { configOptions: SessionConfigOption[] }; replay: SessionNotification[] }) => void;
+    mockClient.loadSession.mockImplementationOnce(() => new Promise((resolve) => { resolveLoad = resolve; }));
+    const older = store.loadSession('agent-1', 'remote-session-1');
+    await vi.waitFor(() => expect(mockClient.loadSession).toHaveBeenCalledTimes(1));
+    await store.loadSession('agent-1', 'local-session-2');
+    await store.loadSession('agent-1', 'remote-session-1');
+    const selected = store.activeSession;
+    resolveLoad({ response: { configOptions: [] }, replay: [] });
+    await older;
+    expect(store.activeSession).toBe(selected);
+    expect(store.activeSessionId).toBe('remote-session-1');
+  });
+
+  it.each([
+    { session_id: 'unexpected-session', node_id: 'node-1' },
+    { session_id: 'remote-session-1', node_id: 'unexpected-node' }
+  ])('rejects an attach response with mismatched identity ($session_id / $node_id)', async (identity) => {
+    const store = createStore();
+    await store.loadSession('agent-1', 'local-session-2');
+    const selected = store.activeSession;
+    mockClient.attachRemoteSession.mockResolvedValueOnce({ ...identity, attached: true,
+      config_options: [], snapshot: { audit: { events: [] } } });
+    await expect(store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1'))
+      .rejects.toThrow('Remote attachment identity does not match the requested session.');
+    expect(store.activeSession).toBe(selected);
+    expect(store.activeSessionId).toBe('local-session-2');
+    expect(store.lastRemoteAttachByAgent['agent-1']).toBeUndefined();
+  });
+
   it('shows the owner mode on remote load and updates it from a confirmed write and reload', async () => {
     const store = createStore();
     const modeOption = (mode: string): SessionConfigOption => ({
@@ -921,8 +1042,6 @@ describe('AgentsStore connections', () => {
     expect(store.sessionsByAgent['agent-1']).toEqual(expect.arrayContaining([
       expect.objectContaining({ sessionId: 'local-session-1', location: 'local' })
     ]));
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('does not scan remote peers after a known local session is missing', async () => {
@@ -941,8 +1060,6 @@ describe('AgentsStore connections', () => {
     expect(mockClient.attachRemoteSession).not.toHaveBeenCalled();
     expect(store.sessionsByAgent['agent-1'][0].location).toBe('local');
     expect(store.activeSession.lastError).toBe('Invalid params');
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('uses an explicit local load result over stale remote catalog metadata', async () => {
@@ -979,8 +1096,6 @@ describe('AgentsStore connections', () => {
     expect(store.workspaceSessionGroupsForLocation('local')).toEqual(expect.arrayContaining([
       expect.objectContaining({ cwd: '/local' })
     ]));
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('uses the direct load metadata to correct a stale local catalog entry', async () => {
@@ -1036,8 +1151,6 @@ describe('AgentsStore connections', () => {
     expect(mockClient.loadSession.mock.invocationCallOrder[0]).toBeLessThan(mockClient.listSessions.mock.invocationCallOrder[0]);
     expect(mockClient.listSessions.mock.invocationCallOrder[0]).toBeLessThan(mockClient.attachRemoteSession.mock.invocationCallOrder[0]);
     expect(mockClient.attachRemoteSession).toHaveBeenCalledWith({ node_id: 'node-1', session_id: 'remote-session-1' });
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('stops remote discovery at the matching page without loading the full catalog or models', async () => {
@@ -1060,8 +1173,6 @@ describe('AgentsStore connections', () => {
     expect(store.sessionsByAgent['agent-1']).toEqual(expect.arrayContaining([
       expect.objectContaining({ sessionId: 'remote-session-1', location: 'remote', remoteNodeId: 'node-1', cwd: '/remote' })
     ]));
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('uses a cached remote listing before making another catalog request', async () => {
@@ -1077,8 +1188,6 @@ describe('AgentsStore connections', () => {
     await store.loadSession('agent-1', 'remote-session-1');
     expect(mockClient.listSessions).not.toHaveBeenCalled();
     expect(mockClient.attachRemoteSession).toHaveBeenCalledWith({ node_id: 'node-1', session_id: 'remote-session-1' });
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('discovers selected remote sessions and attaches only when direct load finds no bookmark', async () => {
@@ -1107,8 +1216,6 @@ describe('AgentsStore connections', () => {
     expect(mockClient.listSessions).toHaveBeenCalledTimes(1);
     expect(mockClient.loadSession.mock.invocationCallOrder[0]).toBeLessThan(mockClient.attachRemoteSession.mock.invocationCallOrder[0]);
     expect(mockClient.attachRemoteSession).toHaveBeenCalledWith({ node_id: 'node-1', session_id: 'remote-session-1' });
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('hydrates and activates an attached remote session without reloading it immediately', async () => {
@@ -1154,8 +1261,6 @@ describe('AgentsStore connections', () => {
 
     await store.loadSession('agent-1', 'remote-session-1');
     expect(mockClient.loadSession).not.toHaveBeenCalled();
-    chatPreferencesStore.setShowRemoteSessions(false);
-    chatPreferencesStore.setRemoteSessionPeer('node-1', false);
   });
 
   it('forks at the selected message, refreshes sessions, and inserts a fallback summary', async () => {
diff --git a/src/lib/stores/agents.svelte.ts b/src/lib/stores/agents.svelte.ts
index 8db8286..756e854 100644
--- a/src/lib/stores/agents.svelte.ts
+++ b/src/lib/stores/agents.svelte.ts
@@ -251,6 +251,7 @@ export class AgentsStore {
   private workspaceDiscoveryPromises = new Map<string, Promise<void>>();
   private sessionListRefreshChain = new Map<string, Promise<void>>();
   private hydratedRemoteSessionKeys = new Set<string>();
+  private sessionSelectionGeneration = 0;
   private unlistenAgentLogs: UnlistenFn | null = null;
   private agentLogSubscriptionPending = false;
   private modelInfoCache = new Map<string, ModelInfo | null>();
@@ -581,6 +582,7 @@ export class AgentsStore {
   }
 
   dispose() {
+    this.sessionSelectionGeneration += 1;
     this.cancelPendingSessionNotifications();
     for (const agentId of [...this.sessionRefreshTimers.keys()]) {
       this.clearScheduledSessionRefresh(agentId);
@@ -1528,12 +1530,14 @@ export class AgentsStore {
     }
   }
 
+  /** Include remote peers only when the catalog preference explicitly enables them. */
   private buildSessionListRequest(input: { cwd?: string | null; cursor?: string | null } = {}) {
     chatPreferencesStore.initialize();
     const remoteNodeIds = chatPreferencesStore.showRemoteSessions ? chatPreferencesStore.remoteSessionPeers : [];
     return buildListSessionsRequest({ ...input, remoteNodeIds });
   }
 
+  /** Seed a missing local summary only after the backend has accepted its load. */
   private ensureSessionLoadTarget(agentId: string, sessionId: string): DesktopSessionSummary | null {
     const existing = getSessionById(this.sessionsByAgent[agentId] ?? [], sessionId);
     if (existing) return existing;
@@ -1569,7 +1573,8 @@ export class AgentsStore {
     return fallback;
   }
 
-  private async findRemoteNodeForMissingSession(agentId: string, sessionId: string, client: DesktopAcpClient): Promise<string | null> {
+  /** Search selected peers until this load finds its owner or loses selection. */
+  private async findRemoteNodeForMissingSession(agentId: string, sessionId: string, client: DesktopAcpClient, isCurrentLoad: () => boolean): Promise<string | null> {
     chatPreferencesStore.initialize();
     const selectedPeers = chatPreferencesStore.showRemoteSessions ? chatPreferencesStore.remoteSessionPeers : [];
     if (selectedPeers.length === 0) return null;
@@ -1589,9 +1594,9 @@ export class AgentsStore {
     const seenCursors = new Set<string>();
     let cursor: string | null = null;
     do {
-      if (!this.isSelectedSession(agentId, sessionId)) return null;
+      if (!isCurrentLoad()) return null;
       const page = await client.listSessions(this.buildSessionListRequest({ cursor }));
-      if (!this.isSelectedSession(agentId, sessionId)) return null;
+      if (!isCurrentLoad()) return null;
       const match = page.sessions.find((session) => session.sessionId === sessionId &&
         session._meta?.location === 'remote' && typeof session._meta.nodeId === 'string' &&
         selectedPeers.includes(session._meta.nodeId));
@@ -1611,6 +1616,7 @@ export class AgentsStore {
     return null;
   }
 
+  /** Replace load metadata and move a corrected summary to its current workspace. */
   private syncLoadedSessionSummary(agentId: string, summary: DesktopSessionSummary) {
     const previous = getSessionById(this.sessionsByAgent[agentId] ?? [], summary.sessionId);
     this.sessionsByAgent = {
@@ -2484,7 +2490,11 @@ export class AgentsStore {
     }
   }
 
+  /** Load history only while this selection generation still owns the view. */
   async loadSession(agentId: string, sessionId: string, pendingOperation: 'undo' | 'redo' | null = null) {
+    const selectionGeneration = ++this.sessionSelectionGeneration;
+    const isCurrentLoad = () => selectionGeneration === this.sessionSelectionGeneration &&
+      this.isSelectedSession(agentId, sessionId);
     const sessionKey = buildSessionKey(agentId, sessionId);
     if (
       pendingOperation === null &&
@@ -2502,6 +2512,7 @@ export class AgentsStore {
     this.acknowledgeSession(agentId, sessionId);
 
     const record = await this.connectInitializedRecord(agentId);
+    if (selectionGeneration !== this.sessionSelectionGeneration) return;
     if (!record) {
       this.error = 'Failed to connect to the agent.';
       return;
@@ -2543,6 +2554,10 @@ export class AgentsStore {
       // screen and still has content, keep the transcript rendered while the
       // fresh history loads. Resetting here collapses the scrollable content,
       // which un-pins the sticky header and makes the top panel jump vertically.
+      if (selectionGeneration !== this.sessionSelectionGeneration) {
+        telemetryStatus = 'cancelled';
+        return;
+      }
       const keepStaleContent =
         this.isSelectedSession(agentId, sessionId) &&
         (this.activeSession.transcript.length > 0 ||
@@ -2553,7 +2568,7 @@ export class AgentsStore {
         const staleRecord = this.ensureClientRecord(agentId);
         staleRecord.recentSessionUpdateKeys = [];
       } else {
-        this.resetActiveSession(agentId, sessionId);
+        this.resetActiveSession(agentId, sessionId, true);
       }
       this.activeSession.undo.pendingOperation = pendingOperation;
       // Distinguish "history is loading" from a live prompt run: both set
@@ -2563,6 +2578,10 @@ export class AgentsStore {
       this.activeSession.activityLabel = 'Loading session history...';
       this.activeSession.lastError = null;
       await tick();
+      if (!isCurrentLoad()) {
+        telemetryStatus = 'cancelled';
+        return;
+      }
       checkpoint('frontend.prepare');
       let loaded;
       try {
@@ -2576,12 +2595,13 @@ export class AgentsStore {
           ? (error.data as Record<string, unknown>).message : null;
         if (error instanceof RequestError && error.code === -32602 &&
           (message === 'session not found' || message === 'Session has no profile binding') &&
-          target?.location !== 'local' && this.isSelectedSession(agentId, sessionId)) {
+          target?.location !== 'local' && isCurrentLoad()) {
           const nodeId = target?.location === 'remote' && target.remoteNodeId
             ? target.remoteNodeId
-            : await this.findRemoteNodeForMissingSession(agentId, sessionId, record.client);
-          if (nodeId && this.isSelectedSession(agentId, sessionId)) {
-            await this.attachRemoteSession(agentId, nodeId, sessionId);
+            : await this.findRemoteNodeForMissingSession(agentId, sessionId, record.client, isCurrentLoad);
+          if (nodeId && isCurrentLoad()) {
+            await this.attachRemoteSession(agentId, nodeId, sessionId, selectionGeneration);
+            if (!isCurrentLoad()) telemetryStatus = 'cancelled';
             return;
           }
         }
@@ -2593,7 +2613,7 @@ export class AgentsStore {
         finishReplay = loaded.finishReplay;
       }
       checkpoint('frontend.acp_wait');
-      if (!this.isSelectedSession(agentId, sessionId)) {
+      if (!isCurrentLoad()) {
         telemetryStatus = 'cancelled';
         return;
       }
@@ -2640,7 +2660,7 @@ export class AgentsStore {
         replay = finishReplay();
         finishReplay = null;
       }
-      if (!this.isSelectedSession(agentId, sessionId)) {
+      if (!isCurrentLoad()) {
         telemetryStatus = 'cancelled';
         return;
       }
@@ -2709,7 +2729,7 @@ export class AgentsStore {
       }
       const drainedCount = await this.drainQueuedSessionUpdates(agentId, sessionId);
       checkpoint('frontend.queued_replay');
-      if (!this.isSelectedSession(agentId, sessionId)) {
+      if (!isCurrentLoad()) {
         telemetryStatus = 'cancelled';
         return;
       }
@@ -2741,14 +2761,14 @@ export class AgentsStore {
       this.reconcileInputStatesFromSnapshot(agentId, sessionId, loadedSession);
       if (record.client.supportsQuerymtMethod(QMT_METHOD_SESSION_RUNTIME_STATE)) {
         await this.refreshSessionRuntime(agentId, sessionId, record.client).catch(() => null);
-        if (!this.isSelectedSession(agentId, sessionId)) {
+        if (!isCurrentLoad()) {
           telemetryStatus = 'cancelled';
           return;
         }
       }
       await this.hydrateUndoStack(agentId, sessionId, record.client);
       checkpoint('frontend.undo_hydrate');
-      if (!this.isSelectedSession(agentId, sessionId)) {
+      if (!isCurrentLoad()) {
         telemetryStatus = 'cancelled';
         return;
       }
@@ -2775,6 +2795,10 @@ export class AgentsStore {
         debugEvents: this.activeSession.events.length
       });
     } catch (error) {
+      if (!isCurrentLoad()) {
+        telemetryStatus = 'cancelled';
+        return;
+      }
       telemetryStatus = 'error';
       const message = error instanceof Error ? error.message : 'Failed to load ACP session.';
       this.activeSession.runState = 'failed';
@@ -2783,7 +2807,7 @@ export class AgentsStore {
       this.error = message;
     } finally {
       finishReplay?.();
-      this.sessionHistoryLoading = false;
+      if (isCurrentLoad()) this.sessionHistoryLoading = false;
       if (heartbeat) clearInterval(heartbeat);
       await telemetryQueue;
       await finishSessionLoadTelemetry(telemetryOperationId, telemetryStatus, telemetryCounters());
@@ -3651,13 +3675,20 @@ export class AgentsStore {
     return result;
   }
 
-  async attachRemoteSession(agentId: string, node_id: string, session_id: string) {
+  /** Attach without letting a delayed response replace a newer selection. */
+  async attachRemoteSession(agentId: string, node_id: string, session_id: string, expectedGeneration?: number) {
+    const generation = expectedGeneration ?? ++this.sessionSelectionGeneration;
     const remoteSession = this.remoteSessionsByAgent[agentId]?.[node_id]?.sessions.find((session) => session.id === session_id);
     const record = await this.connectInitializedRecord(agentId);
     if (!record) {
       throw new Error('Failed to connect to the agent.');
     }
+    if (generation !== this.sessionSelectionGeneration) return session_id;
     const result = await record.client.attachRemoteSession({ node_id, session_id });
+    if (generation !== this.sessionSelectionGeneration) return session_id;
+    if (result.session_id !== session_id || result.node_id !== node_id) {
+      throw new Error('Remote attachment identity does not match the requested session.');
+    }
     this.lastRemoteAttachByAgent = {
       ...this.lastRemoteAttachByAgent,
       [agentId]: result
@@ -3666,21 +3697,23 @@ export class AgentsStore {
     return this.hydrateRemoteAttach(agentId, node_id, result, remoteSession ?? {
       id: session_id, node_id, title: discovered?.title, cwd: discovered?.cwd, updated_at: discovered?.updatedAt ?? undefined,
       profile_id: discovered?.remoteProfileId, profile_label: discovered?.remoteProfileLabel
-    });
+    }, true);
   }
 
+  /** Publish the owner's snapshot and metadata after attachment validation. */
   private async hydrateRemoteAttach(
     agentId: string,
     nodeId: string,
     result: RemoteSessionAttachInfo,
     remoteSession: { id: string; node_id: string; title?: string; cwd?: string; updated_at?: string;
-      profile_id?: string | null; profile_label?: string | null }
+      profile_id?: string | null; profile_label?: string | null },
+    preserveSelectionGeneration = false
   ): Promise<string> {
     const config = this.configs.find((candidate) => candidate.id === agentId);
     if (!config) throw new Error(`Unable to locate agent ${agentId}.`);
 
     const sessionId = result.session_id;
-    this.resetActiveSession(agentId, sessionId);
+    this.resetActiveSession(agentId, sessionId, preserveSelectionGeneration);
     const configOptions = result.config_options ?? [];
     const snapshot = activeSessionFromLoadResponse(sessionId, {
       _meta: { 'querymt/sessionLoadSnapshot.v1': result.snapshot }
@@ -4220,11 +4253,14 @@ export class AgentsStore {
     this.pendingInputsBySession = { ...this.pendingInputsBySession, [key]: pending };
   }
 
-  private resetActiveSession(agentId: string, sessionId: string) {
+  /** Reset the view, invalidating prior loads unless this operation already owns a generation. */
+  private resetActiveSession(agentId: string, sessionId: string, preserveSelectionGeneration = false) {
+    if (!preserveSelectionGeneration) this.sessionSelectionGeneration += 1;
     this.activeAgentId = agentId;
     this.activeSessionId = sessionId;
     this.activeSession = createEmptyActiveSession();
     this.activeSession.sessionId = sessionId;
+    this.sessionHistoryLoading = false;
     this.promptFailure = null;
 
     const record = this.ensureClientRecord(agentId);
diff --git a/src/lib/stores/chat-preferences.svelte.ts b/src/lib/stores/chat-preferences.svelte.ts
index 68e58c6..f90bd56 100644
--- a/src/lib/stores/chat-preferences.svelte.ts
+++ b/src/lib/stores/chat-preferences.svelte.ts
@@ -83,11 +83,13 @@ export class ChatPreferencesStore {
     this.initialized = true;
   }
 
+  /** Persist remote catalog visibility without discarding the selected peer set. */
   setShowRemoteSessions(enabled: boolean) {
     this.showRemoteSessions = enabled;
     writeStorage(showRemoteSessionsKey, String(enabled));
   }
 
+  /** Persist an idempotent inclusion preference, not a remote authorization grant. */
   setRemoteSessionPeer(nodeId: string, enabled: boolean) {
     this.remoteSessionPeers = enabled
       ? [...new Set([...this.remoteSessionPeers, nodeId])]

From aa90f06d9d8fc45eed6f7f5c486b5233a046fb0d Mon Sep 17 00:00:00 2001
From: Ivan Zatevakhin <zatevaxin.ivan@gmail.com>
Date: Wed, 30 Sep 2026 20:53:51 +0100
Subject: [PATCH 3/4] fix(session): clear loading after failed explicit
 attachment

---
 src/lib/stores/agents.svelte.test.ts | 61 ++++++++++++++++++++++++++++
 src/lib/stores/agents.svelte.ts      | 28 +++++++++----
 2 files changed, 80 insertions(+), 9 deletions(-)

diff --git a/src/lib/stores/agents.svelte.test.ts b/src/lib/stores/agents.svelte.test.ts
index 08f79aa..43a205c 100644
--- a/src/lib/stores/agents.svelte.test.ts
+++ b/src/lib/stores/agents.svelte.test.ts
@@ -940,6 +940,67 @@ describe('AgentsStore connections', () => {
     expect(store.sessionHistoryLoading).toBe(false);
   });
 
+  it.each(['connection', 'rpc', 'identity'] as const)('clears loading after an explicit attach fails during %s', async (failure) => {
+    const store = createStore();
+    let resolveLoad!: (value: { response: { configOptions: SessionConfigOption[] }; replay: SessionNotification[] }) => void;
+    mockClient.loadSession.mockImplementationOnce(() => new Promise((resolve) => { resolveLoad = resolve; }));
+    const loading = store.loadSession('agent-1', 'local-session-2');
+    await vi.waitFor(() => expect(mockClient.loadSession).toHaveBeenCalled());
+    if (failure === 'connection') {
+      vi.spyOn(store as unknown as { connectInitializedRecord(): Promise<undefined> }, 'connectInitializedRecord')
+        .mockResolvedValueOnce(undefined);
+    } else if (failure === 'rpc') {
+      mockClient.attachRemoteSession.mockRejectedValueOnce(new Error('Attach unavailable'));
+    } else {
+      mockClient.attachRemoteSession.mockResolvedValueOnce({ session_id: 'wrong-session', node_id: 'node-1', attached: true,
+        config_options: [], snapshot: { audit: { events: [] } } });
+    }
+    await expect(store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1')).rejects.toThrow();
+    expect(store.activeSessionId).toBe('local-session-2');
+    expect(store.sessionHistoryLoading).toBe(false);
+    resolveLoad({ response: { configOptions: [] }, replay: [] });
+    await loading;
+    expect(store.sessionHistoryLoading).toBe(false);
+  });
+
+  it('does not clear a newer pending load when an older explicit attach fails', async () => {
+    const store = createStore();
+    let rejectAttach!: (error: Error) => void;
+    let resolveLoad!: (value: { response: { configOptions: SessionConfigOption[] }; replay: SessionNotification[] }) => void;
+    mockClient.attachRemoteSession.mockImplementationOnce(() => new Promise((_resolve, reject) => { rejectAttach = reject; }));
+    const attaching = store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1');
+    await vi.waitFor(() => expect(mockClient.attachRemoteSession).toHaveBeenCalled());
+    mockClient.loadSession.mockImplementationOnce(() => new Promise((resolve) => { resolveLoad = resolve; }));
+    const loading = store.loadSession('agent-1', 'local-session-2');
+    await vi.waitFor(() => expect(mockClient.loadSession).toHaveBeenCalled());
+    rejectAttach(new Error('Late attach failure'));
+    await expect(attaching).rejects.toThrow('Late attach failure');
+    expect(store.sessionHistoryLoading).toBe(true);
+    expect(store.activeSessionId).toBe('local-session-2');
+    resolveLoad({ response: { configOptions: [] }, replay: [] });
+    await loading;
+    expect(store.sessionHistoryLoading).toBe(false);
+  });
+
+  it('leaves fallback attachment failure cleanup to the initiating load', async () => {
+    const store = createStore();
+    store.remoteSessionsByAgent = { 'agent-1': { 'node-1': {
+      node_id: 'node-1', total_count: 1, sessions: [{ id: 'remote-session-1', node_id: 'node-1' }]
+    } } };
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32602, 'Invalid params', { message: 'session not found' }));
+    mockClient.attachRemoteSession.mockRejectedValueOnce(new Error('Owner offline'));
+    const attach = store.attachRemoteSession.bind(store);
+    vi.spyOn(store, 'attachRemoteSession').mockImplementationOnce(async (...args) => {
+      try { return await attach(...args); }
+      finally { expect(store.sessionHistoryLoading).toBe(true); }
+    });
+    await store.loadSession('agent-1', 'remote-session-1');
+    expect(store.activeSession.lastError).toBe('Owner offline');
+    expect(store.sessionHistoryLoading).toBe(false);
+  });
+
   it('ignores an older attach when navigating away and back to the same remote session', async () => {
     const store = createStore();
     let resolveAttach!: (value: RemoteSessionAttachInfo) => void;
diff --git a/src/lib/stores/agents.svelte.ts b/src/lib/stores/agents.svelte.ts
index 756e854..2c67169 100644
--- a/src/lib/stores/agents.svelte.ts
+++ b/src/lib/stores/agents.svelte.ts
@@ -3679,15 +3679,25 @@ export class AgentsStore {
   async attachRemoteSession(agentId: string, node_id: string, session_id: string, expectedGeneration?: number) {
     const generation = expectedGeneration ?? ++this.sessionSelectionGeneration;
     const remoteSession = this.remoteSessionsByAgent[agentId]?.[node_id]?.sessions.find((session) => session.id === session_id);
-    const record = await this.connectInitializedRecord(agentId);
-    if (!record) {
-      throw new Error('Failed to connect to the agent.');
-    }
-    if (generation !== this.sessionSelectionGeneration) return session_id;
-    const result = await record.client.attachRemoteSession({ node_id, session_id });
-    if (generation !== this.sessionSelectionGeneration) return session_id;
-    if (result.session_id !== session_id || result.node_id !== node_id) {
-      throw new Error('Remote attachment identity does not match the requested session.');
+    let result: RemoteSessionAttachInfo;
+    try {
+      const record = await this.connectInitializedRecord(agentId);
+      if (generation !== this.sessionSelectionGeneration) return session_id;
+      if (!record) {
+        throw new Error('Failed to connect to the agent.');
+      }
+      result = await record.client.attachRemoteSession({ node_id, session_id });
+      if (generation !== this.sessionSelectionGeneration) return session_id;
+      if (result.session_id !== session_id || result.node_id !== node_id) {
+        throw new Error('Remote attachment identity does not match the requested session.');
+      }
+    } catch (error) {
+      // A fallback load owns its cleanup; only an explicit attachment can
+      // inherit loading from the operation it superseded.
+      if (expectedGeneration === undefined && generation === this.sessionSelectionGeneration) {
+        this.sessionHistoryLoading = false;
+      }
+      throw error;
     }
     this.lastRemoteAttachByAgent = {
       ...this.lastRemoteAttachByAgent,

From d0148b69d7b9e3a0829d1358a9efe3c1ae6d0df4 Mon Sep 17 00:00:00 2001
From: Ivan Zatevakhin <zatevaxin.ivan@gmail.com>
Date: Wed, 30 Sep 2026 21:31:07 +0100
Subject: [PATCH 4/4] fix(session): preserve attachment after catalog refresh
 failure

---
 src/lib/stores/agents.svelte.test.ts | 44 ++++++++++++++++++++++++++++
 src/lib/stores/agents.svelte.ts      |  5 +++-
 2 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/src/lib/stores/agents.svelte.test.ts b/src/lib/stores/agents.svelte.test.ts
index 43a205c..5329ab2 100644
--- a/src/lib/stores/agents.svelte.test.ts
+++ b/src/lib/stores/agents.svelte.test.ts
@@ -1048,6 +1048,50 @@ describe('AgentsStore connections', () => {
     expect(store.lastRemoteAttachByAgent['agent-1']).toBeUndefined();
   });
 
+  it.each(['fallback', 'explicit'] as const)('keeps a successful %s attachment usable when catalog refresh fails', async (kind) => {
+    const store = createStore();
+    await store.connectAgent('agent-1');
+    store.remoteSessionsByAgent = { 'agent-1': { 'node-1': {
+      node_id: 'node-1', total_count: 1, sessions: [{ id: 'remote-session-1', node_id: 'node-1' }]
+    } } };
+    chatPreferencesStore.setShowRemoteSessions(true);
+    chatPreferencesStore.setRemoteSessionPeer('node-1', true);
+    if (kind === 'fallback') {
+      mockClient.loadSession.mockRejectedValueOnce(new RequestError(-32602, 'Invalid params', { message: 'session not found' }));
+    }
+    mockClient.attachRemoteSession.mockResolvedValueOnce({
+      session_id: 'remote-session-1', node_id: 'node-1', attached: true, config_options: [],
+      snapshot: { audit: { events: [{ seq: 1, timestamp: 1, kind: { type: 'prompt_received', data: {
+        message_id: 'm1', content: 'Usable owner snapshot'
+      } } }] } }
+    });
+    const refreshError = new Error('Catalog unavailable');
+    mockClient.listRemoteSessions.mockRejectedValueOnce(refreshError);
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    try {
+      const attaching = kind === 'fallback'
+        ? store.loadSession('agent-1', 'remote-session-1')
+        : store.attachRemoteSession('agent-1', 'node-1', 'remote-session-1');
+      await expect(attaching).resolves.toBe(kind === 'fallback' ? undefined : 'remote-session-1');
+      expect(store.activeSessionId).toBe('remote-session-1');
+      expect(store.activeSession.runState).not.toBe('failed');
+      expect(store.activeSession.lastError).toBeNull();
+      expect(store.error).toBeNull();
+      expect(store.activeSession.transcript).toEqual(expect.arrayContaining([
+        expect.objectContaining({ text: 'Usable owner snapshot' })
+      ]));
+      expect(warn).toHaveBeenCalledWith('Remote session attached, but catalog refresh failed', refreshError);
+      await store.loadSession('agent-1', 'remote-session-1');
+      expect(mockClient.loadSession).toHaveBeenCalledTimes(kind === 'fallback' ? 1 : 0);
+      expect(store.activeSession.lastError).toBeNull();
+      mockClient.listRemoteSessions.mockResolvedValueOnce({ node_id: 'node-1', total_count: 0, sessions: [] });
+      await store.refreshRemoteSessionsForAgent('agent-1', 'node-1');
+      expect(store.remoteSessionsByAgent['agent-1']['node-1']?.sessions).toEqual([]);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
   it('shows the owner mode on remote load and updates it from a confirmed write and reload', async () => {
     const store = createStore();
     const modeOption = (mode: string): SessionConfigOption => ({
diff --git a/src/lib/stores/agents.svelte.ts b/src/lib/stores/agents.svelte.ts
index 2c67169..c2e4156 100644
--- a/src/lib/stores/agents.svelte.ts
+++ b/src/lib/stores/agents.svelte.ts
@@ -3765,7 +3765,10 @@ export class AgentsStore {
     };
     this.updateWorkspaceDiscovery(config, [summary], false);
     this.hydratedRemoteSessionKeys.add(buildSessionKey(agentId, sessionId));
-    await this.refreshRemoteSessionsForAgent(agentId, nodeId);
+    // Attachment is committed; a retryable catalog refresh must not fail its load.
+    await this.refreshRemoteSessionsForAgent(agentId, nodeId).catch((error) => {
+      console.warn('Remote session attached, but catalog refresh failed', error);
+    });
     return sessionId;
   }