From 66462528a928c1ab624f45ab3e00b0c2b8de33e4 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste <jean-baptiste@konvex-it.fr>
Date: Fri, 11 Sep 2026 08:28:21 +0200
Subject: [PATCH] (activity): remote decay clears busy without claiming
 response-ready; PTY purge skips remote rows

setActivity gains opts.armReady (default true); remote-activity-ui's decay
passes armReady:false since silence isn't proof a turn actually finished.
updateRunningIndicators now skips dataset.remoteAlias rows and routes its
local purge through session-activity's new purgeActivityFor.
---
 .ai/contexts/session-cache.md           |  13 +++
 eslint.config.js                        |   1 +
 public/app.js                           |  15 ++--
 public/remote-activity-ui.js            |   8 +-
 public/session-activity.js              |  28 +++++-
 public/sidebar.js                       |   3 +
 test/dom-sidebar-remote-session.test.js |   3 +
 test/remote-activity-ui.test.js         |  12 ++-
 test/running-indicators.test.js         |  86 +++++++++++++++++++
 test/session-activity.test.js           | 108 ++++++++++++++++++++++--
 10 files changed, 258 insertions(+), 19 deletions(-)

diff --git a/.ai/contexts/session-cache.md b/.ai/contexts/session-cache.md
index 3db7eaf8..fc9ba72e 100644
--- a/.ai/contexts/session-cache.md
+++ b/.ai/contexts/session-cache.md
@@ -224,6 +224,19 @@ and arms a 20 s decay timer (one per session, reset on each event) that calls
 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 })`,
+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
+(its own transcript silent while children write theirs) would otherwise light every
+unviewed remote row as `.response-ready` on a plain inference. `armReady: false` clears
+`.cli-busy` and `sessionBusyState` through the normal path but skips adding the session to
+`responseReadySessions`, so a remote row falls idle without ever claiming "Claude finished,
+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.
+
 ### Remote hosts file-level rescan (issue #216, first half)
 
 **The unit of rescan used to be the folder, not the file.** `syncMirror`
diff --git a/eslint.config.js b/eslint.config.js
index f3a43016..eb3b3891 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -147,6 +147,7 @@ const rendererCrossFileGlobals = {
   reconcileBusyState: 'readonly',
   currentActivitySeq: 'readonly',
   forgetActivitySeq: 'readonly',
+  purgeActivityFor: 'readonly',
   pruneRemoteActivityTimers: 'readonly',
 
   // Third-party renderer libs loaded as <script>
diff --git a/public/app.js b/public/app.js
index 8133be8b..be5ad8ca 100644
--- a/public/app.js
+++ b/public/app.js
@@ -809,13 +809,14 @@ function updateRunningIndicators() {
       const id = item.dataset.sessionId;
       const running = activePtyIds.has(id);
       item.classList.toggle('has-running-pty', running);
-      if (!running) {
-        if (window.ATRACE) window.atrace('store.purge', id, { reason: 'pty-gone', busy: sessionBusyState.get(id) ?? null, ready: responseReadySessions.has(id), attention: attentionSessions.has(id), fn: 'updateRunningIndicators' });
-        item.classList.remove('needs-attention', 'response-ready', 'cli-busy', 'has-busy-agents');
-        attentionSessions.delete(id);
-        responseReadySessions.delete(id);
-        sessionBusyState.delete(id);
-        forgetActivitySeq(id);
+      // A remote row's busy state is owned by the remote adapter (the watch
+      // channel), not by local PTY presence — it never enters activePtyIds,
+      // so purging it here on every unrelated local PTY start/stop would wipe
+      // its spinner. See .ai/contexts/session-cache.md ("Remote hosts — busy
+      // spinner").
+      if (!running && !item.dataset.remoteAlias) {
+        item.classList.remove('has-busy-agents');
+        purgeActivityFor(id, 'pty-gone');
         // A stopped PTY can never emit subagent-completed (stop-session kills
         // the process; detectSubagentTransitions skips exited sessions), so
         // drop the live-subagent state now instead of waiting for the TTL.
diff --git a/public/remote-activity-ui.js b/public/remote-activity-ui.js
index a56526b0..a9e9da6c 100644
--- a/public/remote-activity-ui.js
+++ b/public/remote-activity-ui.js
@@ -14,7 +14,13 @@ function clearRemoteActivityTimer(sessionId) {
 function armRemoteDecayTimer(sessionId, ms) {
   remoteActivityDecayTimers.set(sessionId, setTimeout(() => {
     remoteActivityDecayTimers.delete(sessionId);
-    setActivity(sessionId, false, 'remote-decay');
+    // 20s of transcript silence means "stopped writing", not "response
+    // ready" — a remote adapter has no PTY to confirm the turn actually
+    // ended (long tool call, parent delegating to subagents). Clear busy
+    // without arming the unread marker. Covers both onRemoteActivityEvent's
+    // decay and seedRemoteActivity's seed-decay — both arm through this
+    // function. See .ai/contexts/session-cache.md ("Remote hosts — busy spinner").
+    setActivity(sessionId, false, 'remote-decay', { armReady: false });
   }, ms));
 }
 
diff --git a/public/session-activity.js b/public/session-activity.js
index adc252f3..ed01d63b 100644
--- a/public/session-activity.js
+++ b/public/session-activity.js
@@ -34,8 +34,32 @@ function applyActivityClasses(sessionId) {
   if (window.ATRACE) window.atrace('class.apply', sessionId, { el: item.id || null, 'response-ready': ready, 'cli-busy': item.classList.contains('cli-busy'), fn: 'applyActivityClasses' });
 }
 
+// Drop all busy/unread/attention state for a session outside the normal
+// active/idle transition — e.g. its PTY just stopped (app.js's
+// updateRunningIndicators, via: 'pty-gone'). Sole writer of the three
+// collections besides setActivity/rekeyActivityState, so a caller never
+// deletes from them directly. Does not touch has-busy-agents/subagent state
+// (sidebar.js's clearActiveSubagentsFor) or has-running-pty — those are
+// owned elsewhere.
+function purgeActivityFor(sessionId, via) {
+  if (window.ATRACE) window.atrace('store.purge', sessionId, { reason: via, busy: sessionBusyState.get(sessionId) ?? null, ready: responseReadySessions.has(sessionId), attention: attentionSessions.has(sessionId), fn: 'purgeActivityFor' });
+  attentionSessions.delete(sessionId);
+  responseReadySessions.delete(sessionId);
+  sessionBusyState.delete(sessionId);
+  forgetActivitySeq(sessionId);
+  const item = sessionItemEl(sessionId);
+  if (item) item.classList.remove('needs-attention');
+  applyActivityClasses(sessionId);
+}
+
 // Central activity dispatcher. `via` is trace-only — see docs/activity-trace.md.
-function setActivity(sessionId, active, via) {
+// `opts.armReady` (default true) gates whether going idle may arm
+// response-ready; it is an explicit opt-out, never derived from `via`. Pass
+// `{ armReady: false }` for a source that can only infer "stopped writing"
+// from silence (no PTY to ask "is a response actually ready?") — see
+// .ai/contexts/session-cache.md ("Remote hosts — busy spinner").
+function setActivity(sessionId, active, via, opts) {
+  const armReady = !(opts && opts.armReady === false);
   if (active) {
     if (window.ATRACE && responseReadySessions.has(sessionId)) window.atrace('store.mutate', sessionId, { map: 'responseReadySessions', op: 'delete', from: true, to: false, fn: 'setActivity', via });
     responseReadySessions.delete(sessionId);
@@ -50,7 +74,7 @@ function setActivity(sessionId, active, via) {
   activitySeqBySession.set(sessionId, activitySeq);
   if (window.ATRACE) window.atrace('store.mutate', sessionId, { map: 'sessionBusyState', op: 'set', from: wasActive, to: active, actSeq: activitySeq, fn: 'setActivity', via });
 
-  if (wasActive && !active && sessionId !== activeSessionId) {
+  if (wasActive && !active && sessionId !== activeSessionId && armReady) {
     if (window.ATRACE) window.atrace('store.mutate', sessionId, { map: 'responseReadySessions', op: 'add', from: false, to: true, fn: 'setActivity', via });
     responseReadySessions.add(sessionId);
   }
diff --git a/public/sidebar.js b/public/sidebar.js
index 14d1f64c..99007520 100644
--- a/public/sidebar.js
+++ b/public/sidebar.js
@@ -1318,6 +1318,9 @@ function buildSessionItem(session) {
   if (parentHasActiveSubagent(session.sessionId)) item.classList.add('has-busy-agents');
   if (window.ATRACE && item.className !== 'session-item js-stateful') window.atrace('class.render', session.sessionId, { el: item.id, cls: item.className, fn: 'buildSessionItem' });
   item.dataset.sessionId = session.sessionId;
+  // Read by app.js's updateRunningIndicators — a remote row's busy state is
+  // owned by the remote adapter, not local PTY presence (F7).
+  if (session.remoteAlias) item.dataset.remoteAlias = session.remoteAlias;
 
   const modified = new Date(session.modified);
   const timeStr = formatDate(modified);
diff --git a/test/dom-sidebar-remote-session.test.js b/test/dom-sidebar-remote-session.test.js
index 76ee219e..cedcf0d6 100644
--- a/test/dom-sidebar-remote-session.test.js
+++ b/test/dom-sidebar-remote-session.test.js
@@ -44,6 +44,8 @@ test('a remote session row carries a badge naming its host', () => {
     const badge = item.querySelector('.remote-badge');
     assert.ok(badge, 'a remote row must be visibly distinguishable from a local one');
     assert.equal(badge.textContent, 'planificator');
+    assert.equal(item.dataset.remoteAlias, 'planificator',
+      'app.js\'s updateRunningIndicators reads dataset.remoteAlias to exempt the row from the PTY-set purge (F7)');
   } finally { ctx.destroy(); }
 });
 
@@ -114,6 +116,7 @@ test('a local session is unaffected: no badge, and the click still opens it', ()
 
     const item = ctx.document.getElementById('si-local-1');
     assert.equal(item.querySelector('.remote-badge'), null);
+    assert.equal(item.dataset.remoteAlias, undefined, 'a local row must not carry dataset.remoteAlias');
 
     const opened = [];
     const viewed = [];
diff --git a/test/remote-activity-ui.test.js b/test/remote-activity-ui.test.js
index 1f2338d5..0a834a54 100644
--- a/test/remote-activity-ui.test.js
+++ b/test/remote-activity-ui.test.js
@@ -118,7 +118,11 @@ test('.cli-busy clears once the decay timer fires, and not before', () => {
   t.destroy();
 });
 
-test('decay routes through setActivity: a non-selected remote session lands in responseReadySessions, exactly like a local one', () => {
+test('decay routes through setActivity with armReady:false: a non-selected remote session clears busy WITHOUT landing in responseReadySessions', () => {
+  // F3: 20s of transcript silence means "stopped writing", not "the response
+  // is ready" — a remote adapter has no PTY to confirm a turn actually ended
+  // (a long tool call, or a parent delegating to subagents whose own
+  // transcript stays silent). Decay must not claim the turn is done.
   const t = setup(['s1']);
   t.window.activeSessionId = 's2'; // s1 is not the focused session
   t.emit({ sessionId: 's1' });
@@ -126,8 +130,10 @@ test('decay routes through setActivity: a non-selected remote session lands in r
 
   t.pending()[0].fn(); // decay fires
 
-  assert.equal(t.sessionBusyState.get('s1'), false);
-  assert.ok(t.responseReadySessions.has('s1'), 'going idle through setActivity marks the turn as an unread response, like a local session');
+  assert.equal(t.sessionBusyState.get('s1'), false, 'busy is cleared');
+  assert.ok(!t.responseReadySessions.has('s1'), 'decay must NOT arm the unread/response-ready marker');
+  assert.ok(!t.item('s1').classList.contains('cli-busy'), 'the spinner is off');
+  assert.ok(!t.item('s1').classList.contains('response-ready'), 'the row must not claim a finished response it never measured');
   t.destroy();
 });
 
diff --git a/test/running-indicators.test.js b/test/running-indicators.test.js
index 888a86ba..fbe181f1 100644
--- a/test/running-indicators.test.js
+++ b/test/running-indicators.test.js
@@ -27,6 +27,7 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const path = require('node:path');
 const { JSDOM } = require('jsdom');
+const { setupSidebarDom } = require('./dom-setup');
 
 // ---------------------------------------------------------------------------
 // Minimal DOM setup
@@ -339,6 +340,91 @@ test('updateRunningIndicators: empty pty-set — all sessions marked stopped', (
   window.close();
 });
 
+// ---------------------------------------------------------------------------
+// F7 — remote rows are exempt from the PTY-set purge.
+//
+// Unlike the replica tests above (hand-rolled Maps/Sets), these drive the
+// REAL session-activity.js/sidebar.js/remote-activity-ui.js via dom-setup.js
+// (same technique as test/dom-sidebar-remote-session.test.js). The gating
+// loop itself is still a hand-mirror of updateRunningIndicators — app.js
+// cannot be eval'd in jsdom (see file header) — but the state it mutates
+// (sessionBusyState/responseReadySessions/attentionSessions, and the purge
+// itself) is the real purgeActivityFor from session-activity.js, not a
+// replica. Keep this mirror's remote-skip condition in sync with app.js's
+// `if (!running && !item.dataset.remoteAlias)`.
+// ---------------------------------------------------------------------------
+
+function runIndicatorPass(doc, activePtyIds) {
+  doc.querySelectorAll('.session-item').forEach(item => {
+    if (item.dataset.subagent) return;
+    const id = item.dataset.sessionId;
+    const running = activePtyIds.has(id);
+    item.classList.toggle('has-running-pty', running);
+    if (!running && !item.dataset.remoteAlias) {
+      item.classList.remove('has-busy-agents');
+      doc.defaultView.purgeActivityFor(id, 'pty-gone');
+    }
+  });
+}
+
+test('F7: a remote row busy via onRemoteActivityEvent stays .cli-busy across an unrelated local pty-set change', () => {
+  const ctx = setupSidebarDom();
+  try {
+    const sidebarContent = ctx.document.getElementById('sidebar-content');
+    const localItem = ctx.document.createElement('div');
+    localItem.className = 'session-item';
+    localItem.dataset.sessionId = 'local-1';
+    localItem.innerHTML = '<span class="session-status-dot"></span>';
+    const remoteItem = ctx.document.createElement('div');
+    remoteItem.className = 'session-item';
+    remoteItem.dataset.sessionId = 'remote-1';
+    remoteItem.dataset.remoteAlias = 'vps';
+    remoteItem.innerHTML = '<span class="session-status-dot"></span>';
+    sidebarContent.append(localItem, remoteItem);
+
+    // Real onRemoteActivityEvent (remote-activity-ui.js), as the watch
+    // channel's IPC event would drive it — routes through the real setActivity.
+    ctx.window.onRemoteActivityEvent({ sessionId: 'remote-1' });
+    assert.ok(remoteItem.classList.contains('cli-busy'), 'precondition: remote row busy via the real dispatcher');
+    assert.equal(ctx.sessionBusyState.get('remote-1'), true);
+
+    runIndicatorPass(ctx.document, new Set(['local-1']));
+    assert.ok(remoteItem.classList.contains('cli-busy'), 'remote row still busy after a pass with local-1 running');
+
+    // local-1 stops — an unrelated local pty-set change.
+    runIndicatorPass(ctx.document, new Set());
+
+    assert.ok(remoteItem.classList.contains('cli-busy'), 'remote row must NOT be purged by an unrelated local pty-set change');
+    assert.equal(ctx.sessionBusyState.get('remote-1'), true, 'sessionBusyState for the remote row is untouched');
+    assert.ok(!localItem.classList.contains('has-running-pty'), 'the local row is still correctly marked not running');
+  } finally {
+    ctx.destroy();
+  }
+});
+
+test('F7: a local non-running row is still purged through purgeActivityFor', () => {
+  const ctx = setupSidebarDom();
+  try {
+    const sidebarContent = ctx.document.getElementById('sidebar-content');
+    const localItem = ctx.document.createElement('div');
+    localItem.className = 'session-item';
+    localItem.dataset.sessionId = 'local-1';
+    localItem.innerHTML = '<span class="session-status-dot"></span>';
+    sidebarContent.append(localItem);
+
+    ctx.setActivity('local-1', true, 'onCliBusyState');
+    runIndicatorPass(ctx.document, new Set(['local-1']));
+    assert.ok(localItem.classList.contains('cli-busy'), 'precondition: local row busy while its pty runs');
+
+    runIndicatorPass(ctx.document, new Set()); // the pty stops
+
+    assert.ok(!localItem.classList.contains('cli-busy'), 'a stopped local row must still be purged');
+    assert.equal(ctx.sessionBusyState.has('local-1'), false, 'sessionBusyState entry dropped for the stopped local row');
+  } finally {
+    ctx.destroy();
+  }
+});
+
 // ---------------------------------------------------------------------------
 // Source-level pin for the REAL public/app.js (not the replica above).
 //
diff --git a/test/session-activity.test.js b/test/session-activity.test.js
index eecdf0cc..8c91ea7a 100644
--- a/test/session-activity.test.js
+++ b/test/session-activity.test.js
@@ -44,6 +44,7 @@ function setup(sessionIds = ['s1', 's2']) {
     reconcileBusyState: read('reconcileBusyState'),
     currentActivitySeq: read('currentActivitySeq'),
     forgetActivitySeq: read('forgetActivitySeq'),
+    purgeActivityFor: read('purgeActivityFor'),
     responseReadySessions: read('responseReadySessions'),
     sessionBusyState: read('sessionBusyState'),
     attentionSessions: read('attentionSessions'),
@@ -149,6 +150,90 @@ test('clearUnread re-exposes the spinner when the session is still generating',
   t.destroy();
 });
 
+// ---------------------------------------------------------------------------
+// F3: opts.armReady — a source that can only infer silence, not completion
+// ---------------------------------------------------------------------------
+
+test('setActivity(id, false, via, { armReady: false }) clears busy without arming response-ready', () => {
+  const t = setup();
+  t.window.activeSessionId = 's2'; // s1 not focused — the case that normally arms response-ready
+
+  t.setActivity('s1', true, 'remote-watch');
+  t.setActivity('s1', false, 'remote-decay', { armReady: false });
+
+  assert.equal(t.sessionBusyState.get('s1'), false, 'busy still clears');
+  assert.ok(!t.responseReadySessions.has('s1'), 'armReady:false must suppress the response-ready transition');
+  assert.ok(!t.item('s1').classList.contains('cli-busy'));
+  assert.ok(!t.item('s1').classList.contains('response-ready'));
+  t.destroy();
+});
+
+test('a local PTY source (no opts) going idle while unfocused still arms response-ready', () => {
+  // The default must stay armed — only an explicit opt-out (F3) changes it.
+  const t = setup();
+  t.window.activeSessionId = 's2';
+
+  t.setActivity('s1', true, 'onCliBusyState');
+  t.setActivity('s1', false, 'onCliBusyState');
+
+  assert.ok(t.responseReadySessions.has('s1'), 'local PTY idle must still claim an unread response');
+  assert.ok(t.item('s1').classList.contains('response-ready'));
+  t.destroy();
+});
+
+test('armReady:false does not block the response-ready CLEAR when the session goes busy again', () => {
+  // Symmetry check: armReady only gates the idle→response-ready transition;
+  // it must not interfere with the existing "busy always clears the stale
+  // marker" behavior.
+  const t = setup();
+  t.window.activeSessionId = 's2';
+
+  t.setActivity('s1', true);
+  t.setActivity('s1', false); // response-ready armed via the normal path
+  assert.ok(t.responseReadySessions.has('s1'));
+
+  t.setActivity('s1', true, 'remote-watch', { armReady: false });
+  assert.ok(!t.responseReadySessions.has('s1'), 'going busy always clears the stale unread marker regardless of armReady');
+  t.destroy();
+});
+
+// ---------------------------------------------------------------------------
+// F7: purgeActivityFor — the single writer for the PTY-gone purge
+// ---------------------------------------------------------------------------
+
+test('purgeActivityFor drops busy/unread/attention state and their classes', () => {
+  const t = setup();
+  t.window.activeSessionId = 's2';
+
+  t.setActivity('s1', true);
+  t.setActivity('s1', false); // response-ready armed
+  t.attentionSessions.add('s1');
+  t.item('s1').classList.add('needs-attention');
+  assert.ok(t.responseReadySessions.has('s1') && t.attentionSessions.has('s1'), 'preconditions');
+
+  t.purgeActivityFor('s1', 'pty-gone');
+
+  assert.ok(!t.attentionSessions.has('s1'), 'attentionSessions cleared');
+  assert.ok(!t.responseReadySessions.has('s1'), 'responseReadySessions cleared');
+  assert.ok(!t.sessionBusyState.has('s1'), 'sessionBusyState cleared');
+  assert.ok(!t.item('s1').classList.contains('needs-attention'));
+  assert.ok(!t.item('s1').classList.contains('response-ready'));
+  assert.ok(!t.item('s1').classList.contains('cli-busy'));
+  t.destroy();
+});
+
+test('purgeActivityFor on a busy session removes .cli-busy too', () => {
+  const t = setup();
+  t.setActivity('s1', true);
+  assert.ok(t.item('s1').classList.contains('cli-busy'));
+
+  t.purgeActivityFor('s1', 'pty-gone');
+
+  assert.ok(!t.sessionBusyState.has('s1'));
+  assert.ok(!t.item('s1').classList.contains('cli-busy'));
+  t.destroy();
+});
+
 // ---------------------------------------------------------------------------
 // Fork / session-detected re-keying
 // ---------------------------------------------------------------------------
@@ -343,14 +428,25 @@ test('public/app.js: the poll reconciles busy state and re-keys it on fork/detec
   assert.match(detected, /rekeyActivityState\(tempId, realId\)/, 'session detection must carry the activity state to the real id');
 });
 
-test('public/app.js: the pty-stop cleanup also purges the activity counter', () => {
-  // activitySeqBySession is the one activity collection updateRunningIndicators
-  // cannot see directly; without this call a long-lived window accumulates one
-  // entry per session that ever ran.
+test('public/app.js: the pty-stop cleanup routes through purgeActivityFor and skips remote rows (F7)', () => {
+  // purgeActivityFor (session-activity.js) is the single writer for
+  // sessionBusyState/responseReadySessions/attentionSessions/activitySeqBySession
+  // outside setActivity/rekeyActivityState — app.js must not touch those maps
+  // directly, and must not purge a row whose busy state is owned by the
+  // remote watch channel instead of local PTY presence.
   const src = fs.readFileSync(path.join(__dirname, '..', 'public', 'app.js'), 'utf8');
   const scanStart = src.indexOf("document.querySelectorAll('.session-item').forEach(item => {");
   assert.notEqual(scanStart, -1, 'the .session-item pty-set scan must still exist');
   const body = src.slice(scanStart, scanStart + 1200);
-  assert.match(body, /sessionBusyState\.delete\(id\);\s*\n\s*forgetActivitySeq\(id\);/,
-    'forgetActivitySeq must sit with the other per-session purges in the !running branch');
+
+  assert.match(body, /if\s*\(!running\s*&&\s*!item\.dataset\.remoteAlias\)\s*\{/,
+    'the purge branch must skip rows carrying dataset.remoteAlias');
+  assert.match(body, /purgeActivityFor\(id,\s*'pty-gone'\)/,
+    'the purge must go through the shared dispatcher');
+  assert.ok(!/sessionBusyState\.delete\(id\)/.test(body),
+    'app.js must not delete from sessionBusyState directly anymore');
+  assert.ok(!/responseReadySessions\.delete\(id\)/.test(body),
+    'app.js must not delete from responseReadySessions directly anymore');
+  assert.ok(!/attentionSessions\.delete\(id\)/.test(body),
+    'app.js must not delete from attentionSessions directly anymore');
 });