create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/public/js/core/session-commands.js

@@ -172,7 +172,9 @@ function machineChipPresentation(row) {
   const title = unreachable
     ? `Runs on ${name} — unreachable (showing its last known state)`
     : `Runs on ${name}`;
-  return { name, health: facts.health, unreachable, title, label: (unreachable ? '⚠ ' : '◈ ') + name };
+  // `machine` is the member's instance id — the same id the trust file and the pending/grant rows
+  // key on, so a click on the chip can name the exact card on the Machines page (AC-4a).
+  return { machine: facts.machine, name, health: facts.health, unreachable, title, label: (unreachable ? '⚠ ' : '◈ ') + name };
 }
 
 // HTML twin, for the row templates that build markup as strings.
@@ -183,6 +185,7 @@ function machineChipHtml(row) {
   const id = _machineRowId(row);
   return `<span class="${classes}" title="${escHtml(view.title)}" aria-label="${escHtml(view.title)}"`
     + (id ? ` data-session-id="${escHtml(id)}"` : '')
+    + ` data-machine-id="${escHtml(view.machine)}"`
     + ` data-machine-name="${escHtml(view.name)}" data-machine-health="${escHtml(view.health)}">${escHtml(view.label)}</span>`;
 }
 
@@ -195,6 +198,7 @@ function machineSessionChipNode(row, sessionId) {
   chip.textContent = view.label;
   chip.title = view.title;
   chip.setAttribute('aria-label', view.title);
+  chip.dataset.machineId = view.machine;
   chip.dataset.machineName = view.name;
   chip.dataset.machineHealth = view.health;
   const id = String(sessionId || _machineRowId(row) || '');
@@ -604,13 +608,23 @@ function createSession() {
   var wantCreateCwd = (!!_nsPathPickerState.createCwd && _nsPathPickerState.createCwd === _normCwd) || _typedMissing;
 
   function _doCreate(finalCwd) {
+    // WP-1 (D-1): the client mints the create id, so the box's late `created` (or its row in a later
+    // sessions list) can be matched back to THIS click even when the hub answers with an error first.
+    // The id comes from PendingCreate.newId(), never from `crypto` directly: crypto.randomUUID is
+    // secure-context only (a hub over plain http on a LAN address has no such function), and a page
+    // that loads this file without pending-create.js simply sends today's id-less frame.
+    var _pc = (typeof PendingCreate === 'object' && PendingCreate) || null;
     var msg = { type: 'create', cwd: finalCwd, label: label || undefined, mcp_profile: mcpProfile };
+    if (_pc) msg.id = _pc.newId();
     if (machine) msg.machine = machine;
     if (wantCreateCwd && !useWorktree && finalCwd) msg.createCwd = true;
     // Spawn the PTY at the terminal's real size so the agent's first paint
     // matches the final height (no 120x30→fit reflow that strands Codex's cursor).
-    var dims = _estimateNewSessionTermDims();
-    if (dims) { msg.cols = dims.cols; msg.rows = dims.rows; }
+    // WP-7 (S-53): a conv-only agent has no PTY, so it sends no cols/rows at all.
+    if (agentType !== 'dsh') {
+      var dims = _estimateNewSessionTermDims();
+      if (dims) { msg.cols = dims.cols; msg.rows = dims.rows; }
+    }
 
     if (agentType === 'claude') {
       msg.cmd = 'claude';
@@ -630,10 +644,31 @@ function createSession() {
     } else if (agentType === 'cursor') {
       msg.cmd = 'cursor-agent';
       msg.args = [];
+    } else if (agentType === 'dsh') {
+      // WP-7 (S-53, D-11): conv-only ACP agent. `dsh` is the command word the server detects
+      // (lib/agent-capabilities.js detectAgentType). OQ-4: the card's Model select contributes the
+      // route — absent/'' means "Auto (DeepSeek on Portkey)" and no routeAlias is sent at all.
+      msg.cmd = 'dsh';
+      msg.agentType = 'dsh';
+      msg.args = [];
+      var dshPick = (window.NewSessionAgentGrid && typeof window.NewSessionAgentGrid.dshRoutePick === 'function')
+        ? window.NewSessionAgentGrid.dshRoutePick() : null;
+      if (dshPick && dshPick.routeAlias) {
+        msg.routeAlias = dshPick.routeAlias;
+        if (dshPick.model) msg.model = dshPick.model;
+      }
     } else if (agentType === 'shell') {
       // default shell
     }
 
+    // WP-1 (D-7, §6.4): register the pending create BEFORE the frame leaves, so a `create-accepted`,
+    // a `created`, an `error` or a sessions list that lands before this line still finds the entry.
+    if (_pc) {
+      _pc.begin({
+        id: msg.id, machine: machine || '', machineName: machineSelectionName(),
+        label: label, activeTabAtClick: state.activeTab,
+      });
+    }
     send(msg);
     closeModal('new-session-modal');
   }
@@ -665,7 +700,9 @@ function createSession() {
     })
       .then(function(d) {
         if (d.error) {
-          toast(d.error, { type: 'error', title: 'Worktree creation failed' });
+          // D-5: a box mid-update says so instead of leaving the user with a bare failure.
+          var updatingText = typeof machineUpdatingToastText === 'function' ? machineUpdatingToastText(d.box_updating) : '';
+          toast(updatingText || d.error, { type: 'error', title: 'Worktree creation failed' });
           if (createBtn) { createBtn.disabled = false; createBtn.textContent = 'Create'; }
           return;
         }
@@ -678,7 +715,9 @@ function createSession() {
         _doCreate(d.path || cwd);
       })
       .catch(function(e) {
-        toast('Worktree error: ' + e.message, { type: 'error' });
+        // D-5: `_wtCreateWithProgress` carries the hub's `box_updating` on the thrown error.
+        var updatingText = typeof machineUpdatingToastText === 'function' ? machineUpdatingToastText(e && e.box_updating) : '';
+        toast(updatingText || ('Worktree error: ' + e.message), { type: 'error' });
         if (createBtn) { createBtn.disabled = false; createBtn.textContent = 'Create'; }
       });
   } else {
@@ -758,6 +797,7 @@ function closeSpecialTab(tabId) {
   if (tabId === 'review') {
     if (typeof _cancelReviewCatchUp === 'function') _cancelReviewCatchUp();
     state.reviewingSessionId = null;
+    state.reviewMachine = '';
     savePref('reviewing_session', null);
     document.querySelectorAll('.recent-item.reviewing').forEach(el => el.classList.remove('reviewing'));
     // Phase 3: stop receiving live updates for the no-longer-reviewed session.
@@ -815,7 +855,13 @@ async function resumeSession(sessionId, cwd, label) {
     alert('This provider does not support session resume yet.');
     return;
   }
-  const resumeCwd = await _resolveResumeCwdBeforeCreate(cwd, agentType, label, resumeId);
+  // WP-2 (§5 D-7): a stamped Recent row is resumed ON its box. The cwd pre-check must ask the same
+  // box (the hub-local worktree check would consult the wrong filesystem), and the create carries
+  // `machine` so the server forwards it. An unstamped row keeps today's message byte for byte.
+  const machine = String(recent?.machine || '').trim();
+  const resumeCwd = machine
+    ? await _resolveMachineResumeCwdBeforeCreate(cwd, machine, label)
+    : await _resolveResumeCwdBeforeCreate(cwd, agentType, label, resumeId);
   if (resumeCwd === null) return;
   send({
     type: 'create',
@@ -824,9 +870,32 @@ async function resumeSession(sessionId, cwd, label) {
     args: resumeSpec.args,
     cwd: resumeCwd || undefined,
     label: label.replace(/^Resume:\s*/i, '').slice(0, 60),
+    ...(machine ? { machine } : {}),
   });
 }
 
+// WP-2 (§5 D-7, §4 `POST /api/path-status` — already proxied with ?machine=). The machine twin of
+// _resolveResumeCwdBeforeCreate: it asks the BOX whether the resume cwd still exists there. A probe
+// that cannot answer never blocks the resume — the create itself reports the real error.
+async function _resolveMachineResumeCwdBeforeCreate(cwd, machine, label) {
+  if (!cwd) return cwd;
+  try {
+    const r = await fetch('/api/path-status?machine=' + encodeURIComponent(machine), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ paths: [cwd] }),
+    });
+    if (!r.ok) return cwd;
+    let d = null;
+    try { d = await r.json(); } catch { /* expected: a probe body that is not JSON leaves the verdict unknown */ }
+    const row = Array.isArray(d?.paths) ? d.paths.find(p => p && p.path === cwd) : null;
+    if (row && row.directory === false) {
+      toast('"' + (label || 'This session').replace(/^Resume:\s*/i, '') + '" was created in a folder that no longer exists on that computer.', { type: 'warning', duration: 7000, key: 'resume-machine-cwd-missing' });
+    }
+  } catch { /* expected: a probe failure must never block the resume the user asked for */ }
+  return cwd;
+}
+
 function resumeWalleSession(sessionId, cwd, label, chatSessionId) {
   if (state.sessions.has(sessionId)) {
     activateTab(sessionId);
@@ -888,6 +957,10 @@ async function reviewSession(sessionId, projectEntry, title, sessionData, opts)
   // Track which review is in flight so stale fetches are discarded
   const reviewRequestId = (state._reviewRequestCounter = (state._reviewRequestCounter || 0) + 1);
   state.reviewingSessionId = sessionId;
+  // WP-1 (§5 D-6, docs/recent-sessions-follow-computer-filter-2026-10-31.html): a stamped Recent row's
+  // transcript lives on that box, so every review page request carries its machine (resolved by
+  // _reviewMessagesUrl). '' for a hub/Local row, which keeps its URL byte-identical.
+  state.reviewMachine = String(sessionData?.machine || '').trim();
   _cancelReviewCatchUp();
 
   // Persist for restore after CTM restart
@@ -1052,8 +1125,11 @@ function closeSessionPalette() {
 // `renderedAt` is the clock the last card render judged D-12 staleness against, so a re-render
 // (a popover pick) cannot move the numbers under the user; `pickerMachine` is the D-1 row picked
 // from the popover, kept for THIS modal session only.
+// `localKeysState` is the D-6 three-state read of THIS Mac's project list: 'idle' (never asked),
+// 'loading', 'ok' (the map is the truth) and 'failed'. A failure is never a latch — the next modal
+// open retries — and it is never reported as "no checkout" (see nsMachineAfterProjectsLoaded).
 const _nsMachineState = {
-  machines: [], localRepoKeyPath: null, localKeysRequested: false, localCwd: '',
+  machines: [], localRepoKeyPath: null, localKeysState: 'idle', localCwd: '',
   renderedAt: 0, pickerMachine: '',
 };
 
@@ -1457,6 +1533,8 @@ function _selectMachineCard(value) {
     });
   }
   _nsMachineSetHint(next ? 'Sessions will spawn on ' + machineSelectionName() + ' — pick a folder on that box.' : '');
+  // WP-13b (D-15): the agent grid's dsh card depends on the picked machine's own agent presence.
+  if (window.NewSessionAgentGrid && typeof window.NewSessionAgentGrid.refresh === 'function') window.NewSessionAgentGrid.refresh();
   // S-13: host-path truth belongs to exactly one machine. Re-run the picker reset on every
   // change — it rebinds the host probe (which now carries ?machine=) and forgets the previous
   // machine's project list — so a box answer can never land on a local path field.
@@ -1468,6 +1546,7 @@ function _selectMachineCard(value) {
     if (typeof _nsPathPickerState !== 'undefined') {
       _nsPathPickerState.machine = next;
       _nsPathPickerState.projectsLoaded = false;
+      _nsPathPickerState.projectsError = false;
       _nsPathPickerState.projects = [];
     }
     _nsPathReset(next ? '' : (typeof getLastSessionCwd === 'function' ? getLastSessionCwd() : ''));
@@ -1508,33 +1587,67 @@ function localProjectKeyFor(cwd, keyPath) {
 
 // Local gitRemoteKey -> path, so the same-repo prefill is a plain key equality against the
 // box's own /api/projects rows. Normalization stays server-side (§6.5).
+//
+// D-6: the read is THREE-state, not a latch. Only 'loading'/'ok' short-circuit — 'idle' and
+// 'failed' both retry, so one timed-out /api/projects (the 10-30 hub read) cannot leave the map
+// null for the page's lifetime and make the picker claim a checkout is missing.
 function loadLocalRepoKeys() {
-  if (_nsMachineState.localKeysRequested) return;
-  _nsMachineState.localKeysRequested = true;
+  const keysState = _nsMachineState.localKeysState;
+  if (keysState === 'loading' || keysState === 'ok') return;
+  _nsMachineState.localKeysState = 'loading';
   const token = (typeof state !== 'undefined' && state.token) || '';
   fetch('/api/projects?token=' + encodeURIComponent(token))
     .then(function(r) { return r.ok ? r.json() : null; })
     .then(function(rows) {
+      if (!Array.isArray(rows)) {
+        // A non-OK answer is a failed read, never an empty project list.
+        _nsMachineState.localKeysState = 'failed';
+        return;
+      }
       const map = Object.create(null);
-      (Array.isArray(rows) ? rows : []).forEach(function(row) {
+      rows.forEach(function(row) {
         if (row && row.path && row.gitRemoteKey) map[String(row.gitRemoteKey)] = row.path;
       });
       _nsMachineState.localRepoKeyPath = map;
+      _nsMachineState.localKeysState = 'ok';
+    })
+    .catch(function() {
+      // expected: without the local key list the picker browses — and the next open retries.
+      _nsMachineState.localKeysState = 'failed';
     })
-    .catch(function() { /* expected: without the local key list the picker simply browses */ });
+    .then(_nsMachineRecheckAfterLocalKeys);
+}
+
+// The box's rows may have arrived while this Mac's list was still loading; judge them now.
+function _nsMachineRecheckAfterLocalKeys() {
+  if (!machineSelection() || typeof _nsPathPickerState === 'undefined') return;
+  if (_nsPathPickerState.projectsLoaded || _nsPathPickerState.projectsError) nsMachineAfterProjectsLoaded(_nsPathPickerState);
 }
 
-// Called by _nsPathLoadProjects once the SELECTED machine's projects answer arrives.
+// D-6: the three-state hint. `ok` + no equal key is today's "No checkout…" copy; `ok` + a match is
+// today's prefill. Anything else (this Mac's list unread, or the box's own read failed) is UNKNOWN,
+// never "no checkout" — the box may well carry the checkout and the user must still be able to pick.
 function nsMachineAfterProjectsLoaded(pickerState) {
   const machine = machineSelection();
   if (!machine) return false;
+  const input = document.getElementById('ns-cwd');
+  if (!input) return false;
+  // Still reading this Mac's list: say nothing final yet — the read's completion re-runs this check.
+  // (A failed BOX read is already final, whatever this Mac's read is doing.)
+  if (!(pickerState && pickerState.projectsError)
+    && (_nsMachineState.localKeysState === 'loading' || _nsMachineState.localKeysState === 'idle')) {
+    _nsMachineSetHint('Checking project lists…');
+    return false;
+  }
+  if (_nsMachineState.localKeysState !== 'ok' || !!(pickerState && pickerState.projectsError)) {
+    _nsMachineSetHint("Couldn't read the project lists right now — pick the folder on " + machineSelectionName() + '.', true);
+    return false;
+  }
   const rows = (pickerState && Array.isArray(pickerState.projects)) ? pickerState.projects : [];
   const localKey = localProjectKeyFor(_nsMachineState.localCwd, _nsMachineState.localRepoKeyPath);
   const match = localKey ? rows.find(function(row) {
     return row && row.path && String(row.gitRemoteKey || '') === localKey;
   }) : null;
-  const input = document.getElementById('ns-cwd');
-  if (!input) return false;
   if (!match) {
     _nsMachineSetHint('No checkout on ' + machineSelectionName() + " carries this project's git remote — browse to a folder on that box.", true);
     return false;
@@ -1550,6 +1663,15 @@ function nsMachineAfterProjectsLoaded(pickerState) {
   return true;
 }
 
+// WP-4 (D-5/§6.5 client half): a 502 whose body carries `box_updating` is not a broken box — it is
+// the box restarting onto `to`. Naming the sha (its first 12 chars) turns "worktree error" into an
+// instruction. '' when the body carries no update, so the caller keeps its own copy.
+function machineUpdatingToastText(boxUpdating) {
+  const to = String((boxUpdating && boxUpdating.to) || '');
+  if (!to) return '';
+  return machineSelectionName() + ' is restarting to apply update ' + to.slice(0, 12) + ' — try again in a minute.';
+}
+
 // Opened with the modal, so the machine list is fresh every time. A hub-less (older) server
 // answers 404 and the modal stays exactly as it was (AC-5a).
 function loadNewSessionMachines() {
@@ -1598,3 +1720,47 @@ function resumeBlockedOpenOnMachineAction(msg, actions, s) {
   actions.appendChild(btn);
   return true;
 }
+
+// ── WP-4 (docs/remote-session-hub-bridge-2026-10-30.html R-13, §8 AC-4a) ────────────────────────────
+// The machine chip is a CONTROL, not decoration: clicking a `.machine-chip` (the sidebar row or the
+// tab chrome) opens the Machines page with that machine's card scrolled into view and briefly
+// highlighted. The handler is registered in the CAPTURE phase and stops propagation, so the row it
+// sits in never also activates its session (the row's own click would switch tabs).
+function machineChipMachineId(chip) {
+  if (!chip) return '';
+  const dataset = chip.dataset || {};
+  return String(dataset.machineId || dataset.machineName || '').trim();
+}
+
+/** Open the Machines page at one machine. navTo routes through showMachinesPanel's reveal hook. */
+function machineChipOpen(machineId, machineName) {
+  const id = String(machineId || '');
+  const name = String(machineName || '');
+  if (typeof navTo === 'function') {
+    navTo('machines', { revealMachine: id, revealMachineName: name });
+    return true;
+  }
+  // No navTo (a unit slice): the reveal itself is machines-page.js's single implementation.
+  return typeof machinesPageRevealCard === 'function' ? machinesPageRevealCard(id, name) : false;
+}
+
+/** Capture-phase delegated click: the chip wins, the row's own activation never runs. */
+function machineChipClick(event) {
+  if (!event) return false;
+  const target = event.target;
+  const chip = target && typeof target.closest === 'function' ? target.closest('.machine-chip') : null;
+  if (!chip) return false;
+  if (typeof event.stopPropagation === 'function') event.stopPropagation();
+  if (typeof event.preventDefault === 'function') event.preventDefault();
+  const dataset = chip.dataset || {};
+  return machineChipOpen(machineChipMachineId(chip), String(dataset.machineName || ''));
+}
+
+function bindMachineChipClickThrough(doc) {
+  const target = doc || (typeof document !== 'undefined' ? document : null);
+  if (!target || typeof target.addEventListener !== 'function') return false;
+  target.addEventListener('click', machineChipClick, true);
+  return true;
+}
+
+bindMachineChipClickThrough();

package/template/coding-task-manager/public/js/dashboard-client-function-order.json

@@ -1381,6 +1381,9 @@
     "isActiveProjectCollapsed",
     "persistActiveProjectCollapsedKeys",
     "toggleActiveProjectGroup",
+    "setActiveComputerFilter",
+    "syncActiveComputerFilterChips",
+    "syncActiveComputerMenu",
     "activeListSessionCount",
     "activeListCanCollapse",
     "activeListMinVisibleLimit",
@@ -1392,6 +1395,11 @@
     "updateActiveListExpansionFromDividerDrag",
     "updateActiveListDividerAffordance",
     "tabOrderSortCmp",
+    "landingEtaText",
+    "landingQueueText",
+    "landingChipText",
+    "landingBadgeParts",
+    "landingBadgeHtml",
     "worktreeAttentionBadge",
     "branchDisplayParts",
     "branchDisplayTitle",

package/template/coding-task-manager/public/js/document-review-links.js

@@ -610,7 +610,15 @@ function _terminalGestureWasSelection(term) {
   const sel = (typeof window !== 'undefined' && typeof window.getSelection === 'function')
     ? window.getSelection()
     : null;
-  return !!(sel && typeof sel.toString === 'function' && sel.toString().length > 0);
+  if (!(sel && typeof sel.toString === 'function' && sel.toString().length > 0)) return false;
+  // Inside the terminal, xterm's own selection (checked above) is the truth. A native DOM selection
+  // can remain over the terminal's row spans independently of term.clearSelection(). Such a
+  // mirror must not block activation when xterm has no selection (the Linux link-click incident,
+  // design nightly-linux-host-portability-2026-10-27). A range that reaches outside the terminal
+  // is still a real page selection.
+  const host = term && term.element;
+  const inside = (node) => !!(node && host && typeof host.contains === 'function' && host.contains(node));
+  return !(inside(sel.anchorNode) && inside(sel.focusNode));
 }
 
 // xterm's documented hover contract: the element must live inside Terminal.element and

package/template/coding-task-manager/public/js/file-resolution-client.js

@@ -36,10 +36,15 @@
     return { kind: 'error', message };
   }
 
+  // D-4: a lone modifier press is not "typing elsewhere" — it must not dismiss the panel.
+  const LONE_MODIFIER_KEYS = new Set(['Shift', 'Control', 'Alt', 'Meta', 'CapsLock']);
+
   function create(opts) {
     const options = opts || {};
     const counts = Object.create(null);
     let last = null;
+    // D-7: at most one panel is open; opening a new one dismisses the open one first.
+    let activeDismiss = null;
 
     function loadedAssetEpoch() {
       const script = Array.from(document.scripts).find((item) => /\/file-resolution-client\.js(?:\?|$)/.test(item.src || ''));
@@ -69,8 +74,14 @@
 
     function dialogFor(outcome) {
       return new Promise((resolve) => {
+        // D-7: one panel at a time. Dismiss the open one (exactly a Close) before building.
+        if (activeDismiss) activeDismiss();
         const dialog = document.createElement('dialog');
         dialog.className = 'ctm-file-menu ctm-file-resolution-dialog';
+        // D-9: a non-modal dialog sits at its static position, and the phone shell does not load
+        // reviews.css, so the top-left placement the user already sees is set inline.
+        dialog.style.cssText = 'position:fixed;top:12px;left:12px;right:auto;bottom:auto;margin:0;'
+          + 'z-index:100050;max-width:min(420px, calc(100vw - 24px))';
         const heading = document.createElement('strong');
         heading.textContent = outcome.kind === 'ambiguous' ? 'Choose the file'
           : outcome.kind === 'incomplete' ? 'File search incomplete' : 'Link details';
@@ -79,11 +90,37 @@
         message.textContent = outcome.message || 'File resolution failed';
         dialog.appendChild(message);
 
+        let done = false;
+        // D-8: finish runs once; it removes both document listeners, clears activeDismiss if it
+        // is its own, closes and removes the dialog, then resolves.
         const finish = (value) => {
+          if (done) return;
+          done = true;
+          document.removeEventListener('pointerdown', onPointerDown, true);
+          document.removeEventListener('keydown', onKeyDown, true);
+          if (activeDismiss === dismiss) activeDismiss = null;
           if (dialog.open && typeof dialog.close === 'function') dialog.close();
           dialog.remove();
           resolve(value);
         };
+        const dismiss = () => finish(null);
+        // D-3: a press outside is a Close and is never swallowed — the press still reaches target.
+        function onPointerDown(event) {
+          if (!dialog.contains(event.target)) finish(null);
+        }
+        // D-4/D-5: Escape closes and is consumed; any other non-modifier key outside is a Close
+        // that is not consumed, so the keystroke still lands where the user was typing.
+        function onKeyDown(event) {
+          if (event.key === 'Escape') {
+            event.preventDefault();
+            event.stopPropagation();
+            finish(null);
+            return;
+          }
+          if (event.isComposing) return;
+          if (LONE_MODIFIER_KEYS.has(event.key)) return;
+          if (!dialog.contains(event.target)) finish(null);
+        }
         if (outcome.kind === 'ambiguous') {
           for (const candidate of (outcome.candidates || []).slice(0, 20)) {
             const button = document.createElement('button');
@@ -112,8 +149,22 @@
         dialog.appendChild(close);
         dialog.addEventListener('cancel', (event) => { event.preventDefault(); finish(null); });
         document.body.appendChild(dialog);
-        if (typeof dialog.showModal === 'function') dialog.showModal();
+        // D-1: non-modal — the page stays interactive. D-2: record who had focus, then give it back.
+        const prev = document.activeElement;
+        if (typeof dialog.show === 'function') dialog.show();
         else dialog.setAttribute('open', '');
+        if (dialog.contains(document.activeElement)) {
+          const inside = document.activeElement;
+          if (prev && typeof Element !== 'undefined' && prev instanceof Element
+            && prev !== document.body && prev.isConnected) {
+            prev.focus({ preventScroll: true });
+          } else if (inside && typeof inside.blur === 'function') {
+            inside.blur();
+          }
+        }
+        activeDismiss = dismiss;
+        document.addEventListener('pointerdown', onPointerDown, true);
+        document.addEventListener('keydown', onKeyDown, true);
       });
     }
 

package/template/coding-task-manager/public/js/history-app-seam.js

@@ -870,6 +870,23 @@
     }
     return session.agentType || (session.meta && session.meta.agentType) || '';
   }
+  // WP-1 (wheel-reader-only-where-history-exists-2026-10-28 §5 D-3): the continuous reader can only
+  // serve a provider the server has a reader source for -- claude (JSONL window) or codex (rollout
+  // lanes), i.e. `historyReader: 'transcript'` in index.html's CLIENT_AGENT_CAPABILITIES, read through its
+  // _clientAgentCaps/_clientAgentTypeForSession globals. Every other provider (opencode, gemini, walle,
+  // cursor, shell) is 'none': its wheel-up forwards the SGR report to the app instead of opening a
+  // reader that exits at once with source-missing. The ONE implementation -- index.html calls it as
+  // HistoryAppSeam.historyReader (index.html sits at its hard size ceiling); the claude/codex fallback
+  // is for node unit tests, where those globals are absent.
+  function historyReader(session) {
+    const g = typeof globalThis !== 'undefined' ? globalThis : {};
+    if (typeof g._clientAgentCaps === 'function' && typeof g._clientAgentTypeForSession === 'function') {
+      return g._clientAgentCaps(g._clientAgentTypeForSession(session)).historyReader === 'transcript';
+    }
+    if (!session) return false;
+    const kind = liveAgentKind(session);
+    return kind === 'codex' || kind === 'claude';
+  }
   function prefetchContinuousPage(c, opts) {
     if (!c || c.active || c._continuousPrefetchInFlight) return false;
     const ttlMs = Number(opts && opts.ttlMs) > 0 ? Number(opts.ttlMs) : PREFETCH_TTL_MS;
@@ -901,13 +918,16 @@
         agentKind: liveAgentKind(session),
         hasScrollback: Number(buf.baseY) > 0,
         readerOpen: !!c.active,
+        historyReader: historyReader(session),
       }), {
         terminalMouseState: StateSync.terminalMouseState,
         terminalWheelRoute: StateSync.terminalWheelRoute,
       });
       // `deltaY: -1` above: this probe asks "would a wheel-UP open the reader?" -- a proven mouse OR
       // a Codex alt-screen tab (D-4, codexAltReaderUp) answers yes.
-      if (!decision.isAlt || decision.parkedInLocalScrollback || !(decision.mouseActive || decision.codexAltReaderUp)) return false;
+      // WP-1: a provider with no reader source never prefetches -- its wheel-up forwards to the app.
+      if (!decision.historyReader || !decision.isAlt || decision.parkedInLocalScrollback
+        || !(decision.mouseActive || decision.codexAltReaderUp)) return false;
       key = liveSeqKey(session);
     } catch {
       // expected: unreadable live terminal/session facts fail closed before any prefetch state mutation
@@ -1441,7 +1461,7 @@
     prefetchNextSegment, enterAboveApp, exitToApp, showBoundaryChip, applyTranscriptWindowBody,
     onTranscriptScroll, fetchTranscriptPage, loadOlderTranscriptWindow, loadNewerTranscriptWindow,
     renderTranscript, resetContinuous, readRenderDiagnostics,
-    enterContinuous, prefetchContinuousPage, rejoin, epochChanged, joinDiag,
+    enterContinuous, prefetchContinuousPage, rejoin, epochChanged, joinDiag, historyReader,
     exitContinuous,
     // WP-3 (D-8/D-9): the fetch-ahead scheduler's window onto the page fetcher's retry bookkeeping.
     planPageFetch, pageRetryPending, hasFailedPage, clearFailedPage, dropPageRetries, abortTranscriptPage,