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

package/ui/pull.js

@@ -7,7 +7,7 @@ export const PULL_MAX = 110 // how far the spinner travels at most
 
 // Where a pull never starts: text fields, the Live box, menus and sheets,
 // 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, [data-no-pull]'
+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.
@@ -15,9 +15,22 @@ export function canStartPull({ coarse, narrow, scrollY, target, overlayOpen } =
   if (!coarse || !narrow || overlayOpen) return false
   if (scrollY > 0) return false
   if (target && typeof target.closest === 'function' && target.closest(PULL_SKIP)) return false
+  if (scrolledAbove(target)) return false
   return true
 }
 
+// 2026-11-06 (the phone's session sheet "scrolls down okay, but I cannot scroll back up. It's very
+// jumpy"): in full screen the page itself never scrolls (scrollY is 0), so a finger moving down
+// inside the sheet's own scroller was taken as a pull to refresh: the board cancelled the scroll and
+// showed the spinner instead. A pull only starts where nothing between the finger and the page is
+// itself scrolled down: a scroller with room above means the finger is scrolling it back up.
+export function scrolledAbove(el) {
+  for (let n = el; n && n.nodeType === 1; n = n.parentElement) {
+    if ((Number(n.scrollTop) || 0) > 0) return true
+  }
+  return false
+}
+
 // One finger movement: how far the spinner sits (with some resistance), how
 // far round it is, and whether letting go now refreshes. Sideways first means
 // it isn't a pull.

package/ui/semdiff.js

@@ -371,11 +371,25 @@ function fileMapHtml(data, { esc, icon, cur }) {
   return h + '<div class="wt-fm-k"><span class="kbd">j</span><span class="kbd">k</span> next step</div></nav>'
 }
 
+// 2026-11-06 every PR the session has is its own range ('pr:<owner/repo>#<n>'): up to PR_CHIPS of them are
+// chips; more fold into one "PRs" chip that opens a menu (the one picked shows its number)
+export const PR_CHIPS = 2
+export const isPrKey = (k) => k === 'pr' || /^pr:/.test(String(k || ''))
+const PR_WORD = { merged: 'merged', closed: 'closed', draft: 'draft' }
+export function prScopeTip(x) { return [x.title, x.repo, x.state ? (x.state === 'open' ? 'Open' : x.state[0].toUpperCase() + x.state.slice(1)) : ''].filter(Boolean).join(' · ') }
 function scopesHtml(data, scope, { esc, icon, sid }) {
   const sc = (data && data.scopes) || [{ key: 'checkpoint', label: SCOPE_WORDS.checkpoint, available: false }, { key: 'session', label: SCOPE_WORDS.session, available: true }]
-  return '<div class="wt-seg" role="group" aria-label="What to walk through">' + sc.map((x) =>
-    '<button type="button" data-action="wt-scope" data-id="' + esc(sid) + '" data-scope="' + esc(x.key) + '" aria-pressed="' + (x.key === scope ? 'true' : 'false') + '"' + (x.available === false ? ' disabled data-tip="No checkpoint yet"' : '') + '>' +
-    (x.key === 'pr' ? icon('git-pull-request') : '') + '<span>' + esc(x.label) + '</span></button>').join('') + '</div>'
+  const prs = sc.filter((x) => isPrKey(x.key)), rest = sc.filter((x) => !isPrKey(x.key))
+  const chip = (x) => '<button type="button" data-action="wt-scope" data-id="' + esc(sid) + '" data-scope="' + esc(x.key) + '" aria-pressed="' + (x.key === scope ? 'true' : 'false') + '"' + (x.available === false ? ' disabled data-tip="No checkpoint yet"' : isPrKey(x.key) && prScopeTip(x) ? ' data-tip="' + esc(prScopeTip(x)) + '"' : '') + '>' +
+    (isPrKey(x.key) ? icon('git-pull-request') : '') + '<span>' + esc(x.label) + (PR_WORD[x.state] ? ' · ' + PR_WORD[x.state] : '') + '</span></button>'
+  let h = rest.map(chip).join('')
+  if (prs.length <= PR_CHIPS) h += prs.map(chip).join('')
+  else {
+    const cur = prs.find((x) => x.key === scope)
+    h += '<button type="button" data-action="wt-prs" data-id="' + esc(sid) + '" aria-pressed="' + (cur ? 'true' : 'false') + '" aria-haspopup="menu" aria-expanded="false" aria-label="' + esc(cur ? cur.label + ', pick another of ' + prs.length + ' PRs' : 'Pick one of ' + prs.length + ' PRs') + '"' + (cur && prScopeTip(cur) ? ' data-tip="' + esc(prScopeTip(cur)) + '"' : '') + '>' +
+      icon('git-pull-request') + '<span>' + esc(cur ? cur.label + (PR_WORD[cur.state] ? ' · ' + PR_WORD[cur.state] : '') : 'PRs · ' + prs.length) + '</span>' + icon('chevron-down', 'ic wt-seg-chev') + '</button>'
+  }
+  return '<div class="wt-seg" role="group" aria-label="What to walk through">' + h + '</div>'
 }
 
 // 2026-10-30 (asked: "the left side file list should be somewhat collapsible"): folded to a
@@ -464,7 +478,7 @@ export function walkthroughHtml({ s, data, ui, reviewed = new Set(), esc, icon,
   if (ui.loading) h += '<p class="wt-sum wt-loading" role="status"><span class="wt-spin" aria-hidden="true"></span><span>Reading the change' + (data && data.status === 'ok' ? '' : '…') + '</span><button type="button" class="linkish wt-stop" data-action="wt-stop" data-id="' + esc(sid) + '">Stop</button></p>'
   if (ui.error) h += '<p class="wt-note" role="alert">' + icon('circle-alert') + '<span>' + esc(ui.error) + '</span></p>'
   if (data && !ui.loading && data.status !== 'ok' && data.message) {
-    const msg = data.status === 'empty' && scope === 'session' ? 'No changes in this session yet.' : data.status === 'empty' && scope === 'pr' ? 'No changes in this PR yet.' : data.message
+    const msg = data.status === 'empty' && scope === 'session' ? 'No changes in this session yet.' : data.status === 'empty' && isPrKey(scope) ? 'No changes in this PR yet.' : data.message
     h += '<p class="wt-note">' + icon('info') + '<span>' + esc(msg) + (data.status === 'no_model' ? ' <a href="#/settings/summaries">Settings</a>' : '') + '</span></p>'
     h += unreadableHtml(data, { esc, icon }) // 2026-10-29 a repo that couldn't be read says so
     // a fallback says why (the first reason; the model's whole reply: leftoff walkthrough debug)
@@ -473,7 +487,7 @@ export function walkthroughHtml({ s, data, ui, reviewed = new Set(), esc, icon,
     if (data.status === 'fallback' && data.small) h += '<p class="faint wt-small">' + icon('info') + '<span>Small local models struggle here. Try Claude or qwen2.5-coder 7B in <a href="#/settings/models">Settings</a>.</span></p>'
   }
   // 2026-11-03 switched to the other scope with nothing written for it: never a model run on its own; Write it is one tap
-  if (data && !ui.loading && data.status === 'none' && view === 'story') h += '<p class="wt-stale" role="status"><i class="wt-chg-g" aria-hidden="true"></i><span>' + (data.fileScope && data.fileScope.key === 'folder' ? 'No walkthrough of the whole folder yet.' : 'No walkthrough of this session’s changes yet.') + ' The files are under Files.</span><button type="button" class="linkish wt-upd" data-action="wt-update" data-id="' + esc(sid) + '">' + icon('refresh-cw') + 'Write it</button></p>'
+  if (data && !ui.loading && data.status === 'none' && view === 'story') h += '<p class="wt-stale" role="status"><i class="wt-chg-g" aria-hidden="true"></i><span>' + (isPrKey(ui.scope) ? 'No walkthrough of this PR yet.' : data.fileScope && data.fileScope.key === 'folder' ? 'No walkthrough of the whole folder yet.' : 'No walkthrough of this session’s changes yet.') + ' The files are under Files.</span><button type="button" class="linkish wt-upd" data-action="wt-update" data-id="' + esc(sid) + '">' + icon('refresh-cw') + 'Write it</button></p>'
   const deck = ok && view === 'story' && ui.deck !== false && (data.steps || []).length > 0 // 0.9.18 the slideshow
   if (ok && view === 'story' && !deck) {
     const steps = data.steps || []
@@ -562,7 +576,7 @@ function deckHtml(data, ui, { esc, icon, reviewed, sid }) {
   let h = '<div class="wt-deck" id="wtDeck" data-cur="' + cur + '" data-n="' + total + '" tabindex="-1" aria-roledescription="slideshow" aria-label="Walkthrough slides">'
   // the overview
   const st = data.stats || {}
-  const scope = SCOPE_WORDS[ui.scope] || ''
+  const scope = SCOPE_WORDS[ui.scope] || (((data.scopes || []).find((x) => x.key === ui.scope) || {}).label) || ''
   const pm = Array.isArray(data.files) && data.files.length ? data.files.reduce((a, f) => ({ add: a.add + (f.add || 0), del: a.del + (f.del || 0) }), { add: 0, del: 0 }) : null
   let o = '<p class="wt-sum big"><b>' + esc(data.headline) + '</b></p>' + (data.summary ? '<p class="wt-sum md-in">' + walkInlineLinks(data.summary) + '</p>' : '')
   o += '<div class="wt-meta">' + (scope ? '<span>' + icon('git-compare') + esc(scope) + '</span>' : '') + '<span>' + plural(st.files || 0, 'file') + (pm ? ' <b class="wt-pl">+' + n0(pm.add) + '</b> <b class="wt-mi">−' + n0(pm.del) + '</b>' : '') + '</span><span>' + plural(steps.length, 'step') + '</span><span id="wtProg">' + steps.filter((x) => reviewed.has(x.id)).length + ' of ' + steps.length + ' reviewed</span></div>'

package/ui/sglyph.js

@@ -109,14 +109,14 @@ export const countsAsWaiting = (s, offline = false) => !!s && !(offline && s.isL
 //   hidden  inside a control that already names the state: aria-hidden, no role
 //   closed  a closed session's quiet ring is fainter
 //   arrive  the page-clock time the new-reply dot appeared (it pulses once from then)
-export function glyphHtml(state, { esc = escDefault, tip = '', quiet = false, hidden = false, closed = false, arrive = null, cls = '' } = {}) {
+export function glyphHtml(state, { esc = escDefault, tip = '', quiet = false, hidden = false, closed = false, arrive = null, cls = '', noTip = false } = {}) {
   if (!GLYPHS.includes(state)) state = 'quiet'
   if (state === 'quiet' && !quiet) return ''
   const label = GLYPH_LABEL[state]
   const inner = state === 'waiting' ? '<span class="sg-in" aria-hidden="true">!</span>' : state === 'offline' ? '<span class="sg-in" aria-hidden="true"></span><span class="sg-slash" aria-hidden="true"></span>' : '<span class="sg-in" aria-hidden="true"></span>'
   const c = 'sg sg-' + state + (state === 'quiet' && closed ? ' sg-closed' : '') + (state === 'unseen' && arrive != null ? ' sg-arrive' : '') + (cls ? ' ' + cls : '')
   const a11y = hidden ? ' aria-hidden="true"' : ' role="img" aria-label="' + esc(tip || label) + '"'
-  return '<span class="' + c + '" data-sg="' + state + '"' + a11y + ' data-tip="' + esc(tip || label) + '"' + (state === 'unseen' && arrive != null ? ' data-arrive="' + Math.round(Number(arrive) || 0) + '"' : '') + '>' + inner + '</span>'
+  return '<span class="' + c + '" data-sg="' + state + '"' + a11y + (noTip ? '' : ' data-tip="' + esc(tip || label) + '"') + (state === 'unseen' && arrive != null ? ' data-arrive="' + Math.round(Number(arrive) || 0) + '"' : '') + '>' + inner + '</span>'
 }
 
 // The words for a glyph in a control's own label (", waiting on you").

package/ui/slash-commands.js

@@ -0,0 +1,89 @@
+// Claude Code slash commands the board can send into a session (Live box).
+// Shared by the daemon (src/live-link.js: what it lets through) and the board
+// (ui/slash.js: the "/" suggestions and the /model and /effort pickers).
+//
+// Checked against Claude Code's own command table (2.1.300, the `claude -p`
+// build on npm; /model and /effort run again on 2.1.319): each of these has a non-interactive form (supportsNonInteractive),
+// so in a session Leftoff runs (`claude -p`, stream-json) "/effort high" written
+// as a user message runs as the command, locally, and its output comes back as
+// the turn's result and as a local_command line in the transcript. In a terminal
+// session the mod runs it with $.command.run, the way it already runs /rename,
+// except a command whose terminal form saves your default (saves, below).
+// Bare /model and /effort open a picker in the terminal, so the board asks for
+// the choice itself. /status and the bare pickers need Claude Code's terminal UI
+// and are left out; anything not listed here is refused.
+
+export const SLASH_MAX = 500
+
+// arg: 'required' | 'optional' | 'none'. choices: what the board's picker offers
+// (Claude Code's own list); strict: only those. tui: false when the terminal's
+// form opens a panel (so the mod path refuses it rather than leave a panel open).
+// saves: the terminal's form also writes it into ~/.claude/settings.json as your
+// default for new sessions (checked on 2.1.319: "Set model to Haiku 5.5 and saved
+// as your default for new sessions"; `claude -p` says "for this session only").
+// Leftoff never writes ~/.claude, so these go only to sessions Leftoff runs.
+export const SLASH_COMMANDS = [
+  { name: 'model', arg: 'required', hint: '<model>', what: 'Switch the model',
+    choices: ['default', 'opus', 'sonnet', 'haiku', 'fable', 'best', 'opus[1m]', 'sonnet[1m]', 'opusplan'], saves: true },
+  { name: 'effort', arg: 'required', hint: '<level>', what: 'Set how hard Claude thinks',
+    choices: ['low', 'medium', 'high', 'xhigh', 'max', 'auto'], strict: true, saves: true },
+  { name: 'compact', arg: 'optional', hint: '[instructions]', what: 'Summarize the conversation to free up context' },
+  { name: 'clear', arg: 'none', hint: '', what: 'Start over with empty context (the old one stays resumable)' },
+  { name: 'context', arg: 'none', hint: '', what: 'Show how full the context is' },
+  { name: 'usage', aliases: ['cost'], arg: 'none', hint: '', what: 'Show session cost and plan usage', tui: false },
+]
+
+const BY_NAME = new Map()
+for (const c of SLASH_COMMANDS) { BY_NAME.set(c.name, c); for (const a of c.aliases || []) BY_NAME.set(a, c) }
+
+export function slashCommand(name) { return BY_NAME.get(String(name || '').toLowerCase()) || null }
+export function isSlashText(text) { return /^\s*\//.test(String(text == null ? '' : text)) }
+export function slashNames() { return SLASH_COMMANDS.map((c) => '/' + c.name) }
+export function allowedText() { return slashNames().join(', ') }
+
+const MODEL_RE = /^[A-Za-z0-9][A-Za-z0-9._:\-[\]]{0,79}$/
+// eslint-disable-next-line no-control-regex
+const CONTROL_RE = /[\u0000-\u001f\u007f\u2028\u2029]/
+
+function bad(message) { const e = new Error(message); e.status = 400; e.code = 'bad_command'; throw e }
+
+// "/effort high" -> { name: 'effort', args: 'high', line: '/effort high', cmd }.
+// One command on one line; leading and trailing spaces are fine; the name is
+// the command's own (an alias becomes it: /cost -> /usage). Throws (400,
+// bad_command) with a message that says what is allowed.
+export function parseSlash(text) {
+  const raw = String(text == null ? '' : text)
+  const t = raw.replace(/^[ \t]+|[ \t]+$/g, '')
+  if (!t.startsWith('/')) bad('a command starts with “/”')
+  if (/[\r\n]/.test(t.trim())) bad('one command a message, on one line')
+  const s = t.trim()
+  if (CONTROL_RE.test(s)) bad('the command has a control character in it')
+  if (s.length > SLASH_MAX) bad('the command is over ' + SLASH_MAX + ' characters')
+  const m = /^\/([A-Za-z][\w-]*)(?:[ \t]+([\s\S]*))?$/.exec(s)
+  if (!m) bad('the board can send ' + allowedText())
+  const c = slashCommand(m[1])
+  if (!c) bad('/' + m[1] + ' can’t be sent from the board. It can send ' + allowedText())
+  const args = (m[2] || '').replace(/[ \t]+/g, ' ').trim()
+  if (c.arg === 'none' && args) bad('/' + c.name + ' takes nothing after it')
+  if (c.arg === 'required' && !args) bad('/' + c.name + ' needs a choice: ' + c.choices.join(', '))
+  if (args.startsWith('/')) bad('one command a message')
+  if (c.name === 'model' && !MODEL_RE.test(args)) bad('/model needs one model name, like ' + c.choices.slice(1, 4).join(', '))
+  if (c.strict && !c.choices.includes(args.toLowerCase())) bad('/' + c.name + ' takes one of ' + c.choices.join(', '))
+  const a = c.strict ? args.toLowerCase() : args
+  return { name: c.name, args: a, line: '/' + c.name + (a ? ' ' + a : ''), cmd: c }
+}
+
+// The "/" suggestions for what's typed so far ("/ef" -> [effort]).
+export function slashMatches(text) {
+  const m = /^\s*\/([\w-]*)$/.exec(String(text == null ? '' : text))
+  if (!m) return []
+  const q = m[1].toLowerCase()
+  return SLASH_COMMANDS.filter((c) => c.name.startsWith(q) || (c.aliases || []).some((a) => a.startsWith(q)))
+}
+
+// A bare "/model" or "/effort" (nothing after it): the board shows its picker.
+export function needsPicker(text) {
+  const m = /^\s*\/([\w-]+)\s*$/.exec(String(text == null ? '' : text))
+  const c = m && slashCommand(m[1])
+  return c && c.arg === 'required' && c.choices ? c : null
+}

package/ui/slash.js

@@ -0,0 +1,82 @@
+// The Live composer's "/" menu (slash commands from the board). Pure functions
+// here, shared with the unit tests; app.js wires them to the page. What can be
+// sent, and the words for it, is ui/slash-commands.js (the daemon checks it too).
+//
+// Typing "/" lists the commands ("/ef" narrows to /effort); picking one fills
+// it in. A command that takes a choice (/model, /effort) then lists its
+// choices ("/effort h" narrows to high). Picking never sends: Enter sends once
+// the menu has nothing more to offer (an exact command or choice closes it).
+// In a terminal session /model and /effort show, disabled, with why: Claude
+// Code's terminal saves them as your default for new sessions.
+
+import { slashCommand, slashMatches } from './slash-commands.js'
+
+const escS = (s) => String(s == null ? '' : s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;')
+
+export const SAVES_WHY = 'In a terminal session this also changes your default for new sessions, so the board doesn’t send it. Type it in the terminal.'
+
+// Where commands go for this session: 'headless' (Leftoff runs it: every
+// command, for this session only), 'terminal' (the mod runs it: not /model or
+// /effort), or null (Codex, or nothing to run it: no menu).
+export function slashTarget(s) {
+  if (!s || s.codingAgent === 'codex' || s.capture === 'codex' || s.endedAt) return null
+  if (s.headless) return 'headless'
+  if (s.capture === 'mod') return 'terminal'
+  return null
+}
+
+// text -> null (no menu) or { kind: 'commands' | 'choices', cmd?, items: [{ value, label, hint, what, off }] }.
+// value: the composer's text after a pick. off: why it can't be picked here (null when it can).
+export function slashMenu(text, { target = 'headless' } = {}) {
+  if (!target) return null
+  const t = String(text == null ? '' : text)
+  const offFor = (c) => (target === 'terminal' && c.saves ? SAVES_WHY : null)
+  const m = /^\s*\/([\w-]*)$/.exec(t)
+  if (m) {
+    const list = slashMatches(t)
+    if (!list.length) return null
+    // an exact command that takes nothing: the menu has nothing to add, Enter sends it
+    const exact = slashCommand(m[1])
+    if (exact && exact.arg === 'none' && list.length === 1 && (exact.name === m[1].toLowerCase() || (exact.aliases || []).includes(m[1].toLowerCase()))) return null
+    return { kind: 'commands', items: list.map((c) => ({ value: '/' + c.name + (c.arg === 'none' ? '' : ' '), label: '/' + c.name, hint: c.hint || '', what: c.what, off: offFor(c) })) }
+  }
+  const a = /^\s*\/([\w-]+)[ \t]+(\S*)$/.exec(t)
+  const c = a && slashCommand(a[1])
+  if (!c || !c.choices) return null
+  if (offFor(c)) return { kind: 'choices', cmd: c.name, items: [{ value: t, label: '/' + c.name, hint: '', what: c.what, off: offFor(c) }] }
+  const q = a[2].toLowerCase()
+  const items = c.choices.filter((x) => x.toLowerCase().startsWith(q))
+  if (!items.length || (items.length === 1 && items[0].toLowerCase() === q)) return null // nothing to pick, or already picked
+  return { kind: 'choices', cmd: c.name, items: items.map((x) => ({ value: '/' + c.name + ' ' + x, label: x, hint: '', what: '', off: null })) }
+}
+
+// The highlighted item after a key: ArrowDown / ArrowUp wrap, skipping disabled ones. -> index or -1
+export function slashMove(menu, active, key) {
+  const items = (menu && menu.items) || []
+  const ok = items.map((x, i) => (x.off ? -1 : i)).filter((i) => i >= 0)
+  if (!ok.length) return -1
+  const at = ok.indexOf(active)
+  if (key === 'ArrowDown') return ok[at < 0 ? 0 : (at + 1) % ok.length]
+  if (key === 'ArrowUp') return ok[at < 0 ? ok.length - 1 : (at - 1 + ok.length) % ok.length]
+  return at < 0 ? ok[0] : active
+}
+
+// What a key does with the menu open: 'move' | 'pick' | 'close' | null (the composer's own).
+export function slashKey(ev) {
+  if (!ev || ev.isComposing || ev.keyCode === 229) return null
+  if (ev.key === 'ArrowDown' || ev.key === 'ArrowUp') return ev.altKey || ev.metaKey || ev.ctrlKey ? null : 'move'
+  if ((ev.key === 'Enter' && !ev.shiftKey && !ev.metaKey && !ev.ctrlKey && !ev.altKey) || (ev.key === 'Tab' && !ev.shiftKey)) return 'pick'
+  if (ev.key === 'Escape') return 'close'
+  return null
+}
+
+// The listbox, above the composer. id: the listbox's id (the textarea's aria-controls);
+// each option's id is id + '-' + index (aria-activedescendant).
+export function slashMenuHtml(menu, { active = -1, id = 'slashMenu', esc = escS } = {}) {
+  if (!menu || !menu.items.length) return ''
+  const head = menu.kind === 'choices' ? '<div class="slash-h" aria-hidden="true">' + esc('/' + menu.cmd) + '</div>' : ''
+  return '<div class="slash-menu" role="listbox" id="' + esc(id) + '" aria-label="' + esc(menu.kind === 'choices' ? 'Choices for /' + menu.cmd : 'Commands') + '">' + head +
+    menu.items.map((x, i) => '<div class="slash-opt' + (x.off ? ' off' : '') + '" role="option" id="' + esc(id + '-' + i) + '" data-i="' + i + '" data-value="' + esc(x.value) + '" aria-selected="' + (i === active ? 'true' : 'false') + '"' + (x.off ? ' aria-disabled="true" data-tip="' + esc(x.off) + '"' : '') + '>' +
+      '<span class="slash-l">' + esc(x.label) + (x.hint ? ' <span class="slash-hint">' + esc(x.hint) + '</span>' : '') + '</span>' +
+      (x.what ? '<span class="slash-w">' + esc(x.off ? 'Not in a terminal session' : x.what) + '</span>' : '') + '</div>').join('') + '</div>'
+}

package/ui/tabs.js

@@ -222,6 +222,13 @@ export function stateMark(v, esc) {
 // 0.9.17 the walkthrough's Look-closely count: a small eye and a number, as quiet as the
 // status word (not a badge), only when there's something; the words in the tip.
 const EYE = '<svg class="ic" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true" focusable="false"><path d="M2 12s3.6-7 10-7 10 7 10 7-3.6 7-10 7S2 12 2 12z"/><circle cx="12" cy="12" r="3"/></svg>'
+// 0.9.18 the strip: a closable tab's shape sits in the ×'s place (the × shows on hover or focus),
+// so a busy strip keeps room for titles; the word is in the tab's tip and its label. A pinned tab
+// (no ×) and a touch screen (no hover) keep the shape beside the title. Shapes differ per state.
+export function slotMark(v, esc) {
+  const st = stateOf(v)
+  return st !== 'quiet' ? glyphHtml(st, { esc, hidden: true, noTip: true, cls: 'tab-sg tab-xsg' }) : ''
+}
 export function lookMark(v, esc) {
   const n = Number(v && v.look) || 0
   if (n <= 0) return ''
@@ -240,12 +247,12 @@ export function stripHtml(views, activeId, onBoard, esc) {
   const tabs = views.map((v) => {
     const on = v.id === activeId
     return '<div class="tab-cell' + (on ? ' on' : '') + (v.preview ? ' preview' : '') + (v.pinned ? ' pinned' : '') + '" data-tab-id="' + esc(v.id) + '">' +
-      '<a class="tab tab-s' + (on ? ' on' : '') + (v.preview ? ' preview' : '') + '" href="' + esc(v.href) + '" data-tab="' + esc(v.id) + '"' + (on ? ' aria-current="true"' : '') + ' data-tip="' + esc(v.title + (v.pinned ? ' · pinned' : '') + (v.preview ? ' · preview: double-click to keep it open' : '')) + '" aria-label="' + esc((v.pinned ? 'Pinned: ' : '') + label(v)) + '" aria-keyshortcuts="Alt+Shift+ArrowLeft Alt+Shift+ArrowRight" draggable="false">' +
-      (v.pinned ? PIN_GLYPH : '') + '<span class="tab-t">' + esc(v.title) + '</span>' + stateMark(v, esc) + lookMark(v, esc) + '</a>' +
+      '<a class="tab tab-s' + (on ? ' on' : '') + (v.preview ? ' preview' : '') + '" href="' + esc(v.href) + '" data-tab="' + esc(v.id) + '"' + (on ? ' aria-current="true"' : '') + ' data-tip="' + esc(v.title + (SHORT[stateOf(v)] ? ' · ' + SHORT[stateOf(v)] : '') + (v.pinned ? ' · pinned' : '') + (v.preview ? ' · preview: double-click to keep it open' : '')) + '" aria-label="' + esc((v.pinned ? 'Pinned: ' : '') + label(v)) + '" aria-keyshortcuts="Alt+Shift+ArrowLeft Alt+Shift+ArrowRight" draggable="false">' +
+      (v.pinned ? PIN_GLYPH : '') + '<span class="tab-t">' + esc(v.title) + '</span>' + '<span class="tab-st' + (v.pinned ? '' : ' tab-st-touch') + '">' + slotMark(v, esc) + '</span>' + lookMark(v, esc) + '</a>' +
       (v.preview
         ? '<button type="button" class="tab-x tab-keep" data-tab-keep="' + esc(v.id) + '" data-tip="Keep open" aria-label="' + esc('Keep ' + v.title + ' open') + '">' + PIN + '</button>'
         : '') +
-      (v.pinned ? '' : '<button type="button" class="tab-x" data-tab-close="' + esc(v.id) + '" data-tip="Close tab" aria-label="' + esc('Close ' + v.title) + '">' + X + '</button>') + // a pinned tab stays: Unpin is on its right-click
+      (v.pinned ? '' : '<button type="button" class="tab-x' + (slotMark(v, esc) ? ' has-st' : '') + '" data-tab-close="' + esc(v.id) + '" data-tip="Close tab" aria-label="' + esc('Close ' + v.title) + '">' + slotMark(v, esc) + X + '</button>') + // a pinned tab stays: Unpin is on its right-click
       '</div>'
   }).join('')
   // 0.9.16: + New session right after the open tabs

package/ui/viewport-fit.js

@@ -57,3 +57,17 @@ 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
+
+// 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
+// measured a keyboard's worth of lost height (lf-kb), and some keyboards (a third-party one coming up
+// late or in steps, or iOS shrinking the window along with the keyboard) never report that. Now the
+// sheet steps aside whenever a text box outside the sheet has focus, measured or not, and comes back
+// a beat after it lets go (so the tap that closed the keyboard lands where it was aimed, not on a
+// sheet sliding in under the finger). A text box inside the sheet keeps it.
+export const SHEET_BACK_AFTER_BLUR_MS = 400
+// typing: a text box has focus; inSheet: that box is in the sheet; blurredMs: ms since a text box outside the sheet let go (null: none lately)
+export function sheetAside({ typing = false, inSheet = false, blurredMs = null } = {}) {
+  if (typing) return !inSheet
+  return blurredMs != null && blurredMs >= 0 && blurredMs < SHEET_BACK_AFTER_BLUR_MS
+}