@leftoff/cli 0.9.7 → 0.9.8-beta.10

package/ui/app.js

@@ -9,15 +9,26 @@ import { changedKeys } from './settings-dirty.js'
 import { looksMd, stripMd, plainCp } from './cp-text.js'
 import { beginWriting, settleWriting, reconcileWriting, dismissWriting, isWriting, writingText, WRITING_SYNC_MS, FRESH_MS } from './writing.js'
 import { inStatus, repoChips, applyFilter, readFilter, saveRepos, filterHash, toggleRepo, chipSelected, splitChips, repoMatches, orderSelectedFirst, searchMatches, saveProject, inProject, projectChips, projectLabel } from './repos.js'
+import { navKey, moreActive, badgeText, quickLookItems, quickLookHtml } from './nav.js'
+import { canStartPull, pullStep, pullRelease } from './pull.js'
+import { navHideStep, NAVHIDE_TYPING } from './navhide.js'
+import { wireTips } from './tips.js'
 import { needsItems, needsStrip, needPanel, agentNeedPanel, httpsOnly, agentReplyButton, agentChipHtml, cardBadge, questionAnswer, turnsHtml, dismissedHtml } from './needs.js'
 import { SUMMARY_EXAMPLES, LENGTH_CHOICES } from './summary-examples.js'
 import { mdInline, renderSection } from './changelog-md.js'
 import { cardPrsHtml, sessionPrsSection, prsPageHtml, prsBodyHtml, prRowHtml, prRows, readPrFilter, prsHash } from './prs.js'
 import { wantsSetupBanner, setupCandidate, localLeftoffAnswers, thisOneSuffix, isPhoneUa } from './viewer.js'
-import { restoreAccess, hintHtml, restoreWhen } from './restore-gate.js'
+import { restoreAccess, hintHtml, restoreWhen, askLine } from './restore-gate.js'
 import { defaultEmoji, PICKER_SET, isEmoji } from './machines.js'
+import { sessionTitle, titleIsWhere, titleHtml, cardPills, foldsAsEmpty, threadHtml, earlierHtml, createLiveKeeper, liveHref, parseLiveRoute, hasUnread, scrollDecision, atBottom, jumpView, liveBadgeHtml, lockPulses, liveWorking } from './live-view.js' // 0.9.8 Live link polish
+import { statusView, elapsedText } from './live-status.js'
+import { anyPending, shouldPoll, streamDead, isStale, liveSignature, wakeReason, createWake, createWatchdog, HEARTBEAT_MS, POLL_MS, AWAY_MS } from './live-wake.js' // 0.9.8 live after sleep
+import { mountPush, paintPush } from './push.js' // 0.9.8 phone notifications
+import { TABS_KEY, layoutFor, parseStored, serialize, openTab, promote, remember, closeTab, moveTab, neighbours, indexOf, sessionOfHash, keepHash, tabView, stripHtml, allTabsItems, openRowHtml, pagerHtml, swipeDir } from './tabs.js' // 0.9.8 tabs for sessions
 import { todosSection, sessionTodosSection, cardHandoffChips, sessionFilesSection, docViewerBody, docDownloadHref, docMenuItems, docFileName, renderDoc } from './handoffs.js'
 const $app = document.getElementById('app')
+// 0.9.8: the pulsing dots (Live while Claude works, active, a blocking ask) keep their beat through the board's redraws
+if (typeof MutationObserver === 'function') new MutationObserver(() => lockPulses(document)).observe(document.body, { childList: true, subtree: true })
 const state = { sessions: [], health: null, cfg: null, route: null, machine: localStorage.getItem('cp.machine') || '', drafts: {}, pendingAsk: {}, mayAnswer: true, needOpen: {}, needTurns: {} }
 const multi = () => !!(state.health && state.health.machines && state.health.machines.length > 1)
 const agentNames = () => [...new Set(((state.health && state.health.agents) || []).map((a) => a.display || a.name))]
@@ -108,10 +119,16 @@ async function copy(text) {
 // 0.8.7: the copy icon says it worked for a moment (a check, "Copied"), then goes back.
 function copiedMark(btn) {
   clearTimeout(btn._copied)
+  const tip = btn._tip || (btn._tip = btn.title || 'Copy resume command')
   btn.classList.add('copied'); btn.innerHTML = icon('check'); btn.setAttribute('aria-label', 'Copied'); btn.title = 'Copied'
-  btn._copied = setTimeout(() => { btn.classList.remove('copied'); btn.innerHTML = icon('copy'); btn.setAttribute('aria-label', 'Copy resume command'); btn.title = 'Copy resume command' }, 1500)
+  btn._copied = setTimeout(() => { btn.classList.remove('copied'); btn.innerHTML = icon('copy'); btn.setAttribute('aria-label', 'Copy resume command'); btn.title = tip }, 1500)
 }
 const pill = (status) => '<span class="pill s-' + esc(status) + '">' + esc(LABEL[status] || status) + '</span>'
+// 0.9.8 Live link: the session's channel is listening (send it prompts from here)
+// It pulses while Claude is running a turn (liveWorking), steady when idle; lockPulses keeps redraws from restarting it.
+const liveBadge = (s) => liveBadgeHtml(s)
+// The status pill beside it: a live session that is only waiting shows just Live (never "dormant").
+const statusPill = (s) => { const st = cardPills(s).status; return st ? pill(st) : '' }
 
 const fmtCode = (x) => esc(x).replace(/`([^`]+)`/g, '<code>$1</code>')
 
@@ -175,11 +192,11 @@ function wtChips(s) {
   return h
 }
 
-function where(s) {
+function where(s, { repo = true } = {}) {
   if (s.agent) return (s.project ? '<button type="button" class="chip mono repo-link" data-action="repo" data-repo="' + esc(s.repoLabel) + '" data-key="' + esc(s.repoKey || '') + '" title="' + esc(s.repoLabel + ' · show only this project') + '">' + esc(s.repoLabel) + '</button>' : '') + agentChip(s.agent)
   const branch = s.repo && s.repo.branch
   const label = s.repoLabel || s.repoName || 'no repo'
-  return projChip(s) + '<button type="button" class="chip mono repo-link" data-action="repo" data-repo="' + esc(label) + '" data-key="' + esc(s.repoKey || '') + '" title="' + esc((s.repoKey || label) + ' · show only this repo') + '">' + esc(label) + (branch ? ' · ' + esc(branch) : '') + '</button>' + wtChips(s) +
+  return projChip(s) + (repo ? '<button type="button" class="chip mono repo-link" data-action="repo" data-repo="' + esc(label) + '" data-key="' + esc(s.repoKey || '') + '" title="' + esc((s.repoKey || label) + ' · show only this repo') + '">' + esc(label) + (branch ? ' · ' + esc(branch) : '') + '</button>' : '') + wtChips(s) +
     (multi() || !s.isLocal ? (() => { const sn = s.isLocal ? '' : staleNote(s.machine); return '<button type="button" class="chip machine' + (s.isLocal ? '' : ' remote') + (sn ? ' stale' : '') + '" title="' + (s.isLocal ? 'this machine' : sn ? 'showing data as of ' + esc(sn.replace(/^as of /, '')) + ': ' + esc(s.machine) + ' hasn’t synced since' : 'synced from another machine') + '" data-action="machine-emoji" data-machine="' + esc(s.machine) + '"><span class="memo">' + esc(mEmoji(s.machine)) + '</span> ' + esc(s.machine) + (sn ? ' · ' + esc(sn) : '') + '</button>' })() : '') + modelChip(s)
 }
 
@@ -378,9 +395,13 @@ function liveNote(s) {
   if (s.live === 'open' && s.liveVia === 'heartbeat' && !s.isLocal) return 'open (heartbeat)'
   return s.live === 'open' ? 'open' : ''
 }
-function goButton(s) {
+// 0.9.8: { page: true } is the session page's header, where a Go that can't run
+// is left out (its tooltip was the only place the reason showed, and the grey
+// box read as broken); a card keeps the dimmed Go and its short why.
+function goButton(s, { page = false } = {}) {
   if (s.live === 'closed') return ''
   const j = s.jump || {}
+  if (page && (state.viewerLocal === false || !j.supported)) return ''
   // Another machine's session (v0.5.2): Go runs there, through its Leftoff, when it allows it.
   if (!s.isLocal) {
     if (!j.peer) return ''
@@ -430,8 +451,12 @@ function agentCard(s) {
 // closed), a small copy icon for the resume command, and "⋯" for the rest. The
 // ⋯ menu's items ride in the card as an inert <template> (real buttons with the
 // same data-action as before), so the one click handler below runs them unchanged.
+// What Resume runs: codex resume, claude --resume, or for a Live session (0.9.8)
+// leftoff live -- --resume, so it comes back Live.
+function resumeVerb(s) { return s.codingAgent === 'codex' ? 'codex resume' : s.resumeLive ? 'leftoff live -- --resume' : 'claude --resume' }
+function resumeTip(s, lead) { return lead + ': ' + resumeVerb(s) + (s.resumeLive ? ' (it comes back Live)' : '') }
 function copyResumeIcon(s) {
-  return '<button type="button" class="btn icon-btn copy-resume" data-action="resume" data-id="' + esc(s.id) + '" aria-label="Copy resume command" title="Copy resume command">' + icon('copy') + '</button>'
+  return '<button type="button" class="btn icon-btn copy-resume" data-action="resume" data-id="' + esc(s.id) + '" aria-label="Copy resume command" title="' + esc(resumeTip(s, 'Copy resume command')) + '">' + icon('copy') + '</button>'
 }
 // items: [{ action, label, icon, title, attrs }]
 // 0.9.2: an item may also be { note } (a plain line, no button) and carry a sub line.
@@ -548,7 +573,7 @@ function checkpointSplit(s) {
       '<button type="button" class="btn primary split-more" disabled aria-disabled="true" aria-label="Checkpoint length">' + icon('chevron-down') + '</button></span>'
   }
   return '<span class="split" role="group" aria-label="Checkpoint now">' +
-    '<button type="button" class="btn primary split-main" data-action="checkpoint" data-id="' + esc(s.id) + '" data-length="' + esc(def) + '" title="' + esc('Checkpoint now · ' + lengthLabel(def) + (s.isLocal ? '' : ' · written on ' + s.machine)) + '">Checkpoint now</button>' +
+    '<button type="button" class="btn primary split-main" data-action="checkpoint" data-id="' + esc(s.id) + '" data-length="' + esc(def) + '" title="' + esc('Checkpoint now · ' + lengthLabel(def) + (s.isLocal ? '' : ' · written on ' + s.machine)) + '" aria-label="Checkpoint now">' + icon('bookmark-plus') + 'Checkpoint</button>' +
     '<button type="button" class="btn primary split-more" data-action="cp-lengths" data-id="' + esc(s.id) + '" aria-label="Checkpoint length" title="Choose the length" aria-haspopup="menu" aria-expanded="false">' + icon('chevron-down') + '</button></span>'
 }
 function openLengthMenu(btn, id) {
@@ -572,15 +597,15 @@ function card(s) {
   const nb = s.needsYou ? cardBadge(s.needsYou) : ''
   return '<article class="card ' + esc(s.status) + (s.live === 'closed' ? ' is-closed' : '') + (s.needsYou && s.needsYou.blocking ? ' needs-you' : '') + '" data-id="' + esc(s.id) + '" data-href="#/s/' + esc(encodeURIComponent(s.id)) + '">' +
     '<div class="row1"><div class="title">' + liveDot(s) +
-      (s.pinned ? '<span class="pin">★ </span>' : '') + '<a href="#/s/' + encodeURIComponent(s.id) + '">' + esc(s.title || 'Untitled session') + '</a>' +
+      (s.pinned ? '<span class="pin">★ </span>' : '') + '<a href="#/s/' + encodeURIComponent(s.id) + '">' + titleHtml(sessionTitle(s), esc) + '</a>' +
       '<button type="button" class="icon" data-action="rename" title="Rename">✎</button>' +
-    '</div>' + pill(s.status) + '</div>' +
-    '<div class="meta">' + spaceChip(s) + where(s) + (ln ? '<span class="livenote ' + esc(s.live) + '">' + esc(ln) + '</span>' : '') + (endedNote ? '<span>' + esc(endedNote) + '</span>' : '') + '<span>·</span><span>' + esc(s.turns) + (s.turns === 1 ? ' turn' : ' turns') + (s.historyTurns ? ' · resumed (' + esc(s.historyTurns) + ' before)' : s.startSource === 'resume' && !s.turns ? ' · resumed' : s.empty && s.live !== 'closed' ? ' · no prompt yet' : '') + '</span>' +
+    '</div>' + statusPill(s) + liveBadge(s) + '</div>' +
+    '<div class="meta">' + spaceChip(s) + where(s, { repo: !titleIsWhere(s) }) + (ln ? '<span class="livenote ' + esc(s.live) + '">' + esc(ln) + '</span>' : '') + (endedNote ? '<span>' + esc(endedNote) + '</span>' : '') + '<span>·</span><span>' + esc(s.turns) + (s.turns === 1 ? ' turn' : ' turns') + (s.historyTurns ? ' · resumed (' + esc(s.historyTurns) + ' before)' : s.startSource === 'resume' && !s.turns ? ' · resumed' : s.empty && s.live !== 'closed' && !cardPills(s).live ? ' · no prompt yet' : '') + '</span>' +
       (s.needsInput && s.lastNotification && !s.needsYou ? '<span class="chip">' + esc(s.lastNotification.replace(/_/g, ' ')) + '</span>' : '') + '</div>' +
     cardPrsHtml(s.prs) + listChips(s) + cardHandoffChips(s) + nb + cpArea(s, cpBlock(s.latestCheckpoint)) +
     '<a class="cplink" href="#/s/' + encodeURIComponent(s.id) + '">' + (s.checkpointCount ? s.checkpointCount + (s.checkpointCount === 1 ? ' checkpoint' : ' checkpoints') : 'Session history') + ' →</a>' +
     '<div class="actions-row">' + (goButton(s) || (s.status === 'ended' || s.live === 'closed' ? resumeButton(s, s.viewer || { local: state.viewerLocal !== false, ghostty: !!state.ghostty }) : '')) +
-      copyResumeIcon(s) +
+      chatButton(s) + copyResumeIcon(s) +
       (s.isLocal ? '' : remoteNote(s)) + moreMenu(s, sessionMenuItems(s)) +
     '</div></article>'
 }
@@ -751,7 +776,7 @@ async function viewBoard() {
   // not a resumed conversation) fold into one "N empty sessions" row. One
   // appears on the board as itself after its first prompt. Pinned ones, and
   // ones that need you, always show.
-  const isFolded = (s) => s.empty && !s.pinned && !(s.needsYou && s.needsYou.blocking)
+  const isFolded = (s) => foldsAsEmpty(s) // 0.9.8: never a live session
   const shown = recent.filter((s) => !isFolded(s))
   const empties = recent.filter(isFolded)
   const rank = Object.fromEntries(ORDER.map(([k], i) => [k, i]))
@@ -787,7 +812,7 @@ async function viewBoard() {
     '<a class="btn primary" href="#/catchup/new">' + icon('coffee') + 'Catch me up</a>' +
     '<a class="btn" href="#/digest">' + icon('newspaper') + 'Today’s digest →</a></div></div>'
   html += syncDetails() + staleLine(sessions)
-  html += restoreBanner()
+  html += restoreAsksBanner() + restoreBanner()
   // Needs you (v0.4.4): every session waiting on you, whatever the filters, longest wait first.
   const needs = needsItems(sessions)
   html += needsStrip(needs, needOpts())
@@ -799,6 +824,7 @@ async function viewBoard() {
   html += projectRow(spaced, pj, 'board-project')
   if (filter === 'closed') {
     html += await closedSection(f, sp)
+    if (parseRoute().name === 's') return // 0.9.8: you opened a session while the board loaded
     $app.innerHTML = banners() + html
     return closedWire()
   }
@@ -840,6 +866,7 @@ function boardSearch(q, closedHits, n) {
 // A repaint from a live update (or the 30 s refresh) while you type in the
 // search box keeps the box focused, with what you typed and the caret.
 function paintBoardKeepingSearch(h) {
+  if (parseRoute().name === 's') return // 0.9.8: a slow board answer never paints over the session you opened
   const old = document.getElementById('boardQ')
   const keep = old && document.activeElement === old ? { v: old.value, pos: old.selectionStart } : null
   $app.innerHTML = h
@@ -919,10 +946,10 @@ function resumeButton(s, viewer = {}) {
   const busy = closedUi.busy.has(s.id)
   if (s.isLocal) {
     if (!viewer.ghostty) return ''
-    return '<button type="button" class="btn primary" data-action="resume-open" data-id="' + esc(s.id) + '"' + (busy ? ' disabled' : '') + ' title="Open it in a new Ghostty tab: ' + (s.codingAgent === 'codex' ? 'codex resume' : 'claude --resume') + '">' + icon('rotate-ccw') + (busy ? 'Opening…' : 'Resume') + '</button>'
+    return '<button type="button" class="btn primary" data-action="resume-open" data-id="' + esc(s.id) + '"' + (busy ? ' disabled' : '') + ' title="' + esc(resumeTip(s, 'Open it in a new Ghostty tab')) + '">' + icon('rotate-ccw') + (busy ? 'Opening…' : 'Resume') + '</button>'
   }
   if (!(s.peer && s.peer.ok)) return '' // that Mac can't be reached from here: Copy resume
-  return '<button type="button" class="btn primary" data-action="resume-open" data-id="' + esc(s.id) + '"' + (busy ? ' disabled' : '') + ' title="' + esc('Open it in a new Ghostty tab on ' + s.machine) + '">' + icon('rotate-ccw') + (busy ? 'Opening…' : 'Resume on ' + esc(s.machine)) + '</button>'
+  return '<button type="button" class="btn primary" data-action="resume-open" data-id="' + esc(s.id) + '"' + (busy ? ' disabled' : '') + ' title="' + esc(resumeTip(s, 'Open it in a new Ghostty tab on ' + s.machine)) + '">' + icon('rotate-ccw') + (busy ? 'Opening…' : 'Resume on ' + esc(s.machine)) + '</button>'
 }
 function closedCard(s, viewer) {
   const href = '#/s/' + encodeURIComponent(s.id)
@@ -1039,14 +1066,49 @@ function emptyFold(list) {
 // (0.9.7: or when the terminal quit),
 // with a checkbox each; Restore opens each in a new Ghostty tab, resumed by id.
 // Opening tabs runs on the Mac, so (like Go) only its own browser may press it.
-const restoreUi = { open: false, off: new Set(), result: null }
+const restoreUi = { open: false, off: new Set(), result: null, ask: null, busy: new Set() }
 function restoreDismissKey(r) { return 'lo.restore.dismissed:' + (r.restartAt || '') }
 function restorePicked() { const r = state.restore; return r ? r.sessions.filter((s) => !restoreUi.off.has(s.id)) : [] }
 // 0.9.7: this Mac's own board, or the hosted board open on it (the direct path)
 function restoreGate() {
   const lr = window.leftoffRelay, r = state.restore || {}
   return restoreAccess({ local: state.viewerLocal !== false, hosted: !!lr, route: lr ? lr.route : null, routeMac: lr ? lr.mac : null, machine: r.machine || null,
-    phone: isPhoneUa(navigator.userAgent, { maxTouchPoints: navigator.maxTouchPoints || 0 }) })
+    phone: isPhoneUa(navigator.userAgent, { maxTouchPoints: navigator.maxTouchPoints || 0 }), canAsk: Array.isArray(r.asks) })
+}
+// 0.9.8: Restore asked from a phone or another Mac, waiting on THIS Mac: confirm
+// or decline here (this Mac's own board, or the hosted board open on it).
+function restoreAsksBanner() {
+  const r = state.restore
+  const asks = r && Array.isArray(r.asks) ? r.asks : []
+  if (!asks.length) return ''
+  const gate = restoreGate()
+  const here = gate.how === 'local' || gate.how === 'direct'
+  return asks.map((a) => {
+    const what = a.count + ' session' + (a.count === 1 ? '' : 's') + (a.titles && a.titles.length ? ': ' + a.titles.join(', ') + (a.count > a.titles.length ? '…' : '') : '')
+    const busy = restoreUi.busy.has(a.id)
+    return '<div class="banner warn restore-ask" role="alert" data-ask="' + esc(a.id) + '"><span class="grow"><b>' + esc(a.who || 'Another device') + ' asks to restore ' + esc(what) + '</b> on ' + esc(r.machine || 'this Mac') + '. ' +
+      (here ? 'Open them here, each in a new Ghostty tab?' : 'Someone at ' + esc(r.machine || 'that Mac') + ' has to confirm it there.') + ' <span class="rs-m">Until ' + esc(clock(a.expiresAt)) + '.</span></span>' +
+      (here ? '<button type="button" class="btn primary" data-action="restore-ask-confirm" data-id="' + esc(a.id) + '"' + (busy ? ' aria-disabled="true"' : '') + '>' + icon('rotate-ccw') + (busy ? 'Opening…' : 'Open ' + a.count + ' tab' + (a.count === 1 ? '' : 's')) + '</button>' +
+        '<button type="button" class="btn" data-action="restore-ask-decline" data-id="' + esc(a.id) + '"' + (busy ? ' aria-disabled="true"' : '') + '>Decline</button>' : '') + '</div>'
+  }).join('')
+}
+function restoreAskNote() {
+  const x = askLine(restoreUi.ask, { clock })
+  return x ? '<span class="rs-note rs-ask ' + x.tone + '" id="restoreAskNote" role="status">' + hintHtml(x.text, esc) + '</span>' : ''
+}
+// The asker's side: poll the request until it's settled.
+async function pollRestoreAsk() {
+  const a = restoreUi.ask
+  if (!a || !a.id || !['pending', 'confirming'].includes(a.state)) return
+  try {
+    const r = await api('GET', '/v1/restore/asks/' + encodeURIComponent(a.id) + (a.machine ? '?machine=' + encodeURIComponent(a.machine) : ''))
+    if (restoreUi.ask && restoreUi.ask.id === a.id) {
+      const changed = r.state !== a.state
+      restoreUi.ask = { ...a, ...r, machine: a.machine || r.machine }
+      if (changed) { const el = document.getElementById('restoreBanner'); if (el) el.outerHTML = restoreBanner(); if (r.state === 'confirmed') toast('Restored on ' + (a.machine || 'that Mac')) }
+    }
+  } catch (e) { if (restoreUi.ask && restoreUi.ask.id === a.id && /gone|not_found/.test(String(e.message))) restoreUi.ask = { ...a, state: 'failed', error: e.message } }
+  if (restoreUi.ask && ['pending', 'confirming'].includes(restoreUi.ask.state)) setTimeout(pollRestoreAsk, 2000)
 }
 function restoreBanner() {
   const r = state.restore
@@ -1062,17 +1124,18 @@ function restoreBanner() {
   }
   const gate = restoreGate()
   const picked = restorePicked().length
+  const asking = restoreUi.ask && ['pending', 'confirming'].includes(restoreUi.ask.state)
   const rows = r.sessions.map((s) => '<label class="rs-row"><input type="checkbox" name="rs" value="' + esc(s.id) + '"' + (restoreUi.off.has(s.id) ? '' : ' checked') + '>' +
     '<span class="rs-main"><span class="rs-t">' + esc(s.title || '(untitled)') + '</span><span class="rs-m">' + esc([s.repoLabel, s.branch, s.modelLabel, s.lastAliveAt ? 'last seen ' + ago(s.lastAliveAt) : null, 'cp:' + (s.shortId || s.id.slice(0, 8))].filter(Boolean).join(' · ')) + '</span>' + (s.blocked ? '<span class="rs-m err">' + esc(s.error) + '</span>' : '') + '</span></label>').join('')
   return '<div class="banner info restore open" id="restoreBanner" role="region" aria-label="Restore sessions"><div class="rs-head"><span class="grow">' + head + '. Each opens in a new Ghostty tab, in its folder, with <code>claude --resume</code> and its name.</span>' +
     '<button type="button" class="btn x" data-action="restore-close" aria-label="Close" title="Close">✕</button></div>' +
     '<div class="rs-list">' + rows + '</div>' +
     '<div class="rs-actions">' +
-    '<button type="button" class="btn primary" data-action="restore-go" id="restoreGo" data-how="' + (gate.how || 'off') + '"' + (gate.ok && picked ? '' : ' aria-disabled="true"') +
-      (gate.ok ? '' : ' aria-describedby="restoreHint" title="' + esc(gate.hint.replace(/`/g, '')) + '"') + '>' + icon('rotate-ccw') + 'Restore ' + picked + '</button>' +
+    '<button type="button" class="btn primary" data-action="restore-go" id="restoreGo" data-how="' + (gate.how || 'off') + '"' + (gate.ok && picked && !asking ? '' : ' aria-disabled="true"') +
+      (gate.ok && gate.how !== 'ask' ? '' : ' aria-describedby="restoreHint"') + (gate.ok ? '' : ' title="' + esc(gate.hint.replace(/`/g, '')) + '"') + '>' + icon('rotate-ccw') + 'Restore ' + picked + '</button>' +
     '<button type="button" class="btn" data-action="restore-all">' + (picked === r.sessions.length ? 'Select none' : 'Select all') + '</button>' +
     '<button type="button" class="btn" data-action="restore-copy">Copy commands</button>' +
-    (gate.ok ? '' : '<span class="rs-note" id="restoreHint">' + hintHtml(gate.hint, esc) + '</span>') +
+    (restoreUi.ask ? restoreAskNote() : gate.ok && gate.how !== 'ask' ? '' : '<span class="rs-note" id="restoreHint">' + hintHtml(gate.hint, esc) + '</span>') +
     '</div>' + (restoreUi.result ? restoreResult() : '') + '</div>'
 }
 // 0.9.7: the hosted board found (or lost) this Mac's direct path: Restore follows it
@@ -1130,9 +1193,11 @@ async function viewWaiting() {
 // The nav's count, the page title and the favicon dot: visible from a background tab.
 function paintNeedsCount(n) {
   const c = document.getElementById('needsCount')
-  if (c) { c.hidden = !n; c.textContent = n > 99 ? '99+' : String(n) }
+  if (c) { c.hidden = !n; c.textContent = badgeText(n) }
   const tab = document.getElementById('needsTab')
   if (tab) { tab.classList.toggle('has-needs', !!n); tab.title = n ? n + ' waiting on you' : 'Nothing waiting on you' }
+  if (quickLookOpen() && paintNeedsCount.count !== n) loadQuickLook()
+  paintNeedsCount.count = n
   document.title = (n ? '(' + n + ') ' : '') + 'Leftoff'
   // The tab icon gets a red dot while something waits (leftoff-favicon-badge,
   // v0.4.5); the PNG is for browsers without SVG favicons.
@@ -1158,7 +1223,7 @@ function needOpts(extra = {}) {
 document.addEventListener('keydown', (ev) => {
   if (ev.key !== 'Enter' || !(ev.metaKey || ev.ctrlKey) || ev.altKey || ev.shiftKey) return
   const box = ev.target && ev.target.closest && ev.target.closest('[data-submit]')
-  const need = box && box.closest('.need')
+  const need = box && (box.closest('.need') || box.closest('.live-box')) // 0.9.8: the Live box too
   if (!need) return
   ev.preventDefault()
   if (ev.repeat || ev.isComposing) return
@@ -1201,8 +1266,8 @@ async function viewAgentSession(s) {
   const name = esc(a.display || a.name)
   const hint = typeof a.replyHint === 'string' && a.replyHint.trim() ? a.replyHint.trim() : ''
   let html = '<a class="back" href="#/">← All sessions</a>'
-  html += '<div class="pagehead"><div><h1>' + esc(s.title || 'Untitled') + '</h1><div class="sub">' + pill(s.status) + ' ' + spaceChip(s, { force: true }) + where(s) + ' <span class="faint">' + esc(s.inFeed === false ? 'no longer in the feed' : AGENT_STATUS[s.feedStatus] || s.feedStatus) + ' · updated ' + esc(ago(s.lastActivityAt)) + '</span></div></div>' +
-    '<div class="actions">' + agentReplyButton(a) + '</div></div>'
+  html += '<div class="pagehead s-head"><div class="s-head-main"><h1>' + esc(s.title || 'Untitled') + '</h1><div class="sub">' + pill(s.status) + ' ' + spaceChip(s, { force: true }) + where(s) + ' <span class="faint">' + esc(s.inFeed === false ? 'no longer in the feed' : AGENT_STATUS[s.feedStatus] || s.feedStatus) + ' · updated ' + esc(ago(s.lastActivityAt)) + '</span></div></div>' +
+    '<div class="actions s-actions">' + agentReplyButton(a) + '</div></div>'
   // v0.5.6: agent.url only links the name; the reply affordance and its
   // words come from the feed (agent.reply, agent.replyHint), or nothing.
   html += '<div class="banner info"><span>Read-only. This is ' + (home ? '<a href="' + esc(home) + '" target="_blank" rel="noopener noreferrer">' + name + '</a>' : name) + '’s work, from its feed' + (a.pullsHere ? ', pulled by this Mac' : a.puller ? ', pulled by ' + esc(a.puller) : '') + (a.lastSuccessAt ? ' (last pull ' + esc(ago(a.lastSuccessAt)) + ')' : '') + '.' + (hint ? ' ' + esc(hint.charAt(0).toUpperCase() + hint.slice(1)) + (/[.!?]$/.test(hint) ? '' : '.') : '') + '</span></div>'
@@ -1223,39 +1288,110 @@ async function viewAgentSession(s) {
   $app.innerHTML = banners() + html
 }
 
+// 0.9.8: another Mac's session whose Mac is offline says so plainly, once, near the top
+function ownerOffline(s) {
+  if (!s || s.isLocal !== false || s.agent || !s.machine) return false
+  const st = window.leftoffRelay && state.relayStatus
+  const x = st && (st.macs || []).find((y) => y.machine === s.machine)
+  if (x) return !x.online
+  return !!(s.peer && s.peer.code === 'unreachable')
+}
+function ownerOfflineNote(s) {
+  if (!ownerOffline(s)) return ''
+  const m = esc(s.machine), sn = staleNote(s.machine)
+  return '<p class="owner-off" role="status">' + icon('wifi-off') + '<span>This session lives on <b>' + m + '</b>, which is offline right now. You’re seeing what it last synced' + (sn ? ' (' + esc(sn) + ')' : '') + '. Live, its transcript and Find lists come back when ' + m + ' is.</span></p>'
+}
+// 0.9.8: opening a session is instant. The tap paints the page's shell at
+// once (title and pills from the card we already have, or the whole page from
+// the last visit), then every fetch runs in parallel (the session, its Live
+// thread, spaces, projects, lists) instead of one after another; on a phone
+// through the relay each was a full round trip. A newer navigation wins: a
+// slow answer for a page you already left never paints over the one you're on.
+const sessionCache = new Map() // id -> { s, live, lists, spv }, the last few sessions you opened
+const SESSION_CACHE_MAX = 8
+function cacheSession(id, v) { sessionCache.delete(id); sessionCache.set(id, v); while (sessionCache.size > SESSION_CACHE_MAX) sessionCache.delete(sessionCache.keys().next().value) }
+const onSession = (id) => { const r = parseRoute(); return r.name === 's' && r.arg === id }
+function sessionShellHtml(s) {
+  const head = s
+    ? '<h1>' + titleHtml(sessionTitle(s), esc) + '</h1><div class="sub">' + statusPill(s) + liveBadge(s) + '</div>'
+    : '<h1 class="skel-line skel-title" aria-label="Loading"></h1>'
+  return '<a class="back" href="#/">← All sessions</a><div class="pagehead s-head s-shell" data-sid="' + esc((s && s.id) || '') + '"><div class="s-head-main">' + head + '</div></div>' +
+    '<div class="s-skel" role="status" aria-live="polite" aria-busy="true"><div class="s-skel-note"><span class="lv-spin" aria-hidden="true"></span>Opening…</div>' +
+    '<div class="skel-line"></div><div class="skel-line short"></div><div class="skel-block"></div><div class="skel-line"></div><div class="skel-line short"></div></div>'
+}
+function paintSession(s, data) {
+  if (data.live && !data.live.error) liveUi.sig[s.id] = liveSignature(data.live.messages)
+  liveKeeper.before($app)
+  $app.innerHTML = sessionPageHtml(s, data)
+  liveAfterRender(s.id)
+  aroundWire(s.id)
+}
 async function viewSession(id) {
   if (String(id).startsWith('agent:')) return viewAgentSession(await api('GET', '/v1/sessions/' + encodeURIComponent(id)))
-  const s = await api('GET', '/v1/sessions/' + encodeURIComponent(id))
+  const showing = $app.querySelector('.s-head[data-sid="' + CSS.escape(id) + '"]') // a re-render of the page you're on: no shell
+  const cached = sessionCache.get(id)
+  const known = (cached && cached.s) || state.sessions.find((x) => x.id === id) || null
+  if (!showing) {
+    if (cached) paintSession(cached.s, cached) // the last visit, at once; fresh data replaces it below
+    else { liveKeeper.before($app); $app.innerHTML = sessionShellHtml(known) }
+  }
+  // on leftoff.dev, another Mac's session loads its data from that Mac: say so before the first call
+  const owner = (x) => { if (x && window.leftoffRelay && window.leftoffRelay.owner) window.leftoffRelay.owner(x.id, x.isLocal === false && !x.agent ? x.machine : null) }
+  owner(known)
+  const pS = api('GET', '/v1/sessions/' + encodeURIComponent(id))
+  const pLive = !known || liveWanted(known) ? fetchLive(id) : null // the thread doesn't wait for the session
+  const pLists = known && known.lists && known.lists.length ? fetchLists(id) : null
+  const pRest = Promise.all([api('GET', '/v1/spaces').catch(() => null), loadProjects()])
+  let s
+  try { s = await pS } catch (e) { if (!onSession(id)) return; throw e }
   state.sessions = state.sessions.filter((x) => x.id !== s.id).concat([s])
+  owner(s)
+  const status = s.isLocal === false && window.leftoffRelay ? window.leftoffRelay.status().then((st) => { state.relayStatus = st }).catch(() => {}) : null
+  const lists = s.lists && s.lists.length ? (pLists || fetchLists(id)) : null
+  const live = liveWanted(s) ? (pLive || fetchLive(id)) : !isLive(s) && !s.endedAt && s.live !== 'closed' ? liveHow().then(() => null) : null
+  let [[spv], v, sl] = await Promise.all([pRest, live, lists, status])
+  if (!onSession(id)) return // you moved on while this loaded
+  // a Live fetch that failed keeps the thread you had (its bubbles say "Reconnecting…"), not an empty one
+  const prev = sessionCache.get(id)
+  if (v && v.error && prev && prev.live && !prev.live.error) v = { ...prev.live, error: null }
+  const data = { spv, live: v, lists: sl }
+  if (v && !v.error) cacheSession(id, { s, ...data, live: v })
+  paintSession(s, data)
+}
+const fetchLists = (id) => api('GET', '/v1/sessions/' + encodeURIComponent(id) + '/lists').catch(() => null)
+function sessionPageHtml(s, { spv = null, live: liveV = null, lists = null } = {}) {
   const branch = s.repo && s.repo.branch
-  const [spv] = await Promise.all([api('GET', '/v1/spaces').catch(() => null), loadProjects()])
   let html = '<a class="back" href="#/">← All sessions</a>'
   // 0.8.9: rename in place: tap the title or the pencil (this Mac's sessions; like /cp-name, your name wins over automatic ones)
   const canRename = reachOf(s) === 'local' || reachOf(s) === 'peer' // 0.9.2: another Mac's session renames through it
-  html += '<div class="pagehead"><div>' + (canRename
-    ? '<div class="title s-title" data-id="' + esc(s.id) + '"><h1><span class="s-title-text" role="button" tabindex="0" data-action="rename" data-id="' + esc(s.id) + '" data-title="' + esc(s.title || '') + '" title="Rename">' + esc(s.title || 'Untitled session') + '</span></h1><button type="button" class="icon rename-pen" data-action="rename" data-id="' + esc(s.id) + '" data-title="' + esc(s.title || '') + '" aria-label="Rename" title="Rename">' + icon('pencil') + '</button></div>'
-    : '<h1>' + esc(s.title || 'Untitled session') + '</h1>') + '<div class="sub">' + pill(s.status) + ' ' + spaceChip(s, { force: true }) + projChip(s) + wtChips(s) + (canProject(s) ? '<button type="button" class="chip proj-add" data-action="project-menu" data-key="' + esc(s.repoKey) + '" data-repo="' + esc(s.repoLabel || s.repoName || '') + '" title="' + esc(s.repoProject ? 'Move ' + (s.repoLabel || 'this repo') + ' to another project, or out of it' : 'Add ' + (s.repoLabel || 'this repo') + ' to a project') + '">' + (s.repoProject ? 'Change project' : '+ Project') + '</button>' : '') + ' &nbsp;' + esc(s.titleSource ? s.titleSource + ' title' : '') + '</div></div>' +
-    '<div class="actions">' + goButton(s) + (s.status === 'ended' || s.live === 'closed' ? resumeButton(s, s.viewer || { local: state.viewerLocal !== false, ghostty: !!state.ghostty }) : '') + '<a class="btn" href="#/timeline?session=' + encodeURIComponent(s.id) + '">' + icon('history') + 'Open in Timeline</a><button type="button" class="btn" data-action="resume" data-id="' + esc(s.id) + '">Copy resume</button>' + (reachOf(s) === 'local' || reachOf(s) === 'peer' ? checkpointSplit(s) : reachOf(s) === 'away' ? '<span class="more-wrap">' + moreMenu(s, awayMenuItems(s), { project: false, title: s.title || 'This session' }) + '</span>' : '') + '</div></div>'
+  html += '<div class="pagehead s-head" data-sid="' + esc(s.id) + '"><div class="s-head-main">' + (canRename
+    ? '<div class="title s-title" data-id="' + esc(s.id) + '"><h1><span class="s-title-text" role="button" tabindex="0" data-action="rename" data-id="' + esc(s.id) + '" data-title="' + esc(s.title || '') + '" title="Rename">' + titleHtml(sessionTitle(s), esc) + '</span></h1><button type="button" class="icon rename-pen" data-action="rename" data-id="' + esc(s.id) + '" data-title="' + esc(s.title || '') + '" aria-label="Rename" title="Rename">' + icon('pencil') + '</button></div>'
+    : '<h1>' + titleHtml(sessionTitle(s), esc) + '</h1>') + '<div class="sub">' + statusPill(s) + liveBadge(s) + ' ' + spaceChip(s, { force: true }) + projChip(s) + wtChips(s) + (canProject(s) ? '<button type="button" class="chip proj-add" data-action="project-menu" data-key="' + esc(s.repoKey) + '" data-repo="' + esc(s.repoLabel || s.repoName || '') + '" title="' + esc(s.repoProject ? 'Move ' + (s.repoLabel || 'this repo') + ' to another project, or out of it' : 'Add ' + (s.repoLabel || 'this repo') + ' to a project') + '">' + (s.repoProject ? 'Change project' : '+ Project') + '</button>' : '') + ' &nbsp;' + esc(s.titleSource ? (s.titleSource === 'prompt' ? 'named from the first prompt' : s.titleSource + ' title') : '') + '</div></div>' +
+    // 0.9.8: one line each, 44px, an icon and a short label; the group drops under the title as a whole when it doesn't fit beside it
+    '<div class="actions s-actions">' + goButton(s, { page: true }) + (s.status === 'ended' || s.live === 'closed' ? resumeButton(s, s.viewer || { local: state.viewerLocal !== false, ghostty: !!state.ghostty }) : '') + '<a class="btn" href="#/timeline?session=' + encodeURIComponent(s.id) + '" title="Open in Timeline" aria-label="Open in Timeline">' + icon('history') + 'Timeline</a><button type="button" class="btn" data-action="resume" data-id="' + esc(s.id) + '" title="' + esc(resumeTip(s, 'Copy resume command')) + '">' + icon('copy') + 'Copy resume</button>' + (reachOf(s) === 'local' || reachOf(s) === 'peer' ? checkpointSplit(s) : reachOf(s) === 'away' ? '<span class="more-wrap">' + moreMenu(s, awayMenuItems(s), { project: false, title: s.title || 'This session' }) + '</span>' : '') + '</div></div>'
+  html += ownerOfflineNote(s) // 0.9.8: before the facts, where it's seen
   html += '<div class="facts">' +
     fact('Machine', mEmoji(s.machine) + ' ' + s.machine + (thisOneSuffix(s.machine, state.health) || (s.isLocal ? '' : ' (synced)'))) + fact('Repo', (s.repoName || '—') + (branch ? ' · ' + branch : '')) + (s.repoProject ? fact('Project', projectLabel(s.repoProject)) : '') + (s.worktree ? fact('Worktree', '⑂ ' + s.worktree.name + (s.worktree.branch ? ' · ' + s.worktree.branch : ''), 'wrap') : '') + (s.startedIn ? fact('Started in', s.startedIn) : '') + fact('Directory', s.cwd || '—') + fact('Last activity', ago(s.lastActivityAt)) + fact('Started', clock(s.startedAt)) +
     fact('Turns', s.turns + ' (' + s.turnsSinceCheckpoint + ' since checkpoint)' + (s.historyTurns ? ' · resumed, ' + s.historyTurns + ' before' : '')) + fact('Capture', s.capture || '—') + fact('Model', s.modelLabel || s.model || '—', 'wrap') + fact('Session id', s.id) +
     fact('Open?', s.live === 'open' ? 'open' + (s.liveVia === 'pid' ? ' (process ' + s.pid + ' running)' : ' (heartbeat)') : s.live === 'closed' ? 'closed ' + ago(s.closedAt) : 'unknown') +
     fact('Terminal', (s.terminal ? s.terminal.label : s.codingAgent === 'codex' ? ({ 'codex-ide': 'Codex in the IDE', 'codex-app': 'Codex app', 'codex-exec': 'codex exec' }[s.surface] || 'Codex CLI') : '—') + (s.tty ? ' · ' + s.tty.replace('/dev/', '') : '') + ' · tab cp:' + (s.shortId || '')) + '</div>'
+  if (isLive(s)) html += (s.needsYou ? sessionNeedsStrip(s) : '') + liveBoxHtml(s, liveV)
   html += parkRow(s)
   html += spacePicker(s, spv, 'session', s.id)
   html += '<section class="sprs" id="prs">' + sessionPrsSection(s, { mayEdit: !s.agent }) + '</section>'
   // 0.7.0: steps handed back to you, and the docs, plans and artifacts it made
   html += '<section class="stodos" id="todos">' + sessionTodosSection(s, { agoFn: ago, mayEdit: state.mayAnswer !== false }) + '</section>'
   html += '<section class="sfiles" id="files">' + sessionFilesSection(s, { agoFn: ago }) + '</section>'
-  if (s.needsYou) html += '<section class="needs-strip one" aria-label="Needs you"><div class="needs-head"><h2>Needs you</h2></div><div class="needs-list">' + needPanel({ ...s.needsYou, session: s }, needOpts({ compact: true })) + '</div></section>'
+  // 0.9.8: a live-linked session keeps its permission card and the prompt box together, near the top
+  if (s.needsYou && !isLive(s)) html += sessionNeedsStrip(s)
+  if (!isLive(s)) html += liveBoxHtml(s, liveV)
   if (s.statusChanges && s.statusChanges.length) {
     html += '<div class="striplabel">Status history</div><div class="strip">' + s.statusChanges.slice(-24).map((c) => '<span class="s-' + esc(c.status) + '" title="' + esc(clock(c.at)) + '">' + esc(LABEL[c.status] || c.status) + '</span>').join('') + '</div>'
   }
   // Lists (v0.5.1): its saved lists in full, the hint, and Find lists in this session
   if (s.lists && s.lists.length) {
-    const sl = await api('GET', '/v1/sessions/' + encodeURIComponent(s.id) + '/lists').catch(() => null)
     state.listFull = {}
-    for (const l of (sl && sl.lists) || []) state.listFull[l.ref] = l
+    for (const l of (lists && lists.lists) || []) state.listFull[l.ref] = l
   }
   state.listsMayEdit = state.mayAnswer !== false
   html += '<section class="slists" id="lists">' + sessionListsSection(s) + '</section>'
@@ -1273,9 +1409,257 @@ async function viewSession(id) {
   const empties = s.checkpoints.filter((cp) => cp.doubt === 'empty') // 0.9.2
   if (empties.length) html += '<details class="tl-doubt"><summary>' + empties.length + ' empty checkpoint' + (empties.length === 1 ? '' : 's') + ' set aside: no messages were found when ' + (empties.length === 1 ? 'it was' : 'they were') + ' written</summary><div class="timeline">' + cpTimeline(empties, null) + '</div></details>'
   html += answeredList(s)
-  $app.innerHTML = html
-  aroundWire(s.id)
+  return html
+}
+// ------------------------------------------------------------ Live link (0.9.8 beta)
+
+const isLive = (s) => !!(s && s.liveLink && s.liveLink.on)
+function sessionNeedsStrip(s) { return '<section class="needs-strip one" aria-label="Needs you"><div class="needs-head"><h2>Needs you</h2></div><div class="needs-list">' + needPanel({ ...s.needsYou, session: s }, needOpts({ compact: true })) + '</div></section>' }
+// 0.9.8 polish: the thread is ui/live-view.js (entries, status, sticking to the
+// bottom); Claude's answer is the session's own (markdown, like the terminal).
+const liveKeeper = createLiveKeeper()
+const liveSeenKey = (id) => 'lo-live-seen:' + id
+function liveSeen(id) { try { return localStorage.getItem(liveSeenKey(id)) } catch { return null } }
+function markLiveSeen(id, at) { try { localStorage.setItem(liveSeenKey(id), at || new Date().toISOString()) } catch {} }
+// "Chat" on a live card: straight to the Live box (#/s/<id>/live), with a dot when Claude replied since you last looked.
+function chatButton(s) {
+  if (!cardPills(s).live || s.agent) return ''
+  const unread = hasUnread(s.liveLink && s.liveLink.lastReplyAt, liveSeen(s.id))
+  return '<a class="btn chat-btn" href="' + esc(liveHref(s.id)) + '" aria-label="' + esc('Chat with this session' + (unread ? ' (new reply)' : '')) + '">Chat' + (unread ? '<span class="unread-dot" aria-hidden="true"></span>' : '') + '</a>'
+}
+// The how-to for a session that isn't live (fetched once: the claude line has this Mac's path).
+async function liveHow() {
+  if (state.liveHow === undefined) { try { state.liveHow = await api('GET', '/v1/live') } catch { state.liveHow = null } }
+  return state.liveHow
+}
+// Does this session's page show a Live thread (and so fetch one)?
+const liveWanted = (s) => !!(s && isLive(s) && !s.agent && s.codingAgent !== 'codex' && s.capture !== 'hooks')
+// GET the Live thread; what it says is the newest the page knows (0.9.8: the
+// time of the last good answer decides "Reconnecting…" on a pending bubble).
+async function fetchLive(id, { timeoutMs } = {}) {
+  const turns = (state.liveTurns && state.liveTurns[id]) || 20 // "Show earlier" adds 20 at a time
+  try {
+    const v = await api('GET', '/v1/sessions/' + encodeURIComponent(id) + '/live' + (turns > 20 ? '?turns=' + turns : ''), null, timeoutMs ? { timeoutMs } : {})
+    noteLive(id, v)
+    return v
+  } catch (e) { return { messages: [], error: e.message } }
+}
+function liveBoxHtml(s, v) {
+  if (s.agent || s.codingAgent === 'codex' || s.capture === 'hooks') return ''
+  if (!isLive(s)) {
+    if (s.endedAt || s.live === 'closed') return ''
+    const how = state.liveHow
+    return '<section class="live-box off" aria-label="Live link"><div class="live-head"><h2>Live <span class="pill soon">Beta</span></h2></div>' +
+      '<p class="faint">To send this session messages from here or your phone, and answer its permission prompts, start it with <code>leftoff live</code>' +
+      (how && how.line ? ' (or <code>' + esc(how.line) + '</code>)' : '') + '. Claude Code asks once to load the channel; channels are a research preview.</p></section>'
+  }
+  const msgs = (v && v.messages) || []
+  const may = state.mayAnswer !== false
+  const draft = (state.drafts && state.drafts['live:' + s.id]) || ''
+  const now = Date.now()
+  const lastClaude = [...msgs].reverse().find((m) => m.from === 'claude')
+  if (lastClaude) markLiveSeen(s.id, lastClaude.at)
+  return '<section class="live-box" id="live" aria-label="Live link" data-id="' + esc(s.id) + '"><div class="live-head"><h2>Live</h2><span class="faint">Goes straight into this session' + (s.isLocal === false ? ' on ' + esc(s.machine) : '') + '. Claude reads it as its next prompt.</span></div>' +
+    '<div class="live-thread" data-sid="' + esc(s.id) + '"><ol class="live-log" aria-live="polite" aria-label="Messages with this session">' +
+      earlierHtml((v && v.earlier) || 0, { esc }) + threadHtml(msgs, { esc, ago, md: renderDoc, now }) + '</ol>' +
+      '<p class="faint live-empty"' + (msgs.length ? ' hidden' : '') + '>Nothing sent yet. Claude answers here and in the terminal.</p>' +
+      '<button type="button" class="live-jump" data-action="live-jump" hidden>Jump to latest ↓<span class="live-jump-n"></span></button></div>' +
+    (v && v.error ? '<p class="live-err">' + esc(v.error) + '</p>' : '') +
+    '<div class="reply-row live-row"><textarea class="reply-text live-text" rows="2" maxlength="4000" placeholder="Message this session…" aria-label="Message this session" data-draft="live:' + esc(s.id) + '" data-submit="live" aria-keyshortcuts="' + (/Mac|iPhone|iPad/.test(navigator.platform || navigator.userAgent) ? 'Meta+Enter' : 'Control+Enter') + '"' + (may ? '' : ' disabled') + '>' + esc(draft) + '</textarea>' +
+    '<button type="button" class="btn primary" data-action="live-send" data-submit-for="live" data-id="' + esc(s.id) + '"' + (may ? '' : ' aria-disabled="true"') + '>Send</button></div>' +
+    (may ? '' : '<p class="faint">Sending from another device is off. On a Mac, turn on Settings → Privacy &amp; security → Trust my paired devices.</p>') + '</section>'
+}
+// After the session page is drawn: keep the thread (scroll, diffed entries), show "Jump to latest".
+function liveAfterRender(sid) {
+  const r = liveKeeper.after($app)
+  if (!r) return
+  const ol = r.thread.querySelector('.live-log')
+  const empty = r.thread.querySelector('.live-empty')
+  if (empty && ol) empty.hidden = ol.children.length > 0
+  liveJumpButton(r.thread, liveKeeper.unseen)
+  if (ol && !ol.dataset.wired) {
+    ol.dataset.wired = '1'
+    ol._stick = atBottom(ol)
+    // the button follows the scroll: there whenever you're away from the bottom, gone once you're back
+    ol.addEventListener('scroll', () => { ol._stick = atBottom(ol); liveJumpButton(r.thread, liveKeeper.unseen) }, { passive: true })
+    // at the bottom, the thread stays there while an entry grows (a streamed reply, a code block, late fonts)
+    if (typeof ResizeObserver === 'function') {
+      ol._ro = new ResizeObserver(() => { if (ol._stick && !atBottom(ol, 2)) ol.scrollTop = ol.scrollHeight; liveJumpButton(r.thread, liveKeeper.unseen) })
+    }
+  }
+  if (ol && ol._ro) { ol._ro.disconnect(); ol._ro.observe(ol); for (const li of ol.children) ol._ro.observe(li) }
+  if (ol && r.follow) ol._stick = true
+  // #/s/<id>/live: scroll to the box once, and ready the input on a Mac (no keyboard popping up on a phone)
+  const want = parseLiveRoute(location.hash)
+  if (want === sid && state.liveFocused !== location.hash + '|' + sid) {
+    state.liveFocused = location.hash + '|' + sid
+    const box = document.getElementById('live')
+    if (box) box.scrollIntoView({ block: 'start', behavior: 'auto' })
+    if (ol) ol.scrollTop = ol.scrollHeight
+    const ta = box && box.querySelector('.live-text')
+    if (ta && !ta.disabled && !(window.matchMedia && window.matchMedia('(pointer: coarse)').matches)) ta.focus({ preventScroll: true })
+  }
+  liveTick()
+}
+// "Jump to latest ↓" shows whenever the thread is scrolled away from its bottom (with the
+// count of what came in since, when there is any), and hides once you're back at the bottom.
+function liveJumpButton(thread, n) {
+  const b = thread && thread.querySelector('.live-jump')
+  if (!b) return
+  const ol = thread.querySelector('.live-log')
+  const v = jumpView(ol, n)
+  if (!v.show && n > 0) liveKeeper.seen()
+  // on its way down after a tap: don't flash back up mid-scroll
+  if (v.show && thread.dataset.jumping && Date.now() < Number(thread.dataset.jumping)) return
+  b.hidden = !v.show
+  const c = b.querySelector('.live-jump-n')
+  if (c) c.textContent = v.count
+  b.setAttribute('aria-label', v.label)
+}
+function liveJumpClick(btn) {
+  const thread = btn.closest('.live-thread')
+  const ol = thread && thread.querySelector('.live-log')
+  const smooth = !(window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches)
+  if (thread) thread.dataset.jumping = String(Date.now() + (smooth ? 900 : 0))
+  if (ol) ol.scrollTo({ top: ol.scrollHeight, behavior: smooth ? 'smooth' : 'auto' })
+  liveKeeper.seen()
+  btn.hidden = true
+  const c = btn.querySelector('.live-jump-n'); if (c) c.textContent = ''
+  // land exactly at the bottom even if something grew mid-scroll, then the button follows the scroll again
+  setTimeout(() => { if (!thread || !thread.isConnected) return; delete thread.dataset.jumping; if (ol && !atBottom(ol, 4)) ol.scrollTop = ol.scrollHeight; liveJumpButton(thread, liveKeeper.unseen) }, smooth ? 950 : 0)
+}
+// "Show earlier": 20 more turns, the view stays on what you were reading (the keeper anchors it).
+async function liveEarlierClick(btn) {
+  const box = btn.closest('.live-box')
+  const sid = box && box.dataset.id
+  if (!sid) return
+  state.liveTurns = state.liveTurns || {}
+  state.liveTurns[sid] = ((state.liveTurns[sid]) || 20) + 20
+  btn.setAttribute('aria-busy', 'true'); btn.textContent = 'Loading…'
+  await render()
+}
+// The elapsed time beside "Claude is working…", every second while something is in flight.
+// 0.9.8: when what the page shows is older than STALE_MS (the stream died, the
+// phone slept), a running bubble says "Reconnecting…" instead of a timer.
+let liveTimer = null
+function liveTick() {
+  const els = [...document.querySelectorAll('.lv-status[data-since]')]
+  const box = document.querySelector('#live[data-id]')
+  const stale = !!box && isStale(liveUi.okAt[box.dataset.id], Date.now())
+  for (const el of els) {
+    const since = Number(el.dataset.since) || 0
+    const end = Number(el.dataset.final) || 0
+    const t = el.querySelector('.lvs-time')
+    if (t && since) t.textContent = elapsedText((end || Date.now()) - since)
+    if (!end) {
+      el.classList.toggle('lv-reconnecting', stale)
+      let hint = el.querySelector('.lvs-hint')
+      if (stale && !hint) { hint = document.createElement('span'); hint.className = 'lvs-hint'; hint.textContent = 'Reconnecting…'; (el.querySelector('.lvs-line') || el).append(hint) }
+      if (hint) hint.hidden = !stale
+    }
+  }
+  const running = els.some((el) => !el.dataset.final)
+  if (running && !liveTimer) liveTimer = setInterval(() => { if (!document.querySelector('.lv-status[data-since]:not([data-final])')) { clearInterval(liveTimer); liveTimer = null } liveTick() }, 1000)
+}
+
+// 0.9.8: Live keeps up after the phone sleeps (ui/live-wake.js). Every Live
+// fetch notes when it answered and whether a message is still going; while
+// one is, on a visible page, the thread is fetched again every POLL_MS
+// whatever the event stream does.
+const liveUi = { okAt: {}, sig: {}, pending: {}, polling: false }
+function noteLive(id, v) {
+  if (!v || v.error) return
+  liveUi.okAt[id] = Date.now()
+  liveUi.pending[id] = anyPending(v.messages)
+}
+const liveOnScreen = () => { const r = state.route; const box = document.querySelector('#live[data-id]'); return r && r.name === 's' && box && box.dataset.id === r.arg ? r.arg : null }
+// Fetch the thread and diff it into the page, even while you type (busy()
+// holds full redraws back, never the thread). A turn that ended also redraws
+// the rest of the page (the pill stops pulsing) once you're not busy.
+async function refreshLive(reason) {
+  const id = liveOnScreen()
+  if (!id || liveUi.polling) return false
+  liveUi.polling = true; liveUi.triedAt = Date.now()
+  let v
+  try { v = await fetchLive(id, { timeoutMs: 8000 }) } finally { liveUi.polling = false }
+  if (!v || v.error || liveOnScreen() !== id) { liveTick(); return false }
+  const s = state.sessions.find((x) => x.id === id)
+  const sig = liveSignature(v.messages)
+  const before = liveUi.sig[id]
+  liveUi.sig[id] = sig
+  if (s && before !== sig) {
+    const box = document.querySelector('#live')
+    const cur = box && box.querySelector('.live-thread')
+    if (cur) {
+      const tmp = document.createElement('div')
+      tmp.innerHTML = liveBoxHtml(s, v)
+      const fresh = tmp.querySelector('.live-thread')
+      if (fresh) {
+        const next = cur.nextSibling
+        liveKeeper.before(box)
+        box.insertBefore(fresh, next)
+        const r = liveKeeper.after(box)
+        if (r) liveJumpButton(r.thread, liveKeeper.unseen)
+      }
+    }
+    const c = sessionCache.get(id); if (c) c.live = v
+    if (!liveUi.pending[id] && !busy()) soon() // settled: the pill, the tab, the card
+  }
+  liveTick()
+  return true
 }
+// The safety net, and the stream's watchdog, on one slow timer.
+const streamDog = createWatchdog()
+const wakeGate = createWake()
+setInterval(() => {
+  if (document.visibilityState === 'hidden') return
+  const id = liveOnScreen()
+  if (shouldPoll({ visible: true, onLive: !!id, pending: !!(id && liveUi.pending[id]) }) && Date.now() - Math.max(liveUi.okAt[id] || 0, liveUi.triedAt || 0) >= POLL_MS - 250) refreshLive('poll')
+  if (streamDog.check() === 'dead') { connect(); refreshView('stream') }
+}, 1000)
+// Coming back (iOS: the Home Screen app returns, the screen unlocks, a
+// bfcache restore, the network returns): fetch what's on screen at once, and
+// open a new stream if the old one missed its pings.
+function refreshView(reason) {
+  if (liveOnScreen()) refreshLive(reason)
+  if (!busy() && !(state.route && ['settings', 'setup'].includes(state.route.name))) render()
+  refreshHealth()
+}
+let awayAt = 0 // when the page went to the background (hidden, or the window lost focus)
+function onWake(ev) {
+  if (ev.type === 'blur' || (ev.type === 'visibilitychange' && document.visibilityState === 'hidden')) { awayAt = awayAt || Date.now(); return }
+  const why = wakeReason(ev.type, { visibilityState: document.visibilityState, persisted: !!ev.persisted })
+  if (!why) return
+  liveTick() // a stale timer turns into "Reconnecting…" before anything else
+  const dead = !stream || stream.readyState === 2 || streamDead(streamDog.lastAt, Date.now(), HEARTBEAT_MS + 2000)
+  const away = awayAt ? Date.now() - awayAt : 0
+  awayAt = 0
+  // a click back into the window a moment later isn't a wake-up; coming back after a while, a restore or the network is
+  if ((why === 'focus' || why === 'visible') && away < AWAY_MS && !dead) return
+  if (!wakeGate.due()) return
+  if (why === 'pageshow-bfcache' || dead) connect()
+  refreshView(why)
+}
+for (const t of ['pageshow', 'focus', 'blur', 'online']) window.addEventListener(t, onWake)
+document.addEventListener('visibilitychange', onWake)
+async function liveSendClick(btn) {
+  const box = btn.closest('.live-box')
+  const ta = box && box.querySelector('.live-text')
+  const text = ta ? ta.value.trim() : ''
+  if (!text) { toast('Type a message first'); return }
+  if (btn.getAttribute('aria-disabled') === 'true') return
+  btn.setAttribute('aria-disabled', 'true'); btn.textContent = 'Sending…'
+  try {
+    const r = await api('POST', '/v1/sessions/' + encodeURIComponent(btn.dataset.id) + '/live', { text })
+    if (state.drafts) delete state.drafts['live:' + btn.dataset.id]
+    if (ta) ta.value = ''
+    if (r.state === 'failed') toast('Didn’t arrive: ' + (r.error || 'the session isn’t listening'), 4200)
+    const ol = box && box.querySelector('.live-log')
+    if (ol) ol.scrollTop = ol.scrollHeight // your own message: always follow it
+    setTimeout(() => { if (state.route && state.route.name === 's') soon() }, 1500)
+  } catch (e) { toast(e.message, 4200) } finally { await render(); const nb = document.querySelector('.live-box [data-action="live-send"]'); if (nb) { nb.removeAttribute('aria-disabled'); nb.textContent = 'Send' } }
+}
+
 // ------------------------------------------------------------ search inside transcripts (0.9.6)
 
 // Plain text + [start, end] ranges -> escaped HTML with <mark>s (ranges that
@@ -2385,6 +2769,7 @@ async function viewSettings() {
     general: '<div class="section">Needs you</div>' +
       '<label for="f-notify">Notify me</label><label class="check"><input id="f-notify" type="checkbox"' + (c.notify && c.notify.needsYou === false ? '' : ' checked') + '><span>Show a notification when a prompt or question has waited ' + esc((c.notify && c.notify.delaySec != null) ? c.notify.delaySec : 10) + ' seconds</span></label>' +
       '<div class="hint">With <code>terminal-notifier</code>, a click jumps to the session.</div>' +
+      '<div class="full push-slot" data-push-slot hidden></div>' +
       '<div class="section">Appearance</div>' +
       '<label>Theme</label><div class="theme" role="group" aria-label="Theme">' + ['light', 'dark', 'system'].map((t) => '<button type="button" data-theme-set="' + t + '" aria-pressed="' + (pref === t) + '">' + THEME_ICONS[t] + (t === 'system' ? 'System' : t[0].toUpperCase() + t.slice(1)) + '</button>').join('') + '</div>' +
       advanced('general', '<label for="f-dormant">Dormant after (min)</label><input id="f-dormant" type="number" min="1" step="1" value="' + esc(c.dormantAfterMin) + '">' +
@@ -3146,7 +3531,8 @@ function parseRoute() {
 
 async function render() {
   const r = (state.route = parseRoute())
-  document.querySelectorAll('.tabs a, .topright a[data-route]').forEach((a) => { const on = a.dataset.route === (r.name === 's' ? 'board' : r.name === 'catchup' ? 'digest' : r.name); a.classList.toggle('on', on); if (on) a.setAttribute('aria-current', 'page'); else a.removeAttribute('aria-current') })
+  paintNav(r)
+  tabsOnRoute(r)
   try {
     if (r.name === 's' && r.arg) await viewSession(r.arg)
     else if (r.name === 'waiting') await viewWaiting()
@@ -3161,6 +3547,7 @@ async function render() {
     else if (r.name === 'search') await viewSearch(r.q || '')
     else if (r.name === 'setup') await viewSetup()
     else await viewBoard()
+    tabsAfterRender()
   } catch (e) {
     if (e.code === 'login_required') return showLogin()
     $app.innerHTML = '<div class="empty">Couldn’t load: ' + esc(e.message) + '</div>'
@@ -3233,6 +3620,7 @@ async function refreshHealth() {
     if (h.answering) state.mayAnswer = h.answering.allowedHere !== false
     const dot = document.querySelector('#wnTab .newdot')
     if (dot) dot.hidden = !(h.whatsNew && h.whatsNew.unseen > 0)
+    paintMoreDots()
     paintSettingsDots()
   } catch (e) {
     el.className = 'health down'
@@ -3263,6 +3651,475 @@ function paintTopDot() {
   el.className = 'topdot' + (warn ? ' warn' : '')
   const why = all.flatMap((x) => x.why)
   document.getElementById('setTab').title = 'Settings' + (why.length && !el.hidden ? ' · ' + why.join(' · ') : '')
+  paintMoreDots()
+}
+
+// ------------------------------------------------------------ the rail, the bottom bar and Quick look (0.9.8)
+// From 700px up the sections sit in a rail on the left; under it, in a bottom
+// bar with the rest under More. Hover the Needs you item (or long-press it on a
+// phone, or press ↓/→ on it) for Quick look: the count and the five longest
+// waits, with Allow / Deny on permission prompts (the Needs you page's own
+// buttons, so the same checks apply and nothing is answered without a click).
+const railMode = () => window.matchMedia('(min-width: 700px)').matches
+function paintNav(r = state.route || parseRoute()) {
+  const key = navKey(r.name)
+  document.querySelectorAll('.tabs a[data-route], .topright a[data-route], #moreMenu a[data-route]').forEach((a) => { const on = a.dataset.route === key; a.classList.toggle('on', on); if (on) a.setAttribute('aria-current', 'page'); else a.removeAttribute('aria-current') })
+  const more = document.getElementById('moreBtn')
+  if (more) more.classList.toggle('on', moreActive(key))
+}
+function paintMoreDots() {
+  const wn = document.querySelector('#wnTab .newdot'), st = document.querySelector('#setTab .topdot')
+  const mwn = document.querySelector('#moreMenu .newdot'), mst = document.querySelector('#moreMenu .topdot')
+  if (mwn && wn) mwn.hidden = wn.hidden
+  if (mst && st) { mst.hidden = st.hidden; mst.className = st.className }
+  const md = document.querySelector('#moreBtn .moredot')
+  if (md) { md.hidden = !((wn && !wn.hidden) || (st && !st.hidden)); md.className = 'moredot' + (st && !st.hidden && st.classList.contains('warn') ? ' warn' : '') }
+}
+
+// More (phones)
+const moreOpen = () => { const m = document.getElementById('moreMenu'); return !!m && !m.hidden }
+function closeMore(focusBtn = false) {
+  const m = document.getElementById('moreMenu'), b = document.getElementById('moreBtn')
+  if (!m || m.hidden) return
+  m.hidden = true
+  if (b) { b.setAttribute('aria-expanded', 'false'); if (focusBtn) b.focus() }
+}
+function openMore() {
+  const m = document.getElementById('moreMenu'), b = document.getElementById('moreBtn')
+  if (!m) return
+  closeQuickLook(); toggleStatus(false)
+  paintMoreDots()
+  paintPush()
+  m.hidden = false
+  if (b) b.setAttribute('aria-expanded', 'true')
+  const first = m.querySelector('a.on') || m.querySelector('a')
+  if (first) first.focus()
+}
+document.getElementById('moreBtn').addEventListener('click', () => (moreOpen() ? closeMore() : openMore()))
+document.getElementById('moreMenu').addEventListener('click', (e) => { if (e.target.closest('a')) closeMore() })
+document.getElementById('moreMenu').addEventListener('keydown', (e) => {
+  const items = [...document.querySelectorAll('#moreMenu a')]
+  const i = items.indexOf(document.activeElement)
+  if (e.key === 'Escape') { e.preventDefault(); closeMore(true) }
+  else if (e.key === 'ArrowDown' || e.key === 'ArrowUp') { e.preventDefault(); const n = items[(i + (e.key === 'ArrowDown' ? 1 : -1) + items.length) % items.length]; if (n) n.focus() }
+  else if (e.key === 'Tab') closeMore()
+})
+
+// Quick look
+const qlUi = { open: false, how: null, openT: 0, closeT: 0, suppressClick: false, model: null, seq: 0 }
+const quickLookOpen = () => qlUi.open
+function quickLookFocusables() { const p = document.getElementById('quickLook'); return p ? [...p.querySelectorAll('a[href], button:not([disabled])')] : [] }
+function paintQuickLook() {
+  const pop = document.getElementById('quickLook')
+  if (!pop || !qlUi.open) return
+  const had = pop.contains(document.activeElement) ? document.activeElement : null
+  const keep = had && (had.closest('.ql-item') ? { key: had.closest('.ql-item').dataset.key, choice: had.dataset.choice || '', main: had.classList.contains('ql-main') } : { foot: had.classList.contains('ql-foot') })
+  const model = qlUi.model || { total: Number((state.health || {}).needsYou) || 0, items: [], more: 0 }
+  pop.innerHTML = quickLookHtml(model, { mayAnswer: state.mayAnswer, pending: state.pendingAsk })
+  pop.setAttribute('aria-busy', qlUi.model ? 'false' : 'true')
+  placeQuickLook()
+  if (keep) {
+    let el = null
+    if (keep.key) { const row = [...pop.querySelectorAll('.ql-item')].find((x) => x.dataset.key === keep.key); if (row) el = keep.main ? row.querySelector('.ql-main') : row.querySelector('[data-choice="' + keep.choice + '"]:not([disabled])') }
+    else if (keep.foot) el = pop.querySelector('.ql-foot')
+    ;(el || quickLookFocusables()[0] || pop).focus()
+  }
+}
+function placeQuickLook() {
+  const pop = document.getElementById('quickLook'), tab = document.getElementById('needsTab')
+  if (!pop || pop.hidden || !tab) return
+  if (!railMode()) { pop.style.left = ''; pop.style.top = ''; return } // the CSS puts it above the bottom bar
+  const r = tab.getBoundingClientRect(), rail = document.querySelector('.top').getBoundingClientRect()
+  pop.style.left = (Math.max(r.right, rail.right) + 8) + 'px'
+  pop.style.top = Math.max(8, Math.min(r.top - 6, window.innerHeight - 8 - pop.offsetHeight)) + 'px'
+}
+// The sessions behind the popover: what the page already has, then a fresh read.
+async function loadQuickLook() {
+  const seq = ++qlUi.seq
+  if (state.sessions && state.sessions.length && !qlUi.model) { qlUi.model = quickLookItems(state.sessions); paintQuickLook() }
+  try {
+    const { sessions, viewer } = await api('GET', '/v1/sessions?limit=200', undefined, { timeoutMs: 8000 })
+    if (seq !== qlUi.seq) return
+    if (viewer) state.mayAnswer = viewer.mayAnswer !== false
+    qlUi.model = quickLookItems(sessions || [])
+  } catch { if (!qlUi.model) qlUi.model = { total: 0, items: [], more: 0, failed: true } }
+  paintQuickLook()
+}
+function openQuickLook(how = 'hover') {
+  const pop = document.getElementById('quickLook'), tab = document.getElementById('needsTab')
+  if (!pop || !tab) return
+  clearTimeout(qlUi.openT); clearTimeout(qlUi.closeT)
+  if (qlUi.open) { if (how !== 'hover') { qlUi.how = how; const f = quickLookFocusables()[0]; if (f) f.focus() } return }
+  closeMore(); toggleStatus(false)
+  qlUi.open = true; qlUi.how = how; qlUi.model = null
+  pop.hidden = false
+  tab.setAttribute('aria-expanded', 'true')
+  // Hover never takes focus; the keyboard and a long-press move into the card (and Tab stays inside it).
+  pop.setAttribute('aria-modal', how === 'hover' ? 'false' : 'true')
+  paintQuickLook()
+  if (how !== 'hover') { const f = quickLookFocusables()[0]; (f || pop).focus() }
+  loadQuickLook()
+}
+function closeQuickLook(focusTab = false) {
+  clearTimeout(qlUi.openT); clearTimeout(qlUi.closeT)
+  if (!qlUi.open) return
+  const pop = document.getElementById('quickLook'), tab = document.getElementById('needsTab')
+  const inside = pop && pop.contains(document.activeElement)
+  qlUi.open = false; qlUi.seq++
+  if (pop) { pop.hidden = true; pop.innerHTML = '' }
+  if (tab) { tab.setAttribute('aria-expanded', 'false'); if (focusTab || inside) tab.focus() }
+}
+{
+  const tab = document.getElementById('needsTab'), pop = document.getElementById('quickLook')
+  const canHover = () => window.matchMedia('(hover: hover) and (pointer: fine)').matches
+  const later = (fn, ms) => { clearTimeout(qlUi.closeT); clearTimeout(qlUi.openT); return setTimeout(fn, ms) }
+  tab.addEventListener('mouseenter', () => { if (!canHover()) return; clearTimeout(qlUi.closeT); if (!qlUi.open) qlUi.openT = later(() => openQuickLook('hover'), 280) })
+  tab.addEventListener('mouseleave', () => { clearTimeout(qlUi.openT); if (qlUi.open && qlUi.how === 'hover') qlUi.closeT = setTimeout(() => closeQuickLook(), 320) })
+  pop.addEventListener('mouseenter', () => clearTimeout(qlUi.closeT))
+  pop.addEventListener('mouseleave', () => { if (qlUi.open && qlUi.how === 'hover' && !pop.contains(document.activeElement)) qlUi.closeT = setTimeout(() => closeQuickLook(), 320) })
+  // Long-press on a touch screen; the tap that ends it doesn't navigate.
+  let lp = null
+  tab.addEventListener('pointerdown', (e) => {
+    if (e.pointerType === 'mouse') return
+    const x = e.clientX, y = e.clientY
+    clearTimeout(lp && lp.t)
+    lp = { x, y, t: setTimeout(() => { qlUi.suppressClick = true; openQuickLook('touch'); if (navigator.vibrate) try { navigator.vibrate(10) } catch {} }, 450) }
+  })
+  const cancel = () => { if (lp) { clearTimeout(lp.t); lp = null } }
+  tab.addEventListener('pointerup', cancel)
+  tab.addEventListener('pointercancel', cancel)
+  tab.addEventListener('pointermove', (e) => { if (lp && Math.hypot(e.clientX - lp.x, e.clientY - lp.y) > 10) cancel() })
+  tab.addEventListener('contextmenu', (e) => { if (qlUi.open || lp) e.preventDefault() })
+  tab.addEventListener('click', (e) => {
+    if (qlUi.suppressClick) { qlUi.suppressClick = false; e.preventDefault(); return }
+    // A second tap while it's open goes to the page, as the footer does.
+    closeQuickLook()
+  })
+  tab.addEventListener('keydown', (e) => {
+    if (['ArrowDown', 'ArrowRight', 'ArrowUp'].includes(e.key) && !e.altKey && !e.metaKey && !e.ctrlKey) { e.preventDefault(); openQuickLook('keyboard') }
+  })
+  pop.addEventListener('keydown', (e) => {
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); closeQuickLook(true); return }
+    if (e.key !== 'Tab') return
+    const f = quickLookFocusables()
+    if (!f.length) { e.preventDefault(); return }
+    const i = f.indexOf(document.activeElement)
+    if (e.shiftKey && i <= 0) { e.preventDefault(); f[f.length - 1].focus() }
+    else if (!e.shiftKey && (i === -1 || i === f.length - 1)) { e.preventDefault(); f[0].focus() }
+  })
+  pop.addEventListener('focusin', () => { clearTimeout(qlUi.closeT); pop.setAttribute('aria-modal', 'true') })
+  pop.addEventListener('click', (e) => { const a = e.target.closest('a[href]'); if (a) closeQuickLook() })
+  document.addEventListener('keydown', (e) => { if (e.key === 'Escape' && qlUi.open) closeQuickLook(true) })
+  document.addEventListener('pointerdown', (e) => {
+    if (qlUi.open && !e.target.closest('#quickLook, #needsTab')) closeQuickLook()
+    if (moreOpen() && !e.target.closest('#moreMenu, #moreBtn')) closeMore()
+  }, true)
+  window.addEventListener('hashchange', () => { closeQuickLook(); closeMore() })
+  window.addEventListener('resize', () => { placeQuickLook(); if (statusOpen()) placeStatus() })
+}
+
+// ------------------------------------------------------------ tabs for sessions (0.9.8, ui/tabs.js)
+// The board is the first tab; a session opens as the one preview tab (italic)
+// that the next click replaces, and stays open once you send a Live message,
+// type there, choose Keep open or double-click its tab (⌘/Ctrl-click or a
+// middle-click opens it permanent straight away). Kept per device in
+// localStorage. By width: under 700px the Open row on the board and ‹ N of M ›
+// (or a swipe) on a session page; from 700px the strip. A width change (fold,
+// Split View, rotation) only changes the CSS: the open set, the session and
+// where you were on the page stay.
+const tabsUi = { m: parseStored(localStorage.getItem(TABS_KEY)), active: null, route: null, permanent: null, html: { strip: '', row: '', pager: '' }, anchor: null, logs: new WeakMap(), quietUntil: 0, fetchT: 0, fetchedAt: 0, scrolls: {} }
+window.leftoffTabs = { model: () => JSON.parse(serialize(tabsUi.m)) } // read by test:tabs-ui
+function setTabs(m) {
+  if (m === tabsUi.m) return
+  tabsUi.m = m
+  try { localStorage.setItem(TABS_KEY, serialize(m)) } catch {}
+}
+const tabSession = (id) => state.sessions.find((s) => s.id === id)
+const tabViews = () => tabsUi.m.tabs.map((t) => tabView(t, tabSession(t.id), { title: sessionTitle, working: (s) => liveWorking(s) }))
+function tabsOnRoute(r) {
+  const id = r.name === 's' && r.arg ? String(r.arg) : null
+  if (tabsUi.active && tabsUi.active !== id) tabsUi.scrolls[tabsUi.active] = window.scrollY || 0
+  if (id) {
+    const permanent = tabsUi.permanent === id
+    setTabs(openTab(tabsUi.m, id, { permanent, hash: keepHash(location.hash), title: (tabSession(id) && sessionTitle(tabSession(id))) || '' }))
+  }
+  tabsUi.permanent = null
+  const changed = tabsUi.active !== id || tabsUi.route !== r.name
+  tabsUi.active = id; tabsUi.route = r.name
+  document.body.dataset.route = r.name
+  paintTabs()
+  if (changed) scrollActiveTab()
+}
+function tabsAfterRender() {
+  let m = tabsUi.m
+  for (const t of m.tabs) { const s = tabSession(t.id); if (s) m = remember(m, t.id, { title: sessionTitle(s) }) }
+  setTabs(m)
+  paintTabs()
+  const back = tabsUi.active && tabsUi.restoreScroll === tabsUi.active ? tabsUi.scrolls[tabsUi.active] : null
+  tabsUi.restoreScroll = null
+  if (back != null) window.scrollTo(0, back)
+  noteAnchor()
+  // the other open tabs' pulse and dot: read the sessions again now and then while you're off the board
+  if (tabsUi.route !== 'board' && tabsUi.m.tabs.some((t) => t.id !== tabsUi.active) && Date.now() - tabsUi.fetchedAt > 15000) refreshTabSessions()
+}
+async function refreshTabSessions() {
+  tabsUi.fetchedAt = Date.now()
+  try {
+    const { sessions = [], parked = [] } = await api('GET', '/v1/sessions?limit=200')
+    const fresh = new Map(sessions.concat(parked).map((s) => [s.id, s]))
+    state.sessions = state.sessions.map((s) => (s.id !== tabsUi.active && fresh.has(s.id) ? fresh.get(s.id) : s)).concat([...fresh.values()].filter((s) => !state.sessions.some((x) => x.id === s.id)))
+    paintTabs()
+  } catch {}
+}
+function paintTabs() {
+  const views = tabViews()
+  const strip = document.getElementById('tabStrip'), row = document.getElementById('openRow'), pager = document.getElementById('tabPager')
+  if (!strip) return
+  const sh = stripHtml(views, tabsUi.active, tabsUi.route === 'board', esc)
+  if (sh !== tabsUi.html.strip) {
+    const sc = strip.querySelector('.tab-scroll'), left = sc ? sc.scrollLeft : 0
+    const had = strip.contains(document.activeElement) ? (document.activeElement.dataset.tab || document.activeElement.dataset.tabClose || document.activeElement.dataset.tabKeep || document.activeElement.id) : null
+    strip.innerHTML = sh; tabsUi.html.strip = sh
+    const nsc = strip.querySelector('.tab-scroll'); if (nsc) nsc.scrollLeft = left
+    if (had) { const el = strip.querySelector('[data-tab="' + CSS.escape(had) + '"], [data-tab-close="' + CSS.escape(had) + '"], [data-tab-keep="' + CSS.escape(had) + '"], #' + CSS.escape(had)); if (el) el.focus({ preventScroll: true }) }
+  }
+  strip.hidden = false
+  const rh = openRowHtml(views, esc)
+  if (rh !== tabsUi.html.row) { const c = row.querySelector('.openrow-chips'), l = c ? c.scrollLeft : 0; row.innerHTML = rh; tabsUi.html.row = rh; const nc = row.querySelector('.openrow-chips'); if (nc) nc.scrollLeft = l }
+  row.hidden = !rh
+  const ph = tabsUi.active ? pagerHtml(tabsUi.m, tabsUi.active, views, esc) : ''
+  if (ph !== tabsUi.html.pager) { pager.innerHTML = ph; tabsUi.html.pager = ph }
+  pager.hidden = !ph
+}
+function scrollActiveTab() {
+  const el = document.querySelector('#tabStrip .tab-cell.on'), sc = document.querySelector('#tabStrip .tab-scroll')
+  if (!el || !sc) return
+  const r = el.getBoundingClientRect(), b = sc.getBoundingClientRect()
+  if (r.left < b.left) sc.scrollLeft -= b.left - r.left + 8
+  else if (r.right > b.right) sc.scrollLeft += r.right - b.right + 8
+}
+function keepTab(id) { setTabs(promote(tabsUi.m, id)); paintTabs() }
+function closeTabNow(id) {
+  const { model, next } = closeTab(tabsUi.m, id, tabsUi.active)
+  setTabs(model)
+  delete tabsUi.scrolls[id]
+  if (tabsUi.active === String(id)) {
+    const t = next && model.tabs.find((x) => x.id === next)
+    if (t) tabsUi.restoreScroll = t.id
+    location.hash = t ? tabView(t).href : '#/'
+  } else paintTabs()
+}
+function goTab(href) {
+  const id = sessionOfHash(href)
+  if (id) tabsUi.restoreScroll = id
+  if (location.hash === href) render(); else location.hash = href
+}
+// ⌘/Ctrl-click or a middle-click on any session link: open it as a permanent tab (here, not a new browser tab)
+function sessionLinkId(a) { return a && a.getAttribute && sessionOfHash(a.getAttribute('href') || '') }
+document.addEventListener('click', (e) => {
+  const a = e.target.closest && e.target.closest('a[href^="#/s/"]')
+  if (!a || !(e.metaKey || e.ctrlKey) || e.button !== 0) return
+  const id = sessionLinkId(a); if (!id) return
+  e.preventDefault(); e.stopPropagation()
+  if (indexOf(tabsUi.m, id) >= 0) setTabs(promote(tabsUi.m, id)); else tabsUi.permanent = id
+  if (location.hash === a.getAttribute('href')) render(); else location.hash = a.getAttribute('href')
+}, true)
+document.addEventListener('mousedown', (e) => { if (e.button === 1 && e.target.closest && e.target.closest('a[href^="#/s/"], #tabStrip .tab-cell')) e.preventDefault() }) // no autoscroll
+document.addEventListener('auxclick', (e) => {
+  if (e.button !== 1 || !e.target.closest) return
+  const cell = e.target.closest('#tabStrip .tab-cell')
+  if (cell) { e.preventDefault(); closeTabNow(cell.dataset.tabId); return } // middle-click a tab: close it
+  const a = e.target.closest('a[href^="#/s/"]')
+  const id = sessionLinkId(a); if (!id) return
+  e.preventDefault()
+  if (indexOf(tabsUi.m, id) >= 0) { setTabs(promote(tabsUi.m, id)); paintTabs() }
+  else { setTabs(openTab(tabsUi.m, id, { permanent: true })); paintTabs() } // opened in the background, the way a middle-click does
+})
+document.addEventListener('click', (e) => {
+  if (!e.target.closest) return
+  const close = e.target.closest('[data-tab-close]')
+  if (close) { e.preventDefault(); return closeTabNow(close.dataset.tabClose) }
+  const keep = e.target.closest('[data-tab-keep]')
+  if (keep) { e.preventDefault(); return keepTab(keep.dataset.tabKeep) }
+  const go = e.target.closest('[data-tab-go]')
+  if (go) { e.preventDefault(); return goTab(go.dataset.tabGo) }
+  const all = e.target.closest('#tabAll')
+  if (all) { e.preventDefault(); return openActionMenu(all, allTabsItems(tabViews(), tabsUi.active), { title: 'Open sessions' }) }
+  const t = e.target.closest('#tabStrip a[data-tab], #openRow a[data-tab], #tabPager a[data-tab]')
+  if (t && !e.metaKey && !e.ctrlKey && t.dataset.tab !== 'board') { e.preventDefault(); goTab(t.getAttribute('href')) }
+})
+document.addEventListener('dblclick', (e) => { const t = e.target.closest && e.target.closest('#tabStrip .tab-cell'); if (t) { e.preventDefault(); keepTab(t.dataset.tabId) } })
+// Working in a session keeps its tab: a Live message, typing there, answering Claude there
+const promoteActive = () => { if (tabsUi.active && tabsUi.route === 's') { const m = promote(tabsUi.m, tabsUi.active); if (m !== tabsUi.m) { setTabs(m); paintTabs() } } }
+for (const ev of ['input', 'change', 'submit']) document.addEventListener(ev, (e) => { if (e.target && $app.contains(e.target) && e.target.type !== 'search') promoteActive() }, true)
+document.addEventListener('click', (e) => { if (e.target.closest && $app.contains(e.target) && e.target.closest('[data-action="live-send"], .live-box [data-action], .need [data-choice], [data-action="ask-answer"], [data-action="rename"]')) promoteActive() }, true)
+// Drag a tab to reorder
+{
+  let dragId = null
+  document.addEventListener('dragstart', (e) => { const c = e.target.closest && e.target.closest('#tabStrip .tab-cell'); if (!c) return; dragId = c.dataset.tabId; c.classList.add('dragging'); try { e.dataTransfer.effectAllowed = 'move'; e.dataTransfer.setData('text/plain', dragId) } catch {} })
+  document.addEventListener('dragover', (e) => { if (!dragId) return; const c = e.target.closest && e.target.closest('#tabStrip .tab-cell'); if (!c) return; e.preventDefault(); document.querySelectorAll('#tabStrip .drop-before').forEach((x) => x.classList.remove('drop-before')); c.classList.add('drop-before') })
+  document.addEventListener('drop', (e) => { if (!dragId) return; const c = e.target.closest && e.target.closest('#tabStrip .tab-cell'); if (c) { e.preventDefault(); const to = indexOf(tabsUi.m, c.dataset.tabId); const from = indexOf(tabsUi.m, dragId); setTabs(moveTab(tabsUi.m, dragId, from < to ? to - 1 : to)); paintTabs() } })
+  document.addEventListener('dragend', () => { dragId = null; document.querySelectorAll('#tabStrip .dragging, #tabStrip .drop-before').forEach((x) => x.classList.remove('dragging', 'drop-before')) })
+}
+// Phones: swipe left / right on a session page for the next / previous open session
+{
+  let sw = null
+  const narrowQ = window.matchMedia('(max-width: 699.98px)')
+  const scrollsSideways = (el) => { for (let n = el; n && n !== document.body; n = n.parentElement) { if (n.scrollWidth > n.clientWidth + 2 && /(auto|scroll)/.test(getComputedStyle(n).overflowX)) return true } return false }
+  document.addEventListener('touchstart', (e) => {
+    sw = null
+    if (!narrowQ.matches || tabsUi.route !== 's' || e.touches.length !== 1) return
+    const t = e.target
+    if (t.closest('input, textarea, select, [contenteditable], .lo-menu, .cmdk, .doc-viewer, .tabs, .moremenu') || scrollsSideways(t)) return
+    sw = { x: e.touches[0].clientX, y: e.touches[0].clientY, at: Date.now() }
+  }, { passive: true })
+  document.addEventListener('touchend', (e) => {
+    if (!sw || !e.changedTouches.length) return
+    const p = e.changedTouches[0]
+    const dir = swipeDir(p.clientX - sw.x, p.clientY - sw.y, Date.now() - sw.at)
+    sw = null
+    if (!dir || (window.getSelection && String(window.getSelection()))) return
+    const n = neighbours(tabsUi.m, tabsUi.active)
+    const to = dir === 'next' ? n.next : n.prev
+    if (!to) return
+    const t = tabsUi.m.tabs.find((x) => x.id === to)
+    document.body.classList.remove('swipe-next', 'swipe-prev'); void document.body.offsetWidth
+    document.body.classList.add('swipe-' + dir); setTimeout(() => document.body.classList.remove('swipe-' + dir), 260)
+    goTab(tabView(t).href)
+  }, { passive: true })
+}
+// A width change keeps your place: the element at the top of the page stays at
+// the top, and a Live chat that was at its newest stays there.
+function anchorY() {
+  let y = 0
+  for (const el of [document.querySelector('.top'), document.getElementById('tabStrip'), document.getElementById('tabPager')]) {
+    if (!el) continue
+    const cs = getComputedStyle(el); if (cs.display === 'none' || !/(fixed|sticky)/.test(cs.position)) continue
+    const r = el.getBoundingClientRect(); if (r.top <= 1 && r.bottom < innerHeight / 2) y = Math.max(y, r.bottom)
+  }
+  return y
+}
+function noteAnchor() {
+  if (Date.now() < tabsUi.quietUntil) return
+  const y = anchorY() + 6, m = $app.getBoundingClientRect()
+  if (m.bottom < y) { tabsUi.anchor = null; return }
+  let el = document.elementFromPoint(Math.max(m.left + 24, Math.min(m.left + m.width / 2, innerWidth - 24)), y)
+  if (!el || !$app.contains(el) || el === $app) { const kids = [...$app.querySelectorAll('h1, h2, h3, p, li, .card, .fact, .lv-msg, section, div')]; el = kids.find((k) => { const r = k.getBoundingClientRect(); return r.bottom > y && r.height > 0 }) || null }
+  tabsUi.anchor = el ? { el, top: el.getBoundingClientRect().top, scrollY: window.scrollY } : null
+}
+function keepPlace() {
+  const a = tabsUi.anchor
+  tabsUi.quietUntil = Date.now() + 250
+  if (a && a.el.isConnected && a.scrollY > 0) window.scrollBy(0, a.el.getBoundingClientRect().top - a.top)
+  document.querySelectorAll('.live-log').forEach((log) => { const st = tabsUi.logs.get(log); if (st && st.bottom) log.scrollTop = log.scrollHeight })
+}
+{
+  let raf = 0
+  window.addEventListener('scroll', () => { if (raf) return; raf = requestAnimationFrame(() => { raf = 0; noteAnchor() }) }, { passive: true })
+  document.addEventListener('scroll', (e) => { const log = e.target; if (log && log.classList && log.classList.contains('live-log') && Date.now() >= tabsUi.quietUntil) tabsUi.logs.set(log, { bottom: log.scrollHeight - log.scrollTop - log.clientHeight < 24 }) }, true)
+  let lay = layoutFor(innerWidth)
+  window.addEventListener('resize', () => {
+    keepPlace()
+    const now = layoutFor(innerWidth)
+    if (now !== lay) { lay = now; document.body.dataset.layout = now; scrollActiveTab() }
+  })
+  document.body.dataset.layout = lay
+}
+
+// Pull to refresh (phones, 0.9.8): pull down from the top of a page and let go
+// past the line; the page reads its data again, the same as a live update (no
+// full reload unless that fails). Never from a field, the Live box or a menu.
+{
+  const ptr = document.createElement('div')
+  ptr.className = 'ptr'; ptr.id = 'ptr'; ptr.setAttribute('aria-hidden', 'true'); ptr.hidden = true
+  ptr.innerHTML = '<span class="ptr-ring"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" focusable="false"><path d="M21 12a9 9 0 1 1-3-6.7L21 8"/><path d="M21 3v5h-5"/></svg></span>'
+  document.body.appendChild(ptr)
+  const coarse = window.matchMedia('(pointer: coarse)'), narrow = window.matchMedia('(max-width: 699.98px)')
+  const overlayOpen = () => qlUi.open || moreOpen() || statusOpen() || !!document.querySelector('.cmdk:not([hidden]), .lo-menu, .doc-viewer:not([hidden]), .emoji-sheet-wrap')
+  let pull = null, refreshing = false
+  const paint = (step) => {
+    ptr.hidden = !step || (!step.pulling && !refreshing)
+    if (ptr.hidden) return
+    ptr.style.transform = 'translate(-50%, ' + (refreshing ? 56 : step.dist) + 'px)'
+    ptr.style.setProperty('--ptr-turn', String(Math.round((step.progress || 0) * 270)) + 'deg')
+    ptr.style.opacity = refreshing ? '1' : String(Math.min(1, 0.25 + (step.progress || 0)))
+    ptr.classList.toggle('armed', !!step.armed)
+    ptr.classList.toggle('busy', refreshing)
+  }
+  async function pullRefresh() {
+    refreshing = true; paint({ pulling: true, dist: 56, progress: 1, armed: true })
+    const started = Date.now()
+    try {
+      prsUi.at = {}; projectsUi.at = 0
+      const r = state.route || parseRoute()
+      const editing = busy() || ['settings', 'setup'].includes(r.name)
+      await Promise.all([editing ? null : render(), refreshHealth()])
+    } catch { location.reload(); return }
+    await new Promise((res) => setTimeout(res, Math.max(0, 450 - (Date.now() - started)))) // long enough to see it turn
+    refreshing = false; ptr.classList.remove('busy', 'armed'); ptr.hidden = true
+  }
+  window.leftoffPullRefresh = pullRefresh
+  document.addEventListener('touchstart', (e) => {
+    if (refreshing || e.touches.length !== 1) { pull = null; return }
+    const t = e.touches[0]
+    pull = canStartPull({ coarse: coarse.matches, narrow: narrow.matches, scrollY: window.scrollY || document.scrollingElement.scrollTop, target: e.target, overlayOpen: overlayOpen() }) ? { x: t.clientX, y: t.clientY, step: null } : null
+  }, { passive: true })
+  document.addEventListener('touchmove', (e) => {
+    if (!pull || e.touches.length !== 1) return
+    const t = e.touches[0]
+    const step = pullStep(t.clientY - pull.y, t.clientX - pull.x)
+    if (!step.pulling && !pull.step) { if (t.clientY - pull.y < -4 || Math.abs(t.clientX - pull.x) > 10) pull = null; return }
+    if ((window.scrollY || 0) > 0) { pull = null; paint(null); return }
+    if (e.cancelable) e.preventDefault() // ours, not the page's rubber band or the browser's own pull
+    pull.step = step
+    paint(step)
+  }, { passive: false })
+  const end = () => {
+    if (!pull) return
+    const what = pullRelease(pull.step)
+    pull = null
+    if (what === 'refresh') pullRefresh()
+    else paint(null)
+  }
+  document.addEventListener('touchend', end, { passive: true })
+  document.addEventListener('touchcancel', () => { pull = null; if (!refreshing) paint(null) }, { passive: true })
+}
+
+// Hide the nav on scroll (phones, 0.9.8): under 700px the top row and the bottom
+// bar slide away while you scroll down and come back when you scroll up, reach
+// the top or the very bottom (ui/navhide.js). Only your own scrolling hides
+// them: a route change, the ‹ › pager or a swipe shows them and holds them until
+// you next touch, wheel or key; typing, a menu or a sheet keeps them shown. The
+// page never reflows: the top row stays in the flow and the bar is an overlay
+// over padding that stays.
+{
+  const narrowQ = window.matchMedia('(max-width: 699.98px)')
+  const top = document.querySelector('.top')
+  let st = { hidden: false, anchor: 0 }, raf = 0, held = true
+  const typing = () => { const a = document.activeElement; return !!(a && a !== document.body && a.matches && a.matches(NAVHIDE_TYPING)) }
+  const overlay = () => qlUi.open || moreOpen() || statusOpen() || !!document.querySelector('.cmdk:not([hidden]), .lo-menu, .lo-backdrop, .doc-viewer:not([hidden]), .emoji-sheet-wrap, .relay-screen:not([hidden])')
+  const apply = (hidden) => {
+    if (hidden && top) document.documentElement.style.setProperty('--top-h', top.offsetHeight + 'px')
+    document.body.classList.toggle('nav-hidden', hidden)
+  }
+  const read = () => {
+    raf = 0
+    const se = document.scrollingElement || document.documentElement
+    const y = window.scrollY || se.scrollTop || 0
+    const next = navHideStep(st, { y, max: se.scrollHeight - window.innerHeight, blocked: held || !narrowQ.matches || typing() || overlay() })
+    if (next.hidden !== st.hidden) apply(next.hidden)
+    st = next
+  }
+  const soon = () => { if (!raf) raf = requestAnimationFrame(read) }
+  // no layout read here: this runs on every route change, ahead of the page's own render
+  const showNav = (hold = true) => { if (hold) held = true; const was = st.hidden; st = { hidden: false, anchor: NaN }; if (was) apply(false) }
+  window.addEventListener('scroll', soon, { passive: true })
+  for (const ev of ['touchstart', 'wheel', 'keydown']) window.addEventListener(ev, () => { held = false }, { passive: true, capture: true })
+  window.addEventListener('hashchange', () => showNav(true))
+  document.addEventListener('focusin', (e) => { if (typing() || (top && top.contains(e.target))) showNav(false) })
+  document.addEventListener('click', soon, { passive: true, capture: true }) // a menu or sheet just opened: back they come
+  narrowQ.addEventListener('change', () => showNav(false))
+  window.leftoffNav = { show: () => showNav(true), hidden: () => document.body.classList.contains('nav-hidden') }
 }
 
 // Status popover: open sessions, this Mac, the summarizer, sync, the version, the theme.
@@ -3319,6 +4176,7 @@ function placeStatus() {
   const pop = document.getElementById('statusPop'), b = document.getElementById('health')
   if (!pop || pop.hidden || !b) return
   const r = b.getBoundingClientRect(), vw = document.documentElement.clientWidth
+  if (railMode()) { pop.style.right = 'auto'; pop.style.left = (document.querySelector('.top').getBoundingClientRect().right + 8) + 'px'; pop.style.top = Math.max(8, Math.min(r.bottom - pop.offsetHeight, window.innerHeight - 8 - pop.offsetHeight)) + 'px'; return } // 0.9.8: beside the rail
   if (vw < 600) { pop.style.left = '8px'; pop.style.right = '8px'; pop.style.top = (r.bottom + 8) + 'px'; return }
   pop.style.right = 'auto'
   pop.style.top = (r.bottom + 8) + 'px'
@@ -3546,11 +4404,27 @@ document.addEventListener('keydown', (e) => {
 
 // A card opens its session's page from anywhere on it, except its buttons,
 // links, fields and selected text (0.4.3: the timeline was too hidden).
+// 0.9.8: the tap shows at once (a pressed card with a spinner); the page's
+// shell follows in the same frame (viewSession).
+function cardOpening(c) {
+  for (const x of document.querySelectorAll('.card.opening')) if (x !== c) x.classList.remove('opening')
+  c.classList.add('opening')
+  setTimeout(() => { if (c.isConnected) c.classList.remove('opening') }, 4000)
+}
+document.addEventListener('pointerdown', (ev) => {
+  const c = ev.target.closest && ev.target.closest('.card[data-href]')
+  if (!c || ev.button > 0 || ev.target.closest('button, input, lo-select, lo-combo, textarea, label, summary, [data-action]')) return
+  const a = ev.target.closest('a')
+  if (a && !/^#\/s\//.test(a.getAttribute('href') || '')) return // a repo chip, a PR link: not opening the session
+  cardOpening(c)
+}, { passive: true })
+document.addEventListener('pointercancel', () => { for (const x of document.querySelectorAll('.card.opening')) x.classList.remove('opening') }, true)
 document.addEventListener('click', (ev) => {
   const c = ev.target.closest('.card[data-href]')
   if (!c || ev.defaultPrevented || ev.target.closest('a, button, input, lo-select, lo-combo, textarea, label, summary, [data-action]')) return
   if (String(window.getSelection && window.getSelection()).trim()) return
   if (ev.metaKey || ev.ctrlKey) { window.open(c.dataset.href, '_blank'); return }
+  cardOpening(c)
   location.hash = c.dataset.href
 })
 
@@ -3577,6 +4451,8 @@ document.addEventListener('input', (ev) => {
 document.addEventListener('keydown', (ev) => { if (ev.target.id === 'prs-q' && ev.key === 'Escape' && ev.target.value) { ev.preventDefault(); ev.target.value = ''; ev.target.dispatchEvent(new Event('input', { bubbles: true })) } })
 
 window.addEventListener('hashchange', () => closeActionMenu())
+const tipsUi = wireTips(document) // 0.9.8: the ⓘ tooltips (Always allow here)
+window.addEventListener('hashchange', () => tipsUi.hide())
 // 0.8.9: a session page's title is a button too (Enter or Space renames it)
 document.addEventListener('keydown', (e) => { const t = e.target; if ((e.key === 'Enter' || e.key === ' ') && t && t.matches && t.matches('.s-title-text[role="button"]')) { e.preventDefault(); t.click() } })
 // 0.8.7: a card's ⋯ opens from the keyboard with the arrows too (Enter and Space click it).
@@ -3726,6 +4602,18 @@ document.addEventListener('click', async (ev) => {
       } catch (e) { cuUi.making = false; cuUi.err = e.message; render() }
       return
     }
+    if (action === 'restore-ask-confirm' || action === 'restore-ask-decline') {
+      const id = btn.dataset.id
+      if (!id || restoreUi.busy.has(id)) return
+      restoreUi.busy.add(id); render()
+      try {
+        const r = await api('POST', '/v1/restore/asks/' + encodeURIComponent(id) + '/' + (action === 'restore-ask-confirm' ? 'confirm' : 'decline'), {}, { timeoutMs: 60000 })
+        toast(r.state === 'confirmed' ? 'Restored ' + ((r.result && r.result.opened) || 0) + ' in Ghostty' : r.state === 'declined' ? 'Declined' : 'That request was ' + r.state)
+      } catch (e) { toast(e.message, 5000) }
+      restoreUi.busy.delete(id)
+      try { state.restore = await api('GET', '/v1/restore') } catch {}
+      return render()
+    }
     if (action === 'restore-open') { restoreUi.open = true; restoreUi.result = null; return render() }
     if (action === 'restore-close') { restoreUi.open = false; return render() }
     if (action === 'restore-dismiss') { try { localStorage.setItem(restoreDismissKey(state.restore || {}), '1') } catch {} restoreUi.open = false; return render() }
@@ -3736,6 +4624,18 @@ document.addEventListener('click', async (ev) => {
       if (!ids.length) { toast('Pick at least one'); return }
       const gate = restoreGate()
       if (!gate.ok) { toast(gate.hint.replace(/`/g, ''), 6000); return }
+      // 0.9.8: from a phone or another Mac, ask that Mac; a person there confirms
+      if (gate.how === 'ask') {
+        if (restoreUi.ask && ['pending', 'confirming'].includes(restoreUi.ask.state)) return
+        const machine = (state.restore && state.restore.machine) || null
+        btn.setAttribute('aria-disabled', 'true'); btn.textContent = 'Asking ' + (machine || 'the Mac') + '…'
+        try {
+          const r = await api('POST', '/v1/restore/asks', { machine, ids })
+          restoreUi.ask = { ...r, machine: machine || r.machine }
+          setTimeout(pollRestoreAsk, 2000)
+        } catch (e) { restoreUi.ask = { state: 'error', machine, error: e.message } }
+        return render()
+      }
       btn.disabled = true; btn.textContent = 'Opening ' + ids.length + '…'
       const r = await api('POST', '/v1/restore', { ids }, { timeoutMs: 60000 })
       restoreUi.result = r.how === 'print' || r.failed ? r : null
@@ -3885,6 +4785,9 @@ document.addEventListener('click', async (ev) => {
     }
     if (action === 'ask-answer' || action === 'ask-pick-send') return answerClick(btn, action)
     if (action === 'reply-send') return replyClick(btn)
+    if (action === 'live-send') return liveSendClick(btn)
+    if (action === 'live-jump') return liveJumpClick(btn)
+    if (action === 'live-earlier') return liveEarlierClick(btn)
     if (action === 'quick-reply') return quickReplyClick(btn)
     if (action === 'need-more') return needMoreClick(btn)
     if (action === 'need-dismiss') return needDismissClick(btn)
@@ -4012,7 +4915,7 @@ document.addEventListener('click', async (ev) => {
 // Answer a permission prompt or a question from the board. The daemon hands it
 // to the waiting hook or mod; the terminal's own prompt may already have won.
 async function answerClick(btn, action) {
-  const need = btn.closest('.need')
+  const need = btn.closest('.need, .ql-item') // 0.9.8: Quick look's Allow / Deny are the same buttons
   if (!need) return
   const askId = need.dataset.ask, key = need.dataset.key
   const s = state.sessions.find((x) => x.id === need.dataset.id)
@@ -4046,6 +4949,7 @@ async function answerClick(btn, action) {
     toast(e.code === 'not_waiting' ? 'Already handled: ' + e.message : e.message, 4200)
   } finally {
     delete state.pendingAsk[key]
+    if (need.classList.contains('ql-item')) { await loadQuickLook(); refreshHealth() }
     render()
   }
 }
@@ -4361,7 +5265,7 @@ document.addEventListener('submit', async (ev) => {
 
 // Live updates over SSE; re-render the current view, at most every 800 ms.
 let pending = null
-const busy = () => !!document.querySelector('.doc-viewer:not([hidden]), .lo-menu, .title input, .repomore[open], .need .deny-form:not([hidden])') || !!(document.activeElement && document.activeElement.closest && document.activeElement.closest('.addform') && document.activeElement.value) || !!(document.activeElement && document.activeElement.closest && document.activeElement.closest('.need') && /^(INPUT|TEXTAREA)$/.test(document.activeElement.tagName))
+const busy = () => !!document.querySelector('.doc-viewer:not([hidden]), .tip:not([hidden]), .lo-menu, .title input, .repomore[open], .need .deny-form:not([hidden])') || !!(document.activeElement && document.activeElement.closest && document.activeElement.closest('.addform') && document.activeElement.value) || !!(document.activeElement && document.activeElement.closest && document.activeElement.closest('.need') && /^(INPUT|TEXTAREA)$/.test(document.activeElement.tagName)) || !!(document.activeElement && document.activeElement.closest && document.activeElement.closest('.live-box') && document.activeElement.value)
 // Settings isn't redrawn by live updates: it would wipe what you're editing,
 // and the QR code you're scanning (v0.4.6). Its sections fetch their own state.
 function soon() { if (pending) return; pending = setTimeout(() => { pending = null; if (!busy() && !(state.route && ['settings', 'setup'].includes(state.route.name)) && !(state.route && state.route.name === 'catchup' && cuUi.open)) render(); refreshHealth() }, 800) }
@@ -4369,16 +5273,21 @@ let stream = null
 function connect() {
   if (stream) { try { stream.close() } catch {} }
   const es = stream = new EventSource('/v1/stream')
+  const again = connect.opened // a reconnect: events may have been missed while it was down
+  streamDog.opened()
+  // 0.9.8: every event and the daemon's ping say the stream is alive (ui/live-wake.js)
+  es.addEventListener('ping', () => { if (stream === es) streamDog.seen() })
   es.addEventListener('prs.updated', () => { prsUi.at = {} }) // 0.8.5: the PR page reads again on its next paint
   es.addEventListener('projects.updated', () => { projectsUi.at = 0 }) // 0.9.0
-  for (const t of ['session.updated', 'checkpoint.created', 'digest.created', 'spaces.updated', 'projects.updated', 'catchup.created', 'needs.updated', 'restore.updated', 'lists.updated', 'peers.updated', 'agents.updated', 'relay.updated', 'prs.updated']) es.addEventListener(t, soon)
+  for (const t of ['session.updated', 'checkpoint.created', 'digest.created', 'spaces.updated', 'projects.updated', 'catchup.created', 'needs.updated', 'restore.updated', 'lists.updated', 'peers.updated', 'agents.updated', 'relay.updated', 'prs.updated']) es.addEventListener(t, () => { if (stream === es) streamDog.seen(); soon() })
   // v0.5.8: standup text prefetched for a digest is stale once spaces or the digest change
   for (const t of ['spaces.updated', 'digest.created', 'checkpoint.created']) es.addEventListener(t, () => { digestUi.standups = {} })
   es.addEventListener('model.pull', (ev) => { try { onPull(JSON.parse(ev.data)) } catch {} })
   // A daemon that restarted (an upgrade, a folder move) comes back on the same
   // port; if the browser gave up on the stream, open a new one.
   es.onerror = () => { document.getElementById('health').className = 'health down'; if (es.readyState === 2 && stream === es) setTimeout(() => { if (stream === es) connect() }, 3000) }
-  es.onopen = () => refreshHealth()
+  let opens = 0
+  es.onopen = () => { if (stream !== es) return; streamDog.seen(); refreshHealth(); if (again || opens++) refreshView('reconnect'); connect.opened = true }
 }
 
 document.addEventListener('change', async (ev) => {
@@ -4487,3 +5396,6 @@ connect()
 // The home-screen app's service worker (v0.4.6): it only serves an offline page
 // when the Mac can't be reached; it caches no API data and no board pages.
 if ('serviceWorker' in navigator && window.isSecureContext) navigator.serviceWorker.register('/sw.js', { scope: '/' }).catch(() => {})
+// 0.9.8: phone notifications. The one per-device button (More on a phone,
+// Settings → General everywhere); the service worker shows the pushes.
+mountPush({ api })