@leftoff/cli 0.9.18-beta.12 → 0.9.18-beta.13

package/mod/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "leftoff",
-  "version": "0.9.18-beta.12",
+  "version": "0.9.18-beta.13",
   "description": "Leftoff (formerly Checkpoints): WTF was I working on? Tracks every Claude Code session on this machine, writes a 3-line checkpoint when one goes quiet, and adds /cp (checkpoint now), /cp-name and a /leftoff pane. Talks to the local Leftoff daemon on 127.0.0.1:7429 and falls back to writing markdown in ~/checkpoints.",
   "author": {
     "name": "One Silly App"

package/mod/hooks/core.js

@@ -904,10 +904,11 @@ export function computeStatus(s, now, cfg = DEFAULT_CONFIG) {
     // fire), so a turn that has been silent for twice the dormancy window is
     // treated as over. The mod sees turn.complete for aborted turns too.
     // 0.8.0: a Codex rollout shows no end for a turn Codex was killed in, either.
-    if ((s.capture === 'hooks' || s.capture === 'codex') && idle >= 2 * dormantAfter) return 'dormant'
+    // 2026-11-06: a subagent working is the turn going on, however quiet the session's own hooks are
+    if ((s.capture === 'hooks' || s.capture === 'codex') && idle >= 2 * dormantAfter && !(s.subagents && s.subagents.n > 0)) return 'dormant'
     return 'active'
   }
-  if (s.backgroundTasks > 0) return 'background'
+  if (s.backgroundTasks > 0 || (s.subagents && s.subagents.n > 0)) return 'background' // 2026-11-06: subagents working (the daemon reads them, src/subagents.js), a turn's end missed or not
   return idle >= dormantAfter ? 'dormant' : 'waiting'
 }
 

package/mod/hooks/register.js

@@ -32,7 +32,7 @@ const START_SKIP_GRACE_MS = 15000 // the same for SessionStart (a cold start can
 const PERM_GRACE_MS = 1500 // how long a permission prompt tool.check saw waits for classic.PermissionRequest before the mod reports it
 
 // Module state. $.state is not used: the pane redraws with $.ui.invalidate.
-const MOD_VERSION = '0.9.18-beta.12' // keep in step with .claude-plugin/plugin.json
+const MOD_VERSION = '0.9.18-beta.13' // keep in step with .claude-plugin/plugin.json
 
 const st = {
   internal: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leftoff/cli",
-  "version": "0.9.18-beta.12",
+  "version": "0.9.18-beta.13",
   "description": "Leftoff: WTF was I working on? Tracks every Claude Code session, writes a 3-line checkpoint when one goes quiet, and gives you a daily digest and a board, on your Mac and (optionally) your phone.",
   "keywords": [
     "claude",

package/ui/app.css

@@ -3602,7 +3602,7 @@ del.gd-x { background: var(--gd-del-word); }
 
 html.live-full, html.live-full body { overflow: hidden; overscroll-behavior: none; }
 .live-box.full { --lf-pl: max(12px, env(safe-area-inset-left)); --lf-pr: max(12px, env(safe-area-inset-right)); position: fixed; z-index: 32; left: 0; right: 0; top: var(--lf-top, 0); height: var(--lf-h, 100vh); height: var(--lf-h, 100dvh); margin: 0; border: 0; border-radius: 0; padding: 0 var(--lf-pr) max(10px, env(safe-area-inset-bottom)) var(--lf-pl); display: flex; flex-direction: column; background: var(--bg); box-sizing: border-box; }
-html.lf-kb .live-box.full { padding-bottom: 8px; }
+html.lf-kb .live-box.full { padding-bottom: calc(8px + var(--lf-acc, 0px)); } /* --lf-acc: iOS 26's keyboard bar floats over the page (app.js KB_ACCESSORY) */
 .live-box.full > * { flex: none; width: 100%; max-width: 860px; margin-left: auto; margin-right: auto; box-sizing: border-box; }
 .live-fbar { display: flex; align-items: center; gap: 6px; min-height: 52px; padding-top: env(safe-area-inset-top); border-bottom: 1px solid var(--line); }
 .live-box.full > .live-fbar { max-width: none; margin: 0 calc(-1 * var(--lf-pr)) 0 calc(-1 * var(--lf-pl)); width: auto; padding-left: max(4px, env(safe-area-inset-left)); padding-right: max(8px, env(safe-area-inset-right)); background: var(--bg); }
@@ -4546,7 +4546,7 @@ html:not(.live-full) .fs-side { display: none; }
   .fs-side.collapsed .fs-rail { display: none; }
   html.live-full.fs-on .live-box.full { height: calc(var(--lf-h, 100vh) - var(--fs-peek, 56px)); height: calc(var(--lf-h, 100dvh) - 56px - env(safe-area-inset-bottom)); padding-bottom: 6px; }
   html.live-full.lf-kb .fs-side { display: none; }
-  html.live-full.lf-kb.fs-on .live-box.full { height: var(--lf-h, 100dvh); }
+  html.live-full.lf-kb.fs-on .live-box.full { height: var(--lf-h, 100dvh); padding-bottom: calc(6px + var(--lf-acc, 0px)); }
   /* 2026-11-06 typing outside the sheet: it steps aside whether or not a keyboard's height was measured (app.js fitSheetAside) */
   html.live-full.lf-typing .fs-side { display: none; }
   html.live-full.lf-typing.fs-on .live-box.full { height: var(--lf-h, 100dvh); }
@@ -5645,3 +5645,22 @@ a.tp-cite::after { content: ''; position: absolute; inset: -10px -4px; }
 .prs-picks { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; padding: 8px 12px; margin: 0 0 10px; border: 1px solid var(--line); border-radius: 10px; background: var(--bg); }
 .prs-picks .btn, .prs-picks .linkish { min-height: 44px; }
 .wt-dec .wt-dec-id { white-space: nowrap; flex: none; }
+
+/* 2026-11-06 the quiet "Updated" after the board catches up on return (ui/app.js caughtUpCue): a check
+   and a word, out of the way under the top row, no spinner; no slide under reduced motion */
+.caught-up { position: fixed; top: calc(var(--lf-top, 0px) + env(safe-area-inset-top, 0px) + 56px); left: 50%; transform: translate(-50%, -4px); z-index: 60; display: inline-flex; align-items: center; gap: 6px; padding: 4px 10px; border-radius: 999px; border: 1px solid var(--line, rgba(127,127,127,.3)); background: var(--card, var(--bg, #fff)); color: var(--muted, inherit); font-size: 12.5px; pointer-events: none; opacity: 0; transition: opacity .2s ease, transform .2s ease; }
+.caught-up[hidden] { display: none; }
+.caught-up .ic { width: 14px; height: 14px; }
+.caught-up.in { opacity: 1; transform: translate(-50%, 0); }
+.caught-up.out { opacity: 0; }
+@media (prefers-reduced-motion: reduce) { .caught-up { transition: none; transform: translate(-50%, 0); } }
+
+/* 2026-11-06 subagents working (ui/subagents-view.js): a spinner shape and words, in the status pill
+   and as Live's line under the thread; the spinner stands still under reduced motion */
+.sub-spin { display: inline-block; width: 10px; height: 10px; border-radius: 50%; border: 2px solid currentColor; border-right-color: transparent; margin-right: 5px; vertical-align: -1px; animation: sub-spin 1s linear infinite; flex: none; }
+@keyframes sub-spin { to { transform: rotate(360deg); } }
+.lv-subs { display: flex; align-items: center; gap: 8px; min-height: 44px; margin: 6px 0 2px; padding: 6px 10px; border: 1px dashed var(--line-strong, var(--line)); border-radius: 10px; color: var(--text); font-size: 13px; }
+.lv-subs-what { display: flex; flex-direction: column; min-width: 0; flex: 1; }
+.lv-subs-step { color: var(--muted); font-family: var(--mono); font-size: 12px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.lv-subs-when { font-size: 12px; flex: none; }
+@media (prefers-reduced-motion: reduce) { .sub-spin { animation: none; border-right-color: currentColor; border-style: dotted; } }

package/ui/app.js

@@ -2,7 +2,7 @@
 // /v1 API on the same origin (auth rides the cookie set at GET /).
 import { goWithFeedback, goState, GIVE_UP_MS } from './go.js'
 import { icon } from './icons.js'
-import { fullViewportFit, isTypingTarget, outOfView, sheetAside, SHEET_BACK_AFTER_BLUR_MS, SETTLE_AFTER_BLUR_MS, SETTLE_WHILE_TYPING_MS } from './viewport-fit.js' // 2026-11-03: no gap above full screen after the keyboard closes; 2026-11-04: nor a hidden composer after switching keyboards
+import { fullViewportFit, isTypingTarget, outOfView, sheetAside, keyboardAccessoryPx, SHEET_BACK_AFTER_BLUR_MS, SETTLE_AFTER_BLUR_MS, SETTLE_WHILE_TYPING_MS, FOLLOW_FRAMES_MS } from './viewport-fit.js' // 2026-11-03: no gap above full screen after the keyboard closes; 2026-11-04: nor a hidden composer after switching keyboards
 import { selectHtml, comboHtml, closeMenu, openActionMenu, closeActionMenu, actionMenuKey, openNameSheet, openProjectSheet, refreshActionMenu } from './picker.js'
 import { sheetRepos, sheetPlan, runSheetPlan, askScopeItems } from './project-sheet.js' // 0.9.12: New project with several repos
 import { watchChipFades } from './chip-fade.js' // 0.9.12: chip rows fade only where chips run off
@@ -14,7 +14,7 @@ import { looksMd, stripMd, plainCp, tidyCp } from './cp-text.js'
 import { beginWriting, settleWriting, reconcileWriting, dismissWriting, isWriting, writingText, WRITING_SYNC_MS, FRESH_MS } from './writing.js'
 import { repoKeyOf, inStatus, repoChips, applyFilter, readFilter, saveRepos, filterHash, toggleRepo, chipSelected, splitChips, repoMatches, orderSelectedFirst, searchMatches, saveProject, inProject, projectChips, projectLabel, repoDisplay } from './repos.js'
 import { navKey, moreActive, badgeText, quickLookItems, quickLookHtml } from './nav.js'
-import { canStartPull, pullStep, pullRelease } from './pull.js'
+import { canStartPull, pullStep, pullRelease, onPullHead } from './pull.js'
 import { navHideStep, NAVHIDE_TYPING } from './navhide.js'
 import { loadSessionOrWait, loadingFromHtml, missingSessionHtml, missingKind, startedHref, startingHtml, STARTING_MS } from './session-missing.js' // 0.9.12: a session this Mac can't load
 import { openLightbox } from './lightbox.js' // 0.9.8: the image preview
@@ -23,6 +23,7 @@ import { isBlank, composerKey, isTouchUi, composerHeight, composerBoxHtml, keepF
 import { parseBang, dropBang, ptyInput, commandOutput, outputMessage, createBangStore, bangRowHtml, cmdLabel } from './bang.js' // 0.9.15 "!" commands
 import { withFresh, pickFresh, newerFresh, freshWins, pendingHeadless, settled as headlessSettled } from './headless-fresh.js' // 0.9.9 another Mac's session, current after Stop/Resume/Permissions
 import { bgPillHtml } from './bgtasks.js' // 0.9.13 "2 tasks running"
+import { subPillHtml, subStripHtml, subSig } from './subagents-view.js' // 2026-11-06 "2 subagents working"
 import { scopeHtml, scopeHintHtml, scopeStart } from './sm-scope.js' // 0.9.15 per-machine summarizer
 import { startPageHtml, startPick, startAsksBanner, headlessBarHtml, hmHelpId, modePillHtml, termPillHtml, termBarHtml, modeLabel, startsSettingHtml, localPillHtml, lockedAttrs, lockHtml, startViewerLocal as startViewerAt, startTexts, fillStartTexts, browseTarget, startPairAskHtml, typedPath, fillApproved, startBody, startExtrasNote, startProjectLineHtml, START_SID, startAttachTodo, newDraftId } from './start.js' // 0.9.9 New session
 import { parseNewSession, projectStartItems, newSessionContext, startStateFor } from './cmdk-new.js' // 0.9.13 ⌘K New session…
@@ -50,7 +51,7 @@ import { defaultEmoji, PICKER_SET, isEmoji, boardMachineFilter, machineOnlyLabel
 import { cutTitle } from './session-title.js'
 import { sessionTitle, sessionWhere, titleIsWhere, titleHtml, cardPills, foldsAsEmpty, threadHtml, earlierHtml, createLiveKeeper, liveHref, parseLiveRoute, scrollDecision, atBottom, jumpView, fadeBelow, jumpTarget, liveBadgeHtml, lockPulses, liveWorking, liveBoxKind, liveThreadWanted, pastViewWanted, pastEmptyText, parseFullRoute, fullHref, pageHref, fullButtonHtml, fullBarHtml, retryPayload, editDraft, messageAttachments, createRetryGate } 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 { anyPending, shouldPoll, streamDead, isStale, liveSignature, wakeReason, createWake, createWatchdog, HEARTBEAT_MS, POLL_MS, AWAY_MS, resumedAfter, catchUp, viewSignature } from './live-wake.js' // 0.9.8 live after sleep; 2026-11-06 catch up on return
 import { mountPush, paintPush } from './push.js' // 0.9.8 phone notifications
 import { createViewStore, viewRouteStep, fullHrefWith, notifyHash } from './full-mem.js' // 0.9.15 a session opens the way you left it, on this device
 import { TABS_KEY, layoutFor, parseStored, serialize, openTab, promote, remember, closeTab, neighbours, indexOf, sessionOfHash, keepHash, tabView, stripHtml, allTabsItems, openRowHtml, pagerHtml, swipeDir, fullTabsHtml, tabTarget, moveTabBefore, syncPins, legacyPins, isPinned } from './tabs.js'
@@ -468,7 +469,7 @@ function copiedMark(btn) {
   btn._copied = setTimeout(() => { btn.classList.remove('copied'); btn.innerHTML = icon('copy'); btn.setAttribute('aria-label', 'Copy resume command'); btn.title = tip }, 1500)
 }
 // 0.9.13: 'background' reads "2 tasks running", its tip naming them (ui/bgtasks.js)
-const pill = (status, s) => status === 'background' && s ? bgPillHtml(s, esc) : '<span class="pill s-' + esc(status) + '">' + esc(LABEL[status] || status) + '</span>'
+const pill = (status, s) => s && (status === 'active' || status === 'background') && s.subagents && s.subagents.n > 0 ? subPillHtml(s, esc) : status === 'background' && s ? bgPillHtml(s, esc) : '<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) => (ownerOffline(s) ? '' : liveBadgeHtml(s)) // 0.9.14: an asleep Mac's channel isn't listening
@@ -3542,7 +3543,16 @@ function setFullClass(on) {
 // and the composer stays just above the keyboard. When the keyboard closes the
 // layout goes back exactly to where it was (ui/viewport-fit.js: iOS can leave
 // its pan behind after a send, which put full screen ~300px down the screen).
-const lfKb = { scroll: null, settle: 0, blurAt: 0, back: 0 } // scroll: window.scrollY as a text box took focus (iOS may scroll the page under the keyboard); blurAt: when a text box outside the sheet let go
+const lfKb = { scroll: null, settle: 0, blurAt: 0, back: 0, raf: 0, until: 0 } // scroll: window.scrollY as a text box took focus (iOS may scroll the page under the keyboard); blurAt: when a text box outside the sheet let go
+// 2026-11-06 iOS 26's keyboard bar floats over the page (ui/viewport-fit.js ACCESSORY_PX): an iPhone or iPad
+// whose Safari has a CSS feature that arrived in 26 keeps room for it above the keyboard
+const KB_ACCESSORY = (() => {
+  try {
+    const ios = /iP(hone|ad|od)/.test(navigator.userAgent) || (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1)
+    const glass = !!(window.CSS && CSS.supports && (CSS.supports('anchor-name: --lf') || CSS.supports('animation-timeline: scroll()')))
+    return keyboardAccessoryPx({ ios, glass })
+  } catch { return 0 }
+})()
 // 2026-11-06 the phone's session sheet steps aside while you type outside it (ui/viewport-fit.js sheetAside)
 function fitSheetAside() {
   const html = document.documentElement, a = document.activeElement
@@ -3555,16 +3565,17 @@ function fitFullViewport() {
   const vv = window.visualViewport
   const html = document.documentElement, st = html.style
   fitSheetAside()
-  if (!html.classList.contains('live-full')) { st.removeProperty('--lf-h'); st.removeProperty('--lf-top'); st.removeProperty('--lf-bar'); html.classList.remove('lf-kb'); lfKb.scroll = null; return }
+  if (!html.classList.contains('live-full')) { st.removeProperty('--lf-h'); st.removeProperty('--lf-top'); st.removeProperty('--lf-bar'); st.removeProperty('--lf-acc'); html.classList.remove('lf-kb'); lfKb.scroll = null; return }
   // 0.9.14: from 700px full screen starts under the board's own tab bar (pinned to the top, the rail hidden)
   const strip = document.getElementById('tabStrip')
   const bar = strip && !strip.hidden && getComputedStyle(strip).display !== 'none' ? Math.round(strip.getBoundingClientRect().height) : 0
   st.setProperty('--lf-bar', bar + 'px')
   const typing = isTypingTarget(document.activeElement)
-  const fit = fullViewportFit({ innerHeight: window.innerHeight, vv, typing })
-  if (!fit) { st.removeProperty('--lf-h'); st.removeProperty('--lf-top'); html.classList.remove('lf-kb'); return }
+  const fit = fullViewportFit({ innerHeight: window.innerHeight, vv, typing, accessory: KB_ACCESSORY })
+  if (!fit) { st.removeProperty('--lf-h'); st.removeProperty('--lf-top'); st.removeProperty('--lf-acc'); html.classList.remove('lf-kb'); return }
   st.setProperty('--lf-h', fit.h + 'px')
   st.setProperty('--lf-top', fit.top + 'px')
+  st.setProperty('--lf-acc', (fit.pad || 0) + 'px') // room kept under the composer for a keyboard bar drawn over the page
   html.classList.toggle('lf-kb', fit.kb) // the keyboard is up: no home-indicator gap under the composer
   // the keyboard's gone: the page under full screen back where it was before the text box took focus
   if (!typing && lfKb.scroll != null && Math.abs(window.scrollY - lfKb.scroll) >= 1) window.scrollTo(window.scrollX, lfKb.scroll)
@@ -3579,7 +3590,7 @@ function keepTypingInView() {
   if (!vv || !html.classList.contains('live-full') || !isTypingTarget(el) || !el.closest) return
   const box = el.closest('.live-box.full')
   if (!box) return
-  const d = outOfView((el.closest('.composer') || el).getBoundingClientRect(), vv)
+  const d = outOfView((el.closest('.composer') || el).getBoundingClientRect(), vv, 1, parseFloat(html.style.getPropertyValue('--lf-acc')) || 0)
   if (d) html.style.setProperty('--lf-top', Math.round((parseFloat(html.style.getPropertyValue('--lf-top')) || 0) - d) + 'px')
 }
 // Every report while you type (a keyboard opening, swapping, changing height, or iOS scrolling the
@@ -3587,7 +3598,21 @@ function keepTypingInView() {
 // come with no report of its own, and a passing bogus one is put right by the next look.
 function onViewportChange(ev) {
   fitFullViewport()
-  if (isTypingTarget(document.activeElement) && document.documentElement.classList.contains('live-full')) settleWhileTyping(1)
+  if (isTypingTarget(document.activeElement) && document.documentElement.classList.contains('live-full')) { settleWhileTyping(1); followFrames() }
+}
+// 2026-11-06: and every frame for FOLLOW_FRAMES_MS after the box takes focus or iOS reports a change,
+// so the keyboard's animation (and iOS's numbers settling a frame or two late) is followed as it goes
+function followFrames() {
+  if (typeof requestAnimationFrame !== 'function') return
+  lfKb.until = performance.now() + FOLLOW_FRAMES_MS
+  if (lfKb.raf) return
+  const frame = () => {
+    lfKb.raf = 0
+    if (!isTypingTarget(document.activeElement) || !document.documentElement.classList.contains('live-full')) return
+    fitFullViewport()
+    if (performance.now() < lfKb.until) lfKb.raf = requestAnimationFrame(frame)
+  }
+  lfKb.raf = requestAnimationFrame(frame)
 }
 function settleWhileTyping(from = 0) {
   clearTimeout(lfKb.settle)
@@ -3612,6 +3637,7 @@ document.addEventListener('focusin', (e) => {
   // 2026-11-04: a third-party keyboard (Raycast, Gboard, SwiftKey) can come up late, or change the
   // visual viewport without a resize event of its own: measure again as it opens, as on the way down
   settleWhileTyping(0)
+  followFrames()
 })
 // A text box let go (a send closes the phone's keyboard, or a tap away): look again as the keyboard
 // goes down, whatever iOS reports or doesn't on the way.
@@ -3740,7 +3766,7 @@ function liveBoxHtml(s, v, { strip = '' } = {}) {
     '<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, attHtml: (atts) => attBubbleHtml(atts, s.id), inserts: rows, openGroups: askUi.groups, earlier: (v && v.earlier) || 0, may, mode: s.headless ? s.headless.mode : null, acts: may && !docked && !ownerOffline(s) && !turnSpinning(s, now), retried: retryUi.done, retrying: retryUi.busy }) + '</ol>' +
       '<p class="faint live-empty"' + (msgs.length || rows.length ? ' hidden' : '') + '>Nothing sent yet. Claude answers here' + (s.headless ? '' : ' and in the terminal') + '.</p>' +
-      liveJumpHtml() + '</div>' +
+      liveJumpHtml() + '</div>' + '<div class="lv-subs-slot">' + subStripHtml((v && v.subagents) || s.subagents, esc) + '</div>' +
     (v && v.error ? '<p class="live-err">' + esc(v.error) + '</p>' : '') +
     (ownerOffline(s) ? '<p class="live-off" role="note">' + icon('wifi-off') + '<span>' + esc(awayNote(s)) + ' (' + esc(offlineLine(s)) + '). Sending and answering work again once it’s back.</span></p></section>' : // 0.9.14: no composer or Allow/Deny for an asleep Mac
     (strip ? '<div class="lf-needs">' + strip + '</div>' : '') + (dock ? '' : backHtml(s)) +
@@ -4247,15 +4273,19 @@ const liveOnScreen = () => { const r = state.route; const box = document.querySe
 // 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) {
+async function refreshLive(reason, { force = false } = {}) {
   const id = liveOnScreen()
-  if (!id || liveUi.polling) return false
+  // 2026-11-06: a fetch that was in flight when the phone froze the page may never answer; coming
+  // back (force) doesn't wait behind it, and its late answer is dropped (the newer one wins)
+  if (!id || (liveUi.polling && !(force && Date.now() - (liveUi.triedAt || 0) > 1500))) return false
+  const gen = liveUi.gen = (liveUi.gen || 0) + 1
   liveUi.polling = true; liveUi.triedAt = Date.now()
   let v
-  try { v = await fetchLive(id, { timeoutMs: 8000 }) } finally { liveUi.polling = false }
+  try { v = await fetchLive(id, { timeoutMs: 8000 }) } finally { if (gen === liveUi.gen) liveUi.polling = false }
+  if (gen !== liveUi.gen) return false
   if (!v || v.error || liveOnScreen() !== id) { liveTick(); return false }
   const s = freshSession(state.sessions.find((x) => x.id === id))
-  const sig = liveSignature(v.messages)
+  const sig = liveSignature(v.messages) + '#' + subSig(v.subagents) // 2026-11-06: a subagent's step changes the thread's line
   const before = liveUi.sig[id]
   liveUi.sig[id] = sig
   if (s && before !== sig) {
@@ -4265,6 +4295,8 @@ async function refreshLive(reason) {
       const tmp = document.createElement('div')
       tmp.innerHTML = liveBoxHtml(s, v)
       const fresh = tmp.querySelector('.live-thread')
+      const slot = box.querySelector('.lv-subs-slot'), freshSlot = tmp.querySelector('.lv-subs-slot') // 2026-11-06: subagents working, outside the kept thread
+      if (slot && freshSlot) slot.innerHTML = freshSlot.innerHTML
       if (fresh) {
         const next = cur.nextSibling
         liveKeeper.before(box)
@@ -4284,8 +4316,13 @@ async function refreshLive(reason) {
 // The safety net, and the stream's watchdog, on one slow timer.
 const streamDog = createWatchdog()
 const wakeGate = createWake()
+let tickAt = Date.now() // 2026-11-06: the timer's own clock, to notice a frozen page (live-wake.js resumedAfter)
 setInterval(() => {
+  const was = tickAt; tickAt = Date.now()
   if (document.visibilityState === 'hidden') return
+  const frozen = resumedAfter(was, tickAt)
+  if (frozen) onWake({ type: 'resume', away: frozen })
+  if (renderDue && !busy()) { renderDue = false; render() } // a redraw a wake-up couldn't make while you typed
   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') }
@@ -4293,27 +4330,66 @@ setInterval(() => {
 // 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 renderDue = false // 2026-11-06: a wake-up's redraw held back while you type (busy()); made once you stop
+let freshAt = Date.now() // when the view's data was last known current (a refetch that answered)
+const WAKES = new Set(['visible', 'focus', 'online', 'pageshow-bfcache', 'resume', 'reconnect', 'resync', 'relay-switch'])
+async function refreshView(reason) {
+  const editing = state.route && ['settings', 'setup'].includes(state.route.name)
+  const id = liveOnScreen()
+  const before = viewSignature(state.sessions, id ? liveUi.sig[id] : '')
+  const wake = WAKES.has(reason)
+  if (reason === 'reconnect' && Date.now() - wakeAt < 2500) return // the stream a wake-up just opened: that wake-up is reading the view
+  const jobs = [id ? refreshLive(reason, { force: wake }) : null, refreshHealth()]
+  if (editing) { /* Settings reads its own sections */ } else if (busy()) renderDue = true
+  else jobs.push(render())
+  await Promise.all(jobs.map((p) => Promise.resolve(p).catch(() => null)))
+  if (!wake) return
+  freshAt = Date.now()
+  const id2 = liveOnScreen()
+  if (viewSignature(state.sessions, id2 ? liveUi.sig[id2] : '') !== before) caughtUpCue()
+}
+// The quiet "Updated" a wake-up's refetch shows when it brought something new: a word and a check
+// (never color alone), no spinner, gone in a moment; still under reduced motion (app.css).
+function caughtUpCue() {
+  let el = document.getElementById('caughtUp')
+  if (!el) {
+    el = document.createElement('div')
+    el.id = 'caughtUp'; el.className = 'caught-up'; el.setAttribute('role', 'status'); el.setAttribute('aria-live', 'polite')
+    el.innerHTML = icon('check') + '<span>Updated</span>'
+    document.body.appendChild(el)
+  }
+  el.hidden = false; el.classList.remove('out'); void el.offsetWidth; el.classList.add('in')
+  clearTimeout(caughtUpCue.t)
+  caughtUpCue.t = setTimeout(() => { el.classList.remove('in'); el.classList.add('out'); caughtUpCue.t = setTimeout(() => { el.hidden = true }, 400) }, 1600)
 }
 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 })
+  const why = ev.type === 'resume' ? 'resume' : 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
+  const now = Date.now()
+  const dead = !stream || stream.readyState === 2 || streamDead(streamDog.lastAt, now, HEARTBEAT_MS + 2000)
+  const away = Math.max(awayAt ? now - awayAt : 0, ev.away || 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()
+  // a click back into the window a moment later isn't a wake-up; coming back after a while, a
+  // restore, the network or a frozen page is (live-wake.js catchUp)
+  const plan = catchUp({ why, away, dead, freshAt: Math.max(freshAt, streamDog.lastAt || 0), now })
+  if (!plan.refetch) return
+  // the timer's freeze and the page's own events arrive together: one catch-up
+  if (now - wakeAt < 2500 && !dead) return
+  if (!wakeGate.due() && !plan.reconnect) return
+  wakeAt = now
+  if (plan.reconnect && now - (connect.at || 0) > 2000) connect()
   refreshView(why)
 }
+let wakeAt = 0
 for (const t of ['pageshow', 'focus', 'blur', 'online']) window.addEventListener(t, onWake)
+// 2026-11-06: the relay moved this board to another Mac: a new stream from it, and its data
+window.addEventListener('leftoff-relay', (e) => {
+  if (!(e.detail && e.detail.switched)) return
+  clearTimeout(onWake.sw); onWake.sw = setTimeout(() => { connect(); refreshView('relay-switch') }, 300)
+})
 // 0.9.15 (ui/away.js): when this board was last on screen here
 document.addEventListener('visibilitychange', () => { if (document.visibilityState === 'visible') { if (presence.start()) { openAway.clear(); render() } } else presence.here() })
 window.addEventListener('pagehide', () => presence.here())
@@ -8605,14 +8681,14 @@ function keepPlace() {
   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
+    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, head: onPullHead(e.target) } : 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 (!pull.head && (window.scrollY || 0) > 0) { pull = null; paint(null); return } // a pull from the bars at the top works scrolled anywhere
     if (e.cancelable) e.preventDefault() // ours, not the page's rubber band or the browser's own pull
     pull.step = step
     paint(step)
@@ -10502,6 +10578,7 @@ let stream = null
 function connect() {
   if (stream) { try { stream.close() } catch {} }
   const es = stream = new EventSource('/v1/stream')
+  connect.at = Date.now()
   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)
@@ -10512,6 +10589,9 @@ function connect() {
   // 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 {} })
+  // 2026-11-06: the relay's poll lost events (its Mac restarted, another Mac took over, or more
+  // happened than the daemon keeps): read the view again (ui/relay-client.js)
+  es.addEventListener('resync', () => { if (stream === es) refreshView('resync') })
   // 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) }

package/ui/live-wake.js

@@ -94,3 +94,50 @@ export function createWatchdog({ now = () => Date.now(), limit = STREAM_DEAD_MS
     get attempt() { return attempt },
   }
 }
+
+// 2026-11-06 the board catches up when you come back ("opening Leftoff on my phone, if it's been
+// opened and not closed, doesn't always pick up the latest data"). iOS freezes a Home Screen app in
+// the background: its timers stop, its event stream's socket is cut without an error, and on the way
+// back it doesn't always fire visibilitychange, focus or pageshow. Coming back after a few seconds
+// the old stream still looked alive (its last ping was under STREAM_DEAD_MS ago), a refetch already
+// in flight when the page froze held every new one back, and a redraw skipped while you had a draft
+// was never made. So:
+// - the board's one-second timer notices it was frozen (it missed RESUME_GAP_MS) and treats that as
+//   coming back, whether or not the page said so
+// - coming back after RECONNECT_AWAY_MS (or the network returning, a restore, a frozen page) always
+//   opens a new stream, whatever the old one's last ping said
+// - a relay poll that answers "reset" (the Mac restarted, or another Mac took over) or "gap" (more
+//   happened than the daemon keeps) refetches the view, since the events in between are gone
+export const RESUME_GAP_MS = 5000
+export const RECONNECT_AWAY_MS = 10000
+export const FRESH_MS = 30000
+
+// How long the page was frozen, by a timer that should have ticked every second: 0 when it ticked.
+export function resumedAfter(prevTick, now = Date.now(), gap = RESUME_GAP_MS) {
+  const d = now - (Number(prevTick) || 0)
+  return prevTick && d > gap ? d : 0
+}
+
+// What a wake-up does: open a new stream (reconnect) and read the view again (refetch).
+//   why: wakeReason's word, or 'resume' (the timer saw a freeze); away: ms in the background;
+//   dead: the stream missed its pings; freshAt: when the view's data was last known current
+//   (a fetch that answered, or the stream's last ping)
+export function catchUp({ why, away = 0, dead = false, freshAt = 0, now = Date.now() } = {}) {
+  if (!why) return { reconnect: false, refetch: false }
+  const hard = why === 'pageshow-bfcache' || why === 'online' || why === 'resume'
+  const reconnect = !!(dead || hard || away >= RECONNECT_AWAY_MS)
+  const stale = !freshAt || now - freshAt > FRESH_MS
+  const refetch = !!(reconnect || away >= AWAY_MS || stale)
+  return { reconnect, refetch }
+}
+
+// A relay poll's answer: were events lost between `after` and this answer?
+export function pollLost(after, j) {
+  if (!j || after == null || after < 0) return false
+  return !!(j.reset || j.gap)
+}
+
+// What the view's data looks like, to tell a refetch that changed something (the quiet "Updated").
+export function viewSignature(sessions, liveSig = '') {
+  return (sessions || []).map((s) => [s && s.id, s && s.status, s && s.title, s && s.lastActivityAt, s && s.subagents ? s.subagents.n + ':' + (s.subagents.latest ? s.subagents.latest.at : '') : ''].join(',')).sort().join('|') + '#' + (liveSig || '')
+}

package/ui/pull.js

@@ -9,10 +9,24 @@ export const PULL_MAX = 110 // how far the spinner travels at most
 // sideways scrollers, and anything open on top of the page.
 export const PULL_SKIP = 'input, textarea, [contenteditable=""], [contenteditable="true"], .live-box, lo-select, lo-combo, .lo-menu, .lo-backdrop, .cmdk, .quicklook, .moremenu, .statuspop, .doc-viewer, .emoji-sheet-wrap, .relay-screen, .tabs, pre, .scroll-x, .fs-side, [data-no-pull]'
 
-// The phone layout on a touch screen, at the very top of the page, from a
-// place that isn't a field or an overlay, and with no overlay open.
+// 2026-11-06 ("it's really hard to do that when you're at the bottom of a long message chain, because
+// you have to scroll all the way to the top"): the bars at the top of the screen are a handle of their
+// own. A pull that starts on the top row, a session's head or the Live box's head refreshes wherever
+// the page or the chat is scrolled to. Fields, menus, sideways scrollers and the sheets still never
+// start one (PULL_HEAD_SKIP: PULL_SKIP without the Live box, whose head is one of the bars).
+export const PULL_HEAD = 'header.top, .s-head, .fs-head, .live-head, .live-fbar' // .live-fbar: full-screen Live's slim bar
+export const PULL_HEAD_SKIP = PULL_SKIP.split(', ').filter((x) => x !== '.live-box' && x !== 'pre').join(', ') + ', button.chip-x, [role="slider"]'
+export function onPullHead(target) {
+  if (!target || typeof target.closest !== 'function') return false
+  return !!target.closest(PULL_HEAD) && !target.closest(PULL_HEAD_SKIP)
+}
+
+// The phone layout on a touch screen, at the very top of the page (or on one of
+// the bars at the top, onPullHead), from a place that isn't a field or an
+// overlay, and with no overlay open.
 export function canStartPull({ coarse, narrow, scrollY, target, overlayOpen } = {}) {
   if (!coarse || !narrow || overlayOpen) return false
+  if (onPullHead(target)) return true
   if (scrollY > 0) return false
   if (target && typeof target.closest === 'function' && target.closest(PULL_SKIP)) return false
   if (scrolledAbove(target)) return false

package/ui/relay-client.js

@@ -364,7 +364,9 @@ class RelayEventSource extends EventTarget {
         if (this.readyState === 0) { this.readyState = 1; if (this.onopen) this.onopen(new Event('open')) }
         this.dispatchEvent(new MessageEvent('ping', { data: '{}' })) // a poll that answered is the stream's heartbeat
         const first = this.seq == null
+        const lost = !first && (j.reset || j.gap) // 2026-11-06: events this browser never got (the Mac restarted, another took over, or more happened than it keeps)
         this.seq = j.seq
+        if (lost) this.dispatchEvent(new MessageEvent('resync', { data: JSON.stringify({ reset: !!j.reset, gap: !!j.gap }) }))
         if (!first) for (const e of j.events || []) {
           const ev = new MessageEvent(e.event, { data: JSON.stringify(e.data) })
           this.dispatchEvent(ev)

package/ui/subagents-view.js

@@ -0,0 +1,41 @@
+// 2026-11-06 subagents working, on the board (src/subagents.js reads them): the session's status says
+// "2 subagents working" instead of looking idle, and Live shows a line with what the newest one is
+// doing ("Bash: pnpm test"). Words and a shape (the spinner), never color alone.
+
+export function subCount(s) { const n = s && s.subagents ? Number(s.subagents.n) || 0 : 0; return n > 0 ? n : 0 }
+export function subLabel(sub) {
+  const n = sub ? Number(sub.n) || 0 : 0
+  return n > 0 ? n + (n === 1 ? ' subagent working' : ' subagents working') : ''
+}
+export function subStep(sub) {
+  const l = sub && sub.latest
+  if (!l) return ''
+  return String(l.tool ? l.tool + (l.detail ? ': ' + l.detail : '') : l.detail || '').replace(/\s+/g, ' ').trim().slice(0, 160)
+}
+const who = (a) => (a && (a.label || (a.type ? a.type + ' agent' : ''))) || 'a subagent'
+export function subTip(sub) {
+  const list = (sub && Array.isArray(sub.agents) ? sub.agents : []).map((a) => who(a) + (a && a.bg ? ' (background)' : ''))
+  const step = subStep(sub)
+  return (list.length ? list.join('\n') : subLabel(sub)) + (step ? '\nNow: ' + step : '')
+}
+// The status pill while subagents work (a session in a turn or with background work)
+export function subPillHtml(s, esc) {
+  const sub = s && s.subagents
+  const label = subLabel(sub)
+  if (!label) return ''
+  const tip = subTip(sub)
+  return '<span class="pill s-active sub-pill" tabindex="0" data-tip="' + esc(tip) + '" aria-label="' + esc(label + ': ' + tip.replace(/\n/g, ', ')) + '"><span class="sub-spin" aria-hidden="true"></span>' + esc(label) + '</span>'
+}
+// Live's line under the thread
+export function subStripHtml(sub, esc, { now = Date.now() } = {}) {
+  const label = subLabel(sub)
+  if (!label) return ''
+  const step = subStep(sub)
+  const at = sub.latest && sub.latest.at ? Number(sub.latest.at) : 0
+  const ago = at ? Math.max(0, Math.round((now - at) / 1000)) : null
+  const when = ago == null ? '' : ago < 5 ? 'just now' : ago < 90 ? ago + 's ago' : Math.round(ago / 60) + 'm ago'
+  return '<div class="lv-subs" role="status" data-tip="' + esc(subTip(sub)) + '"><span class="sub-spin" aria-hidden="true"></span><span class="lv-subs-what"><b>' + esc(label) + '</b>' +
+    (step ? '<span class="lv-subs-step">' + esc(step) + '</span>' : '') + '</span>' + (when ? '<span class="faint lv-subs-when">' + esc(when) + '</span>' : '') + '</div>'
+}
+// What Live's refetch compares, beside the thread's own signature
+export function subSig(sub) { return sub && sub.n > 0 ? sub.n + ':' + (sub.latest ? sub.latest.at + (sub.latest.tool || '') + (sub.latest.detail || '') : '') : '' }

package/ui/viewport-fit.js

@@ -22,13 +22,14 @@ export function isTypingTarget(el) {
 export const KEYBOARD_MIN_PX = 120 // less than this is the browser's own bars, not a keyboard
 
 // innerHeight: the layout viewport's height; vv: { height, offsetTop, scale }; typing: a text box has focus.
-// -> { h, top, kb } in CSS px (null without a visualViewport: the CSS falls back to 100dvh).
+// accessory: px a keyboard bar drawn over the page covers (keyboardAccessoryPx).
+// -> { h, top, kb, pad? } in CSS px (pad only when there's room to keep) (null without a visualViewport: the CSS falls back to 100dvh).
 // 2026-11-04 (switching keyboards mid-typing hid the composer): while a text box has focus, full
 // screen is exactly the visual viewport as iOS reports it right now, whatever the keyboard's height
 // (a keyboard swap reports a passing full-height or tiny keyboard on the way; following each report
 // means the next one puts it right). Nothing is remembered from when the box took focus. `kb` (the
 // keyboard's own look: no home-indicator gap) still needs a keyboard's worth of height.
-export function fullViewportFit({ innerHeight, vv, typing = false } = {}) {
+export function fullViewportFit({ innerHeight, vv, typing = false, accessory = 0 } = {}) {
   if (!vv || !(Number(innerHeight) > 0)) return null
   const ih = Number(innerHeight)
   const vh = Number(vv.height) > 0 ? Number(vv.height) : ih
@@ -37,15 +38,32 @@ export function fullViewportFit({ innerHeight, vv, typing = false } = {}) {
   if (!typing && !zoomed) return { h: Math.round(ih), top: 0, kb: false } // no keyboard: the whole window, from its top
   const room = Math.max(0, ih - vh) // a visual viewport as tall as the window can't be panned (a stale pan)
   const top = Math.min(Math.max(0, Number(vv.offsetTop) || 0), room)
-  return { h: Math.round(Math.min(vh, ih)), top: Math.round(top), kb }
+  // pad: room kept clear at the bottom for a keyboard bar drawn over the page (iOS 26's form bar), only with a keyboard up
+  const pad = kb ? Math.max(0, Math.round(Number(accessory) || 0)) : 0
+  const fit = { h: Math.round(Math.min(vh, ih)), top: Math.round(top), kb }
+  if (pad) fit.pad = pad
+  return fit
+}
+
+// 2026-11-06 (Joel, iPhone: "So close but not quite": the sheet stepped aside, but only the reply
+// box's top edge showed above the keyboard's ^ v ✓ bar). Since iOS 26 that bar floats over the
+// page (Liquid Glass: it and the band behind it show the page through), and the visual viewport iOS
+// reports runs down behind it, so a reply box placed at the reported bottom sits under the bar. No
+// browser number says how tall the bar is, so on an iPhone or iPad whose Safari is 26 or later
+// (glass: a CSS feature that arrived in Safari 26) full screen keeps this much clear at its bottom
+// while a keyboard is up. On older iOS the bar was outside the reported viewport: nothing kept.
+// Measured from the screenshot: the band from the bar's top edge to the keys is about 68px.
+export const ACCESSORY_PX = 64
+export function keyboardAccessoryPx({ ios = false, glass = false } = {}) {
+  return ios && glass ? ACCESSORY_PX : 0
 }
 
 // How far full screen's composer sits outside what you can see (the visual viewport, in the same
 // page coordinates as getBoundingClientRect): > 0 means move it up by that much, < 0 down, 0 it's in view.
 // rect: the composer's { top, bottom }; vv: { height, offsetTop }.
-export function outOfView(rect, vv, slack = 1) {
+export function outOfView(rect, vv, slack = 1, pad = 0) {
   if (!rect || !vv || !(Number(vv.height) > 0)) return 0
-  const top = Number(vv.offsetTop) || 0, bottom = top + Number(vv.height)
+  const top = Number(vv.offsetTop) || 0, bottom = top + Number(vv.height) - Math.max(0, Number(pad) || 0) // pad: covered by a keyboard bar
   if (rect.bottom > bottom + slack) return Math.round(Math.min(rect.bottom - bottom, rect.top - top)) // below the keyboard's edge (never past its own top)
   if (rect.top < top - slack) return -Math.round(top - rect.top) // above the top of what you can see
   return 0
@@ -57,6 +75,10 @@ export const SETTLE_AFTER_BLUR_MS = [0, 120, 350, 700, 1100]
 // The same beats after every report while a text box has focus: a keyboard swap's last change can
 // come with no event of its own, so the board looks again a few times after each one.
 export const SETTLE_WHILE_TYPING_MS = SETTLE_AFTER_BLUR_MS
+// And every frame for this long after the box takes focus and after each report: iOS animates the
+// keyboard (and pans) for ~0.3–0.5 s, part of it with no event, and its numbers settle a frame or
+// two after the event that announced them (WebKit bug 237851: offsetTop read 0 mid-animation).
+export const FOLLOW_FRAMES_MS = 1000
 
 // 2026-11-06 (the phone's session sheet covered the reply box while typing; "sometimes I have to
 // scroll that down, and then the message box appears"): the sheet went away only when the board