diff --git a/.ai/contexts/session-cache.md b/.ai/contexts/session-cache.md
index 18a736b1..718056b6 100644
--- a/.ai/contexts/session-cache.md
+++ b/.ai/contexts/session-cache.md
@@ -244,19 +244,29 @@ the exact remote command, and the mutation proofs are in
   cleared and reset inside `stop()`, so a queued trailing event from before
   the stop can never reach `s.onEvent` afterwards.
 
-### Remote hosts — busy spinner (issue #242)
-
-Remote transcript-write activity feeds the same `setActivity(sessionId, active, via)`
-dispatcher in `session-activity.js` that local PTY output uses — `remote-activity-ui.js`
-calls `setActivity(sessionId, true, 'remote-watch')` on each `remote-activity` IPC event
-and arms a 20 s decay timer (one per session, reset on each event) that calls
-`setActivity(sessionId, false, 'remote-decay')` when it fires, and `seedRemoteActivity(session)`
-(called from `renderProjects`, before any row is built) applies the same call from
-`session.remoteActiveAt` on first paint so a row rendered inside the decay window starts
-busy without waiting for the next event; the visual is the shared `.cli-busy` braille
-spinner, not a separate indicator.
-
-The decay call passes `setActivity(sessionId, false, 'remote-decay', { armReady: false })`,
+### Remote hosts — busy spinner (issue #242, moved onto the remote-ssh adapter in #246 step 3)
+
+**Moved.** The mechanics below (decay timer, `armReady: false`, the F7 purge skip) are
+unchanged, but the entry point is now `public/remote-activity-ui.js`'s persistent
+`remote-ssh` `createSessionState()` adapter, not a bare `setActivity()` call — see
+`.ai/contexts/session-state.md` ("The remote-ssh adapter") for the full wiring
+(watch channel, descriptor, attach/detach) and why `setActivity()`/the Maps are
+still fed in parallel.
+
+Remote transcript-write activity feeds the adapter, which in turn still feeds the same
+`setActivity(sessionId, active, via)` dispatcher in `session-activity.js` that local PTY
+output uses (kept for two readers not yet migrated — sidebar's initial paint and the grid
+busy dot) — `remote-activity-ui.js` calls `setActivity(sessionId, true, 'remote-watch')` on
+each `remote-activity` IPC event and arms a 20 s decay timer (one per session, reset on each
+event) that calls `setActivity(sessionId, false, 'remote-decay', { armReady: false })` when
+it fires, and `seedRemoteActivity(session)` (called from `renderProjects`, before any row is
+built) applies the same call from `session.remoteActiveAt` on first paint so a row rendered
+inside the decay window starts busy without waiting for the next event; the visual is the
+shared `.cli-busy` braille spinner, not a separate indicator — the DOM write itself now goes
+through `session-activity-dom.js`'s `applyStateClasses(sessionId, snapshot)`, projecting the
+adapter's own snapshot rather than being computed inline.
+
+The decay call passes `armReady: false`,
 not the bare two-argument form local PTY callers use. 20 s of transcript silence means
 "stopped writing", not "the response is ready" — a remote adapter has no PTY to ask
 whether a turn actually ended, so a long tool call or a parent delegating to subagents
@@ -267,7 +277,8 @@ unviewed remote row as `.response-ready` on a plain inference. `armReady: false`
 you haven't looked." Separately, `app.js`'s `updateRunningIndicators` PTY-set purge skips
 rows carrying `dataset.remoteAlias` (F7) — a remote row's busy state is owned by this decay
 timer, not by local PTY presence, so it must not be cleared just because some unrelated
-local PTY started or stopped.
+local PTY started or stopped. That same per-row loop is also where `updateRunningIndicators`
+feeds the adapter's `attached` port (`setRemoteAttached(id, running)`).
 
 ### Remote hosts file-level rescan (issue #216, first half)
 
diff --git a/.ai/contexts/session-state.md b/.ai/contexts/session-state.md
index 78ac61e1..85b2a6af 100644
--- a/.ai/contexts/session-state.md
+++ b/.ai/contexts/session-state.md
@@ -6,15 +6,63 @@ what actually shipped, not the whole plan.
 
 ## Migration status
 
-- **Steps 1-2: done.** `public/session-activity.js` split into a state part
+- **Steps 1-3: done.** `public/session-activity.js` split into a state part
   (itself) and a DOM part (`public/session-activity-dom.js`); `public/session-state.js`
-  introduced and wired behind `applyActivityClasses` for **local-pty only**.
-- **Steps 3-5: pending.** `remote-activity-ui.js`/`remote-activity.js` still write
-  `sessionBusyState` directly instead of going through a `remote-ssh` adapter; there
-  is no `local-transcript` adapter; subagent attribution is not routed through
+  introduced and wired behind `applyActivityClasses` for local-pty, and behind
+  a persistent `remote-ssh` adapter (`public/remote-activity-ui.js`) for
+  remote sessions — see "The remote-ssh adapter" below.
+- **Steps 3b/4/5: pending.** The unified icon-slot markup (dot + age + spinner
+  in one element) is a separate PR (3b). There is no `local-transcript`
+  adapter (step 4). Subagent attribution is not routed through
   `session-state.js` (`agentsBusy` exists in the model but nothing local-pty feeds
   it yet — sidebar.js's `has-busy-agents` is still computed by
-  `parentHasActiveSubagent()`, independent of the domain module).
+  `parentHasActiveSubagent()`, independent of the domain module) (step 5).
+
+### The remote-ssh adapter (step 3)
+
+`public/remote-activity-ui.js` keeps one persistent `createSessionState('remote-ssh')`
+per remote session id in `remoteSessionStates` (a `Map`, pruned in
+`pruneRemoteActivityTimers()` alongside the decay timers, called after every
+`refreshSidebar()`). It is fed by:
+
+- **The watch channel** (`onRemoteActivityEvent`, `main.js`'s `remote-activity`
+  IPC): `transcriptTouched` + `busy: true`; the 20s decay timer then applies
+  `busy: false, armReady: false` — a remote row must never reach
+  `.response-ready`, it has no PTY to confirm a turn actually ended. Tested in
+  `test/remote-session-adapter.test.js` and mutation-proven (see below).
+- **The descriptor** (`applyRemoteDescriptor`, called from `seedRemoteActivity`
+  at every render for every remote session): `descriptorStatus(status, at)`
+  from `session.status`/`session.statusUpdatedAt`, and `liveness: 'alive'`
+  when `session.remoteDescriptorSeen` is true. `main.js`'s
+  `annotateRemoteAttachable` sets `remoteDescriptorSeen = !!descriptor` — the
+  descriptor list (`remoteIndexer.getRemoteSessions`) is already ALIVE-marker
+  filtered (#262), so a match means a live process. Absence is left
+  `'unknown'`, never asserted `'dead'` — a poll miss or host backoff is not
+  proof the process exited.
+- **Attach/detach of the remote tab** (`setRemoteAttached(sessionId, attached)`,
+  called from `app.js`'s `updateRunningIndicators` for rows carrying
+  `dataset.remoteAlias`): there is no dedicated open/close IPC event for a
+  remote attach, so this reuses the same per-row `activePtyIds` transition
+  `has-running-pty` already reads.
+
+**The adapter never writes DOM itself.** Every event ends in
+`projectRemoteState(sessionId)`, which calls `session-activity-dom.js`'s new
+`applyStateClasses(sessionId, snapshot)` — the same two-class output
+(`cli-busy`/`response-ready`) `applyActivityClasses` produces for local-pty,
+but computed from the adapter's own snapshot instead of the local-pty Maps.
+
+**`setActivity()`/the Maps in `session-activity.js` are still fed for remote
+ids in parallel** (`markRemoteBusy`/`decayRemoteBusy` call both). Two readers
+were not migrated onto the adapter in this step, so removing the dual-feed
+would regress them:
+- `sidebar.js`'s `buildSessionItem` reads `sessionBusyState`/
+  `responseReadySessions`/`attentionSessions` directly at initial paint.
+- `app.js`'s grid-card busy dot (`updateRunningIndicators`'s `gridCards`
+  loop) reads `sessionBusyState` directly.
+
+Both are driven by the same `active`/`armReady` inputs as the adapter, so the
+two projections never disagree in practice; the dual-feed is a known,
+temporary duplication, not a race.
 
 ## Shape
 
@@ -114,12 +162,13 @@ is a later step, not part of this migration.
 
 | event | local-pty | local-transcript | remote-ssh |
 |---|---|---|---|
-| `busy` / `attention` (OSC 0 / 9) | yes | never | only while attached |
-| `transcriptTouched(at)` | yes | yes (only signal) | yes (watch channel) |
-| `descriptorStatus(status, at)` | yes | no (no live CLI) | yes (`main.js:539`) |
+| `busy` / `attention` (OSC 0 / 9) | yes | never | wired via the watch channel (transcript writes), not OSC — OSC-while-attached is not wired |
+| `transcriptTouched(at)` | yes | yes (only signal) | yes — `onRemoteActivityEvent`/`markRemoteBusy` |
+| `descriptorStatus(status, at)` / `liveness` | yes | no (no live CLI) | yes (`main.js:539` → `applyRemoteDescriptor`) |
+| `attached` | reserved, unused | reserved, unused | yes — `setRemoteAttached`, driven by the per-row `activePtyIds` transition |
 | `subagentSpawned` / `subagentCompleted` | yes | no | no today |
 
 An adapter without a PTY must never claim `waitingForInput` or `responseReady`
-— it has no way to tell "thinking" from "done, unseen". It should only feed
-`busy: unknown` (not modeled as a tri-state yet — reserved for step 3/4) plus
-`lastActivityAt`.
+from a completion signal it cannot verify — that is why the remote-ssh
+`busy: false` transition always passes `armReady: false` (see "The remote-ssh
+adapter" above), not a tri-state `busy: unknown`.
diff --git a/eslint.config.js b/eslint.config.js
index 9e166f53..3b37eb45 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -156,10 +156,13 @@ const rendererCrossFileGlobals = {
   // public/session-activity-dom.js — the only file allowed to write
   // .cli-busy/.needs-attention/.response-ready/.has-busy-agents.
   applyActivityClassesToElement: 'readonly',
+  applyStateClasses: 'readonly',
   setNeedsAttention: 'readonly',
   setResponseReady: 'readonly',
   setCliBusy: 'readonly',
   setHasBusyAgents: 'readonly',
+  // public/remote-activity-ui.js (remote-ssh adapter, see .ai/contexts/session-state.md)
+  setRemoteAttached: 'readonly',
 
   // Third-party renderer libs loaded as <script>
   morphdom: 'readonly',
diff --git a/main.js b/main.js
index e47b2277..ded96287 100644
--- a/main.js
+++ b/main.js
@@ -555,6 +555,8 @@ function annotateRemoteAttachable(projects) {
         session.status = descriptor ? (descriptor.status || null) : null;
         session.statusUpdatedAt = descriptor ? (descriptor.statusUpdatedAt || null) : null;
         session.remoteActiveAt = remoteActivityTracker.activeAt(session.remoteAlias, session.sessionId);
+        // listed descriptor = live process (ALIVE filter) — see .ai/contexts/session-state.md
+        session.remoteDescriptorSeen = !!descriptor;
       } else {
         // Same descriptor vocabulary, read from the local ~/.claude/sessions/<pid>.json
         // instead of a remote host's mirror -- see .ai/contexts/cli-session-state.md
diff --git a/public/app.js b/public/app.js
index 60a9624b..674d9f59 100644
--- a/public/app.js
+++ b/public/app.js
@@ -821,6 +821,7 @@ function updateRunningIndicators() {
         // drop the live-subagent state now instead of waiting for the TTL.
         clearActiveSubagentsFor(id);
       }
+      if (item.dataset.remoteAlias) setRemoteAttached(id, running);
       const dot = item.querySelector('.session-status-dot');
       if (dot) dot.classList.toggle('running', running);
       if (window.ATRACE) window.atrace('class.toggle', id, { el: item.id || null, cls: 'has-running-pty', on: running, dot: !!dot, fn: 'updateRunningIndicators' });
diff --git a/public/remote-activity-ui.js b/public/remote-activity-ui.js
index 03db6f8f..e3a7c271 100644
--- a/public/remote-activity-ui.js
+++ b/public/remote-activity-ui.js
@@ -1,8 +1,25 @@
-// See .ai/contexts/session-cache.md ("Remote hosts — busy spinner (issue #242)").
+// See .ai/contexts/session-cache.md ("Remote hosts — busy spinner (issue #242)")
+// and .ai/contexts/session-state.md (migration step 3: the remote-ssh adapter).
 
 const PIP_DECAY_MS = 20000;
 const remoteActivityDecayTimers = new Map();
 
+// remote-ssh adapter: one persistent state per remote session id — see .ai/contexts/session-state.md
+const remoteSessionStates = new Map();
+
+function remoteState(sessionId) {
+  let state = remoteSessionStates.get(sessionId);
+  if (!state) {
+    state = createSessionState('remote-ssh');
+    remoteSessionStates.set(sessionId, state);
+  }
+  return state;
+}
+
+function projectRemoteState(sessionId) {
+  applyStateClasses(sessionId, remoteState(sessionId).snapshot());
+}
+
 function clearRemoteActivityTimer(sessionId) {
   const t = remoteActivityDecayTimers.get(sessionId);
   if (t) {
@@ -11,11 +28,27 @@ function clearRemoteActivityTimer(sessionId) {
   }
 }
 
+// Maps still fed in parallel for sidebar initial paint and grid dot — see session-state.md "migration status"
+function markRemoteBusy(sessionId, via, at) {
+  const state = remoteState(sessionId);
+  state.apply({ type: 'transcriptTouched', at: at || Date.now(), source: via });
+  state.apply({ type: 'busy', active: true });
+  setActivity(sessionId, true, via);
+  projectRemoteState(sessionId);
+}
+
+// silence is "stopped writing", not "response ready" — see .ai/contexts/session-cache.md ("Remote hosts — busy spinner")
+function decayRemoteBusy(sessionId) {
+  const state = remoteState(sessionId);
+  state.apply({ type: 'busy', active: false, armReady: false });
+  setActivity(sessionId, false, 'remote-decay', { armReady: false });
+  projectRemoteState(sessionId);
+}
+
 function armRemoteDecayTimer(sessionId, ms) {
   remoteActivityDecayTimers.set(sessionId, setTimeout(() => {
     remoteActivityDecayTimers.delete(sessionId);
-    // silence is "stopped writing", not "response ready" — see .ai/contexts/session-cache.md ("Remote hosts — busy spinner")
-    setActivity(sessionId, false, 'remote-decay', { armReady: false });
+    decayRemoteBusy(sessionId);
   }, ms));
 }
 
@@ -23,23 +56,47 @@ function pruneRemoteActivityTimers() {
   for (const sessionId of remoteActivityDecayTimers.keys()) {
     if (!sessionItemEl(sessionId)) clearRemoteActivityTimer(sessionId);
   }
+  for (const sessionId of remoteSessionStates.keys()) {
+    if (!sessionItemEl(sessionId)) remoteSessionStates.delete(sessionId);
+  }
 }
 
 function onRemoteActivityEvent(payload) {
   const sessionId = payload && payload.sessionId;
   if (typeof sessionId !== 'string' || !sessionId) return;
-  setActivity(sessionId, true, 'remote-watch');
+  markRemoteBusy(sessionId, 'remote-watch', payload.at);
   clearRemoteActivityTimer(sessionId);
   armRemoteDecayTimer(sessionId, PIP_DECAY_MS);
 }
 
+// descriptor ports; absence stays 'unknown', never 'dead' — see session-state.md ports table
+function applyRemoteDescriptor(session) {
+  if (!session || !session.remoteAlias) return;
+  const state = remoteState(session.sessionId);
+  if (session.remoteDescriptorSeen) state.apply({ type: 'liveness', value: 'alive' });
+  if (session.status !== undefined) {
+    state.apply({ type: 'descriptorStatus', status: session.status, at: session.statusUpdatedAt });
+  }
+  projectRemoteState(session.sessionId);
+}
+
+// attached = a PTY/ssh attach exists for this row (activePtyIds signal from app.js)
+function setRemoteAttached(sessionId, attached) {
+  if (!attached && !remoteSessionStates.has(sessionId)) return; // nothing recorded yet, nothing to clear
+  const state = remoteState(sessionId);
+  state.apply({ type: 'attached', value: attached });
+  projectRemoteState(sessionId);
+}
+
 function seedRemoteActivity(session) {
   if (!session || !session.remoteAlias) return;
+  applyRemoteDescriptor(session);
+
   if (!Number.isFinite(session.remoteActiveAt)) return;
   const sessionId = session.sessionId;
   const remaining = session.remoteActiveAt + PIP_DECAY_MS - Date.now();
   if (remaining <= 0) return;
-  setActivity(sessionId, true, 'remote-seed');
+  markRemoteBusy(sessionId, 'remote-seed', session.remoteActiveAt);
   if (remoteActivityDecayTimers.has(sessionId)) return;
   armRemoteDecayTimer(sessionId, remaining);
 }
diff --git a/public/session-activity-dom.js b/public/session-activity-dom.js
index fcfb5a08..098a3145 100644
--- a/public/session-activity-dom.js
+++ b/public/session-activity-dom.js
@@ -44,3 +44,15 @@ function applyActivityClassesToElement(item, sessionId) {
 function applyActivityClasses(sessionId) {
   applyActivityClassesToElement(sessionItemEl(sessionId), sessionId);
 }
+
+// Snapshot-driven projection for adapter-owned state — see .ai/contexts/session-state.md
+function applyStateClasses(sessionId, snapshot) {
+  const item = sessionItemEl(sessionId);
+  if (!item) return;
+  const classes = renderSessionIcon(snapshot).classes;
+  const ready = classes.includes('response-ready');
+  const busy = classes.includes('cli-busy');
+  setResponseReady(item, ready);
+  setCliBusy(item, busy);
+  if (window.ATRACE) window.atrace('class.apply', sessionId, { el: item.id || null, 'response-ready': ready, 'cli-busy': busy, fn: 'applyStateClasses', kind: snapshot && snapshot.kind });
+}
diff --git a/test/remote-session-adapter.test.js b/test/remote-session-adapter.test.js
new file mode 100644
index 00000000..b9f5517f
--- /dev/null
+++ b/test/remote-session-adapter.test.js
@@ -0,0 +1,163 @@
+// Tests for the remote-ssh adapter in public/remote-activity-ui.js — see
+// .ai/contexts/session-state.md (migration step 3). Unlike
+// test/remote-activity-ui.test.js (the pre-existing sessionBusyState/
+// responseReadySessions-facing tests, kept as-is), these assert against the
+// adapter's own persistent createSessionState('remote-ssh') snapshot: one
+// instance per remote session id, fed by the watch-channel event, the decay
+// timer, the descriptor (status/liveness) and the attach/detach signal.
+//
+// Same eval-in-jsdom technique as test/remote-activity-ui.test.js: the real
+// session-state.js / session-activity-dom.js / session-activity.js /
+// remote-activity-ui.js, loaded in index.html order, with setTimeout/
+// clearTimeout stubbed so the 20s decay is driven by hand.
+
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { JSDOM } = require('jsdom');
+
+const STATE_SRC = path.join(__dirname, '..', 'public', 'session-state.js');
+const DOM_SRC = path.join(__dirname, '..', 'public', 'session-activity-dom.js');
+const ACTIVITY_SRC = path.join(__dirname, '..', 'public', 'session-activity.js');
+const SRC = path.join(__dirname, '..', 'public', 'remote-activity-ui.js');
+
+function setup(sessionIds = ['s1']) {
+  const items = sessionIds
+    .map(id => `<div class="session-item" data-session-id="${id}"><span class="session-status-dot"></span></div>`)
+    .join('');
+  const dom = new JSDOM(`<!DOCTYPE html><html><body>${items}</body></html>`,
+    { url: 'http://localhost/', runScripts: 'outside-only' });
+  const { window } = dom;
+
+  Object.defineProperty(window, 'activeSessionId', { value: null, writable: true, configurable: true });
+
+  let onRemoteActivityCb = null;
+  Object.defineProperty(window, 'api', {
+    value: { onRemoteActivity: (cb) => { onRemoteActivityCb = cb; } },
+    writable: true, configurable: true,
+  });
+
+  const scheduled = [];
+  let nextId = 1;
+  Object.defineProperty(window, 'setTimeout', {
+    value: (fn, ms) => {
+      const handle = { id: nextId++, fn, ms, cleared: false };
+      scheduled.push(handle);
+      return handle.id;
+    },
+    writable: true, configurable: true,
+  });
+  Object.defineProperty(window, 'clearTimeout', {
+    value: (id) => {
+      const h = scheduled.find(s => s.id === id);
+      if (h) h.cleared = true;
+    },
+    writable: true, configurable: true,
+  });
+
+  const ctx = dom.getInternalVMContext();
+  vm.runInContext(fs.readFileSync(STATE_SRC, 'utf8'), ctx, { filename: STATE_SRC });
+  vm.runInContext(fs.readFileSync(DOM_SRC, 'utf8'), ctx, { filename: DOM_SRC });
+  vm.runInContext(fs.readFileSync(ACTIVITY_SRC, 'utf8'), ctx, { filename: ACTIVITY_SRC });
+  vm.runInContext(fs.readFileSync(SRC, 'utf8'), ctx, { filename: SRC });
+
+  const call = (fnName, ...args) => vm.runInContext(
+    `${fnName}(${args.map((a) => JSON.stringify(a)).join(',')})`, ctx
+  );
+
+  return {
+    window,
+    document: window.document,
+    item: (id) => window.document.querySelector(`.session-item[data-session-id="${id}"]`),
+    emit: (payload) => onRemoteActivityCb(payload),
+    snapshot: (id) => vm.runInContext(`remoteState(${JSON.stringify(id)}).snapshot()`, ctx),
+    applyRemoteDescriptor: (session) => call('applyRemoteDescriptor', session),
+    setRemoteAttached: (id, attached) => call('setRemoteAttached', id, attached),
+    seedRemoteActivity: (session) => call('seedRemoteActivity', session),
+    scheduled,
+    pending: () => scheduled.filter(h => !h.cleared),
+    destroy: () => window.close(),
+  };
+}
+
+test('a remote-activity event drives the adapter snapshot busy, then decay clears busy without arming response-ready', () => {
+  const t = setup(['s1']);
+  let snap = t.snapshot('s1');
+  assert.equal(snap.busy, false, 'precondition: idle');
+
+  t.emit({ sessionId: 's1', at: Date.now() });
+  snap = t.snapshot('s1');
+  assert.equal(snap.busy, true, 'the watch-channel event marks the adapter busy');
+  assert.equal(snap.lastActivitySource, 'remote-watch');
+  assert.ok(t.item('s1').classList.contains('cli-busy'), 'projected onto the row');
+
+  const timer = t.pending()[0];
+  assert.ok(timer, 'a decay timer must be scheduled');
+  timer.fn(); // simulate the 20s elapsing
+
+  snap = t.snapshot('s1');
+  assert.equal(snap.busy, false, 'decay clears busy');
+  assert.equal(snap.waitingForInput, true);
+  assert.equal(snap.responseReady, false, 'decay must never arm response-ready — remote has no PTY to confirm a turn ended');
+  assert.ok(!t.item('s1').classList.contains('cli-busy'));
+  assert.ok(!t.item('s1').classList.contains('response-ready'));
+  t.destroy();
+});
+
+test('applyRemoteDescriptor sets liveness alive and descriptorStatus from a matched descriptor', () => {
+  const t = setup(['s1']);
+  t.applyRemoteDescriptor({
+    sessionId: 's1', remoteAlias: 'planificator',
+    remoteDescriptorSeen: true, status: 'idle', statusUpdatedAt: 12345,
+  });
+
+  const snap = t.snapshot('s1');
+  assert.equal(snap.liveness, 'alive');
+  assert.equal(snap.lastActivitySource, 'descriptor');
+  t.destroy();
+});
+
+test('applyRemoteDescriptor leaves liveness unknown when the descriptor was not seen (no false "dead")', () => {
+  const t = setup(['s1']);
+  t.applyRemoteDescriptor({
+    sessionId: 's1', remoteAlias: 'planificator',
+    remoteDescriptorSeen: false, status: null, statusUpdatedAt: null,
+  });
+
+  assert.equal(t.snapshot('s1').liveness, 'unknown');
+  t.destroy();
+});
+
+test('applyRemoteDescriptor is a no-op for a session with no remoteAlias', () => {
+  const t = setup(['s1']);
+  t.applyRemoteDescriptor({ sessionId: 's1', remoteDescriptorSeen: true, status: 'idle' });
+  assert.equal(t.snapshot('s1').liveness, 'unknown', 'a local session must never be routed through the remote-ssh adapter');
+  t.destroy();
+});
+
+test('setRemoteAttached toggles the attached flag without affecting busy/liveness', () => {
+  const t = setup(['s1']);
+  t.setRemoteAttached('s1', true);
+  assert.equal(t.snapshot('s1').attached, true);
+
+  t.setRemoteAttached('s1', false);
+  assert.equal(t.snapshot('s1').attached, false);
+  t.destroy();
+});
+
+test('seeding a session inside the decay window marks it busy and arms exactly one decay timer', () => {
+  const t = setup(['s1']);
+  t.seedRemoteActivity({
+    sessionId: 's1', remoteAlias: 'planificator', remoteActiveAt: Date.now() - 5000,
+    remoteDescriptorSeen: true, status: 'busy', statusUpdatedAt: 999,
+  });
+
+  const snap = t.snapshot('s1');
+  assert.equal(snap.busy, true);
+  assert.equal(snap.liveness, 'alive');
+  assert.equal(t.pending().length, 1);
+  t.destroy();
+});