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

package/ui/live-view.js

@@ -326,7 +326,9 @@ export function entryHtml(m, { esc, ago, md, now = Date.now(), status = null, at
   const who = senderLabel(m)
   const title = m.from === 'you' ? senderTitle(m) : ''
   let body
+  const cmd = isCommandEntry(m)
   if (m.from === 'claude') body = '<div class="lv-text lv-md">' + (md ? md(m.text || '') : esc(m.text || '')) + '</div>'
+  else if (cmd) body = commandHtml(m, { esc })
   else if (m.from === 'you') {
     const a = messageAttachments(m)
     // 0.9.9 Queued: a long one folds to two lines; a tap opens it in place
@@ -352,6 +354,8 @@ export function entryHtml(m, { esc, ago, md, now = Date.now(), status = null, at
     // 0.9.11: Copy, once the reply is whole (none while it streams)
     const cp = m.done ? copyButtonHtml(m.text) : ''
     if (cp) foot += '<div class="msg-foot">' + cp + '</div>'
+  } else if (cmd && m.status && m.status.phase === 'replied') {
+    // ran: what it printed is the body's; nothing to add
   } else if (m.status && m.from === 'you' && isQueued(m.status)) {
     foot = queuedHtml(m, { esc, may })
   } else if (m.status) {
@@ -369,6 +373,16 @@ export function entryHtml(m, { esc, ago, md, now = Date.now(), status = null, at
   return '<li class="lv lv-' + esc(m.from) + (m.history ? ' lv-history' : '') + (queued ? ' lv-queued' : '') + '" data-key="' + esc(entryKey(m)) + '" data-sig="' + esc(sigHash(sig)) + '">' + head + body + foot + '</li>'
 }
 
+// A slash command sent from the board (ui/slash-commands.js; src/live-link.js sendCommand): the command
+// in mono, then what Claude Code printed, once the transcript shows it ran (settleCommands).
+export function isCommandEntry(m) { return !!m && m.from === 'you' && m.command === true }
+export function commandHtml(m, { esc }) {
+  const ran = !!(m.status && m.status.phase === 'replied')
+  const out = typeof m.out === 'string' ? m.out.trim() : ''
+  return '<div class="lv-text lv-cmd"><code>' + esc(m.text || '') + '</code></div>' +
+    (out ? '<pre class="lv-cmd-out">' + esc(out) + '</pre>' : ran ? '<div class="lv-cmd-out lv-cmd-done">Done</div>' : '')
+}
+
 // 0.9.15: an answer that is still the Stop hook's words, clipped by the mod (280 characters ending in "…")
 export function partialAnswer(m) { return !!(m && m.from === 'claude' && m.via === 'turn' && typeof m.text === 'string' && /…\s*$/.test(m.text)) }
 
@@ -565,7 +579,7 @@ export function threadHtml(msgs, opts) {
     // 0.9.14: Edit on the message; Retry on Claude's "stopped" card (or on the message, when it didn't arrive)
     const acts = m === tgt ? { retry: m.status.phase === 'failed', edit: true, busy } : null
     html += entryHtml(m, acts ? { ...opts, lvActs: acts } : opts)
-    if (m.status && !m.status.folded && !answered.has(m.id) && m.status.phase !== 'failed' && m.status.phase !== 'sent') {
+    if (m.status && !m.status.folded && !answered.has(m.id) && m.status.phase !== 'failed' && m.status.phase !== 'sent' && !isCommandEntry(m)) { // a command has no turn: what it printed is in its own bubble
       // the asks of this turn go before Claude's Working bubble: the answer that replaces it in place then lands after them, as on a fresh page
       html += upTo(next == null ? Infinity : next)
       html += pendingClaudeHtml(m, m === tgt ? { ...opts, lvActs: { retry: true, busy } } : opts)
@@ -664,7 +678,7 @@ export { ranWithoutAsking }
 // A content signature, to replace only the entries that changed (the time-ago
 // text is left out so a minute ticking over doesn't redraw a reply).
 function sigHash(s) { let h = 5381; for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) | 0; return (h >>> 0).toString(36) }
-export function entrySig(m) { return JSON.stringify([m.text, (m.attachments || []).map((a) => a.id), m.state, m.status && [m.status.phase, m.status.tool, m.status.waiting, (m.status.ran || []).length, m.status.endedAt, m.status.folded || null, !!m.status.queued, !!m.status.cancellable, !!m.status.sendNow], m.done, m.ranWithoutAsking, m.ranWhy || null, m.errorText, m.via === 'turn' ? 1 : 0]) }
+export function entrySig(m) { return JSON.stringify([m.text, m.out == null ? null : m.out, (m.attachments || []).map((a) => a.id), m.state, m.status && [m.status.phase, m.status.tool, m.status.waiting, (m.status.ran || []).length, m.status.endedAt, m.status.folded || null, !!m.status.queued, !!m.status.cancellable, !!m.status.sendNow], m.done, m.ranWithoutAsking, m.ranWhy || null, m.errorText, m.via === 'turn' ? 1 : 0]) }
 
 // ------------------------------------------------------------ the DOM keeper
 

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/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
+}