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

package/docs/SECURITY.md

@@ -94,7 +94,7 @@ A relayed request is replayed against the Mac's own board from inside the daemon
 
 When your hosted board is open on a Mac that runs Leftoff, the page sends the same sealed requests straight to that Mac's daemon at `http://127.0.0.1:7429/v1/relay/direct` instead of to the relay. Nothing new is trusted: the daemon opens them with the same per-device key (and the same replay and time checks), runs them the same way (a remote device, the rules above), and seals the answer. The page only switches after the daemon says it's on your account and a sealed round trip through it works, so another Leftoff on that port (someone else's account) can't serve your board: it can't open the request or forge the answer. The door is loopback only, never through a proxy, off when Use from anywhere is off, and answers CORS for exactly one origin, `https://<your name>.leftoff.dev` (with Chrome's Private Network Access header); any other page gets a 403 it can't read. If the direct path fails, the request goes through the relay once more and the board stays on the relay until a later check finds the direct path again.
 
-Since 0.9.7 the page also tries `https://leftoff.localhost/v1/relay/direct` (Leftoff's own Caddy from `leftoff setup`, bound to loopback; it rewrites Host, drops X-Forwarded-*, and passes the page's Origin through), since Safari won't let an https page call plain `http://127.0.0.1`. A request that came in through this door came from a browser on this Mac, from your own board's origin, sealed with a paired key, so it may also do the one thing only this Mac's own browser may do: **Restore** (`POST /v1/restore`, which opens Ghostty tabs here). The daemon marks such requests with a second in-memory secret that only the door sets; a sealed request can't carry it, and every other endpoint treats a direct request exactly like the relay (a paired remote device). Through the relay, from a phone or another Mac, Restore stays off.
+Since 0.9.7 the page also tries `https://leftoff.localhost/v1/relay/direct` (Leftoff's own Caddy from `leftoff setup`, bound to loopback, or since 0.9.18 another app's Caddy on port 443 that imports Leftoff's site file, which turns away any client not on loopback by its address; it rewrites Host, drops X-Forwarded-*, and passes the page's Origin through), since Safari won't let an https page call plain `http://127.0.0.1`. A request that came in through this door came from a browser on this Mac, from your own board's origin, sealed with a paired key, so it may also do the one thing only this Mac's own browser may do: **Restore** (`POST /v1/restore`, which opens Ghostty tabs here). The daemon marks such requests with a second in-memory secret that only the door sets; a sealed request can't carry it, and every other endpoint treats a direct request exactly like the relay (a paired remote device). Through the relay, from a phone or another Mac, Restore stays off.
 
 ### Live link (0.9.8 beta)
 

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

@@ -1,6 +1,6 @@
 {
   "name": "leftoff",
-  "version": "0.9.18-beta.10",
+  "version": "0.9.18-beta.11",
   "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

@@ -1397,7 +1397,7 @@ const CHECKPOINT_BASE = [
 const DECIDED_SECTION = [
   'Only if the transcript shows a decision (a choice between real alternatives that the developer made or approved, a plan they approved, a correction they gave such as "no, do X instead", or a trade-off the agent chose and said so), add after those lines a "Decided:" heading and one "- " line per decision, at most 4:',
   '- <what was decided, in the words the transcript uses> · why: <the reason given, one line> · over: <alternative>; <alternative> · from: <asked | plan | correction | agent>',
-  'A task done, a file edited or a routine step is not a decision. Never invent a choice or a reason the transcript does not show. When unsure, or when there is none, leave the Decided heading out entirely. Skip decisions listed as already recorded.',
+  'A task done, a file edited or a routine step is not a decision, and neither is a one-off choice about this task right now (who does a step, whether to commit, push or deploy now). Never invent a choice or a reason the transcript does not show. When unsure, or when there is none, leave the Decided heading out entirely. Skip decisions listed as already recorded.',
 ]
 const INFORMATIVE_SECTIONS = [
   'Then these sections, each a heading line followed by "- " bullets (write "- none" when there is nothing; never invent):',
@@ -1577,12 +1577,23 @@ function planHeadline(plan) {
   return h.replace(/^#{1,6}\s+/, '').replace(/^(?:plan|implementation plan)\s*[:\-–—]\s*/i, '').replace(/\*\*/g, '').trim()
 }
 
-// The decisions a transcript states outright, with no model: a question you
-// answered from its options (AskUserQuestion, the board's Needs you), its other
-// options as the alternatives; a plan you approved (ExitPlanMode). Messages are
-// src/transcript.js's shape, which is also $.session.messages()'s.
-export function decisionsFromMessages(messages) {
-  const out = []
+// 2026-11-05: a question about one task right now isn't a decision for the repo: who does it ("You update
+// it" / "I'll handle it"), or whether to go ahead with a commit, push, deploy and the like. Never recorded.
+const ACTOR_OPT = /^(?:you|i|i'll|i will|i'd|me|let me|we|we'll|leave it|someone)\b/i
+const NOW_Q = /\b(?:go ahead|proceed|right now|commit|push|merge|deploy|ship|publish|release|restart|open (?:a|the) pr|create (?:a|the) pr|who (?:should|will|does))\b/i
+const YESNO_OPT = /^(?:yes|no|y|n|ok|okay|sure|go ahead|do it|proceed|not now|later|skip|wait|stop|hold off|cancel|continue)\b/i
+export function isOneOffQuestion(q) {
+  const labels = (Array.isArray(q && q.options) ? q.options : []).map((o) => String((o && o.label) || o || '').replace(/\s*\(Recommended\)\s*/i, '').trim()).filter(Boolean)
+  if (labels.length < 2) return false
+  if (labels.every((l) => ACTOR_OPT.test(l))) return true
+  return NOW_Q.test(String((q && q.question) || '')) && labels.every((l) => YESNO_OPT.test(l))
+}
+
+// The transcript's own decisions, oldest first, and the answers it later changed:
+// a question asked again (same header, else the same question) and answered
+// differently keeps only the last answer; the earlier ones are `reversed` (texts).
+function readStated(messages) {
+  const out = [], at = new Map(), replaced = new Set()
   for (const m of messages || []) {
     if (!m || m.role !== 'assistant') continue
     for (const u of m.toolUses || []) {
@@ -1593,17 +1604,22 @@ export function decisionsFromMessages(messages) {
         const ans = questionAnswers(u.text, qs.map((q) => String(q.question)))
         for (const q of qs) {
           const a = ans[q.question]
-          if (!a) continue
+          if (!a || isOneOffQuestion(q)) continue
           const labels = q.options.map((o) => String((o && o.label) || o || '').trim()).filter(Boolean)
           const picked = labels.filter((l) => a === l || a.split(/\s*,\s*/).includes(l))
           const chosen = picked.length ? picked.join(', ') : a
           const opt = q.options.find((o) => o && o.label === picked[0])
-          out.push({
+          const d = {
             text: clip(String(q.header ? q.header + ': ' : '') + chosen.replace(/\s*\(Recommended\)\s*/i, ''), 240),
             why: opt && opt.description ? opt.description : '',
             alternatives: labels.filter((l) => !picked.includes(l)).map((l) => l.replace(/\s*\(Recommended\)\s*/i, '')),
             source: 'asked',
-          })
+          }
+          const topic = 'q:' + decisionNorm(q.header || q.question)
+          const was = at.get(topic)
+          if (was != null && decisionNorm(out[was].text) !== decisionNorm(d.text)) { replaced.add(out[was].text); out[was] = null }
+          if (was != null && out[was]) continue // the same answer again
+          at.set(topic, out.length); out.push(d)
         }
       }
       if (name === 'ExitPlanMode' && u.text && PLAN_OK.test(u.text)) {
@@ -1612,7 +1628,29 @@ export function decisionsFromMessages(messages) {
       }
     }
   }
-  return cleanDecided(out)
+  const found = out.filter(Boolean)
+  const kept = new Set(found.map((d) => decisionNorm(d.text)))
+  return { found, reversed: [...replaced].filter((t) => !kept.has(decisionNorm(t))) }
+}
+
+// The decisions a transcript states outright, with no model: a question you
+// answered from its options (AskUserQuestion, the board's Needs you), its other
+// options as the alternatives, only its last answer; a plan you approved
+// (ExitPlanMode). Messages are src/transcript.js's shape, which is also
+// $.session.messages()'s.
+export function decisionsFromMessages(messages) {
+  return cleanDecided(readStated(messages).found)
+}
+
+// 2026-11-05: what the log settles on its own (src/decisions.js settleStated): the stated decisions,
+// redacted as checkpoints save them, and the texts of answers changed later in the session.
+export function statedDecisions(messages, patterns = []) {
+  const red = (t) => redact(String(t || ''), patterns || [])
+  const { found, reversed } = readStated(messages)
+  return {
+    found: cleanDecided(found).map((d) => ({ ...d, text: red(d.text), why: red(d.why), alternatives: d.alternatives.map(red) })),
+    reversed: reversed.map((t) => red(clip(oneLine(t), 240))),
+  }
 }
 
 // The checkpoint's decisions: what the transcript states outright first, then the model's.
@@ -1910,7 +1948,7 @@ export const TITLE_LANGUAGE = 'Write it in the same language as the user\'s own
 export const TITLE_SYSTEM = 'Write a title of at most 6 words for a coding session, based on its first prompt. ' + TITLE_LANGUAGE + ' Reply with the title only, no quotes, no punctuation at the end.'
 
 export function cleanTitle(text) {
-  const t = String(text || '').replace(/<think>[\s\S]*?<\/think>/gi, '').split('\n').map((l) => l.trim()).find(Boolean) || ''
+  const t = stripChannel(String(text || '').replace(/<think>[\s\S]*?<\/think>/gi, '')).split('\n').map((l) => l.trim()).find(Boolean) || '' // 0.9.18: a model that echoes the Live wrapper
   return clip(t.replace(/^title\s*:\s*/i, '').replace(/^["'`*]+|["'`*.]+$/g, ''), 60)
 }
 

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.10' // keep in step with .claude-plugin/plugin.json
+const MOD_VERSION = '0.9.18-beta.11' // keep in step with .claude-plugin/plugin.json
 
 const st = {
   internal: false,
@@ -1107,14 +1107,22 @@ function startReplyLoop($) {
     let backoff = 0
     while (st.replyLoop && st.sessionId) {
       const sid = st.sessionId
-      const r = await api($, 'GET', '/v1/sessions/' + encodeURIComponent(sid) + '/replies/next?ms=' + ASK_POLL_MS, undefined, ASK_POLL_MS + 5000)
+      const r = await api($, 'GET', '/v1/sessions/' + encodeURIComponent(sid) + '/replies/next?cmds=1&ms=' + ASK_POLL_MS, undefined, ASK_POLL_MS + 5000)
       if (!r || !r.ok) {
         // Daemon down: try again on the heartbeat rather than spinning.
         st.replyLoop = false
         return
       }
       const reply = r.json && r.json.reply
-      if (reply && reply.text && !String(reply.text).startsWith('/') && sid === st.sessionId) {
+      // a slash command from the board (the daemon checked it against its list):
+      // Claude Code runs it as if typed, queued behind a running turn (as /rename)
+      if (reply && reply.command && typeof reply.command.name === 'string' && /^[a-z][\w-]{0,30}$/.test(reply.command.name) && sid === st.sessionId) {
+        try {
+          await $.command.run({ command: reply.command.name, args: String(reply.command.args || '').replace(/[\r\n]+/g, ' ').slice(0, 500) })
+        } catch (err) {
+          try { $.ui.toast('Leftoff: couldn’t run the board’s /' + reply.command.name + ': ' + String((err && err.message) || err).slice(0, 120)) } catch {}
+        }
+      } else if (reply && reply.text && !String(reply.text).startsWith('/') && sid === st.sessionId) {
         try {
           await $.prompt.submit({ text: String(reply.text) })
         } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leftoff/cli",
-  "version": "0.9.18-beta.10",
+  "version": "0.9.18-beta.11",
   "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

@@ -2491,6 +2491,20 @@ mark.tx, .co-snip mark, .tx-snip mark, .tx-msg-text mark { background: var(--tx-
 
 /* 0.9.8 attachments: a paperclip beside ↑, chips above the words inside the box, thumbnails in your bubble */
 .composer { flex-wrap: wrap; }
+/* "/" commands (ui/slash.js): a list above the composer; options 44px tall */
+.composer .slash-menu { position: absolute; left: 0; right: 0; bottom: calc(100% + 6px); z-index: 30; max-height: min(320px, 50vh); overflow-y: auto; overscroll-behavior: contain; padding: 4px; border: 1px solid var(--line-strong); border-radius: 14px; background: var(--card); box-shadow: 0 8px 24px rgba(0,0,0,.22); cursor: default; }
+.slash-h { padding: 6px 10px 2px; font: 600 11.5px/1.4 var(--mono); color: var(--muted); }
+.slash-opt { display: flex; align-items: baseline; gap: 10px; min-height: 44px; box-sizing: border-box; padding: 11px 10px; border-radius: 10px; cursor: pointer; }
+.slash-opt[aria-selected="true"] { background: var(--bg2); }
+@media (hover: hover) { .slash-opt:hover { background: var(--bg2); } }
+.slash-opt.off { cursor: not-allowed; opacity: .6; }
+.slash-l { flex: none; font: 500 13.5px/1.5 var(--mono); color: var(--text); }
+.slash-hint { color: var(--muted); font-weight: 400; }
+.slash-w { min-width: 0; font-size: 13px; line-height: 1.5; color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+/* a slash command's bubble: the command in mono, then what Claude Code printed */
+.lv-cmd code { font-size: 13.5px; background: none; border: 0; padding: 0; }
+.lv-cmd-out { margin: 6px 0 0; padding: 0; font: 12.5px/1.5 var(--mono); color: var(--text2); white-space: pre-wrap; overflow-wrap: anywhere; background: none; border: 0; max-height: 240px; overflow-y: auto; }
+.lv-cmd-done { font-family: inherit; color: var(--muted); }
 .composer .att-chips { flex: 0 0 100%; order: -1; display: flex; flex-wrap: wrap; gap: 6px; padding: 8px 8px 2px 0; margin-left: -6px; }
 .composer .att-chips[hidden] { display: none; }
 .composer.att-drop { border-color: var(--accent); box-shadow: 0 0 0 3px var(--focus); background: color-mix(in srgb, var(--accent) 7%, var(--card2)); }
@@ -2842,7 +2856,18 @@ mark.tx, .co-snip mark, .tx-snip mark, .tx-msg-text mark { background: var(--tx-
   .tab:hover { color: var(--text); }
   .tab:focus-visible, .tab-x:focus-visible, .tab-all:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; }
   .tab-board { flex: none; border-right: 1px solid var(--line); }
-  .tab-cell { position: relative; flex: 0 1 200px; min-width: 120px; display: flex; align-items: stretch; border-right: 1px solid var(--line); }
+  .tab-cell { position: relative; flex: 0 1 200px; min-width: 140px; display: flex; align-items: stretch; border-right: 1px solid var(--line); }
+  /* 0.9.18 a busy strip: the tab you're on keeps its full width (only the others shrink), the rest
+     keep 140px and the strip scrolls with a fade at the edge that has more (ui/chip-fade.js);
+     a pinned tab is its pin and its status shape, the name in its tip and label. */
+  .tab-cell.on { flex-shrink: 0; }
+  .tab-cell.pinned { flex: none; min-width: 0; }
+  .tab-cell.pinned .tab-s { padding-right: 12px; }
+  .tab-cell.pinned .tab-t { display: none; }
+  .tab-cell.pinned .tab-pin { margin-right: 0; }
+  #tabStrip .tab-scroll.fade-r { -webkit-mask-image: linear-gradient(to right, #000 calc(100% - 32px), transparent); mask-image: linear-gradient(to right, #000 calc(100% - 32px), transparent); }
+  #tabStrip .tab-scroll.fade-l { -webkit-mask-image: linear-gradient(to left, #000 calc(100% - 32px), transparent); mask-image: linear-gradient(to left, #000 calc(100% - 32px), transparent); }
+  #tabStrip .tab-scroll.fade-l.fade-r { -webkit-mask-image: linear-gradient(to right, transparent, #000 32px, #000 calc(100% - 32px), transparent); mask-image: linear-gradient(to right, transparent, #000 32px, #000 calc(100% - 32px), transparent); }
   .tab-s { flex: 1; min-width: 0; padding-right: 0; }
   .tab.on, .tab-cell.on { color: var(--text); background: var(--card); }
   .tab-board.on, .tab-cell.on { box-shadow: inset 0 -2px 0 var(--accent); }
@@ -4518,15 +4543,32 @@ html:not(.live-full) .fs-side { 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); }
+  /* 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); }
+  /* the sheet follows a finger (app.js); its peek is the handle, its content scrolls natively */
+  .fs-side.dragging { transition: none; }
+  .fs-peek { touch-action: none; }
 }
 @media (prefers-reduced-motion: reduce) { .fs-side { transition: none; } }
 /* the tab strip: pinned tabs at the left (a pin), each tab's status as a shape AND a word, + New session */
-.tab-cell.pinned .tab-t { max-width: 10em; }
 .tab-pin { display: inline-flex; flex: none; margin-right: 5px; color: var(--text2); }
 .tab-pin .ic { width: 12px; height: 12px; }
 .lf-tab .tab-pin { margin-right: 2px; }
 .tab-st { display: inline-flex; align-items: center; gap: 3px; flex: none; margin-left: 6px; }
 .tab-w { font-size: 11.5px; font-weight: 550; color: var(--text2); white-space: nowrap; }
+/* 0.9.18 the strip: a closable tab's shape sits in the ×'s place; the × on hover or keyboard focus.
+   A pinned tab and a touch screen (no hover) keep the shape beside the title. */
+.tab-st:empty, .tab-st-touch { display: none; }
+.tab-x .tab-xsg { position: absolute; left: 50%; top: 50%; margin: -7px 0 0 -7px; }
+.tab-x.has-st .ic { opacity: 0; }
+.tab-cell:hover .tab-x.has-st .ic, .tab-x.has-st:focus-visible .ic { opacity: 1; }
+.tab-cell:hover .tab-x .tab-xsg, .tab-x:focus-visible .tab-xsg { visibility: hidden; }
+@media (hover: none), (pointer: coarse) {
+  .tab-st-touch:not(:empty) { display: inline-flex; }
+  .tab-x .tab-xsg { display: none; }
+  .tab-x.has-st .ic { opacity: 1; }
+}
 .tab-new { flex: none; display: inline-flex; align-items: center; justify-content: center; width: 44px; color: var(--text2); border-radius: 8px; }
 .tab-new .ic { width: 16px; height: 16px; }
 @media (hover: hover) { .tab-new:hover { color: var(--text); background: var(--card2); } }
@@ -5470,6 +5512,7 @@ a.dec-rc:hover .dec-rc-w { text-decoration: underline; }
 .dec-row-h .dec-st { margin-left: 0; font-size: 11.5px; color: var(--text); }
 .dec-row-h .dec-id { font: 500 11px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace; color: var(--text2); opacity: .85; }
 .dec-row-h .dec-src { margin-top: 0; font-size: 11.5px; }
+.dec-auto { font-size: 11.5px; color: var(--text2); }
 .dec-dot { color: var(--text2); opacity: .6; }
 .dec-list .dec-text { font-size: 14px; font-weight: 500; line-height: 1.4; margin-top: 2px; overflow-wrap: anywhere; }
 .dec-row-rejected .dec-text { text-decoration: line-through; text-decoration-thickness: 1px; color: var(--text2); }

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, 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, 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 { 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
@@ -54,7 +54,7 @@ import { anyPending, shouldPoll, streamDead, isStale, liveSignature, wakeReason,
 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'
-import { fsSideHtml, createSideStore, railHtml, createWidthStore, clampSideWidth, sideMax, SIDE_W_STEP, SIDE_W_DEFAULT, WIDE_MIN } from './fs-side.js'
+import { fsSideHtml, createSideStore, railHtml, createWidthStore, clampSideWidth, sideMax, SIDE_W_STEP, SIDE_W_DEFAULT, WIDE_MIN, sheetDragStart, sheetDragOffset, sheetDragFlips } from './fs-side.js'
 import { fileReach, gateFileRefs } from './file-reach.js' // 2026-10-29 a path links only when its file can be read
 import { createFoldStore, foldHtml, relPath, rootsOf, filesTouchedHtml, dropJunkCps, statusStripHtml, answeredHtml, whereWords } from './side-fold.js' // 2026-10-29 a calmer session panel
 import { walkthroughHtml, hydrateWalkthrough, fmToggle, eyeCountHtml, reviewedSet, stepAfter, visibleSteps, stepPos, toMarkdown, toHtmlDoc, exportName, revNextState, revNextLabel, REVNEXT_TIP, REVFINISH_TIP, sfState, sfSet, patchFor, readingOrder, uniqueStepIds, SPLIT_MIN, RAIL_MIN as WT_SIDE_MIN, RAIL_MAX as WT_SIDE_MAX, RAIL_DEFAULT as WT_SIDE_DEFAULT, fileScopeStore, scopeAskLine } from './semdiff.js' // 0.9.17 Walk me through it
@@ -62,6 +62,7 @@ import { rowsOf, pickLine, dragTo, describePicks, refsPrompt } from './walk-line
 import { spotsFor, nextSpotIndex, spotCountWords } from './walk-spots.js' // 2026-10-30 Next spot
 import { walkButtonHtml, sizeLineHtml, popContent, initPops } from './walk-pop.js' // 0.9.18 Walk me through it's size line and popover
 import { lastReply, ghostShows } from './ghost.js'
+import { slashTarget, slashMenu, slashMove, slashKey, slashMenuHtml } from './slash.js' // slash commands from the board
 import { digestHeadline, todayHidden, hideToday, todayCardHtml } from './today.js' // 0.9.16 the board's Today card // 0.9.16 the suggested next message // 0.9.16 the session panel beside full screen
 import { machinesListHtml, pendingCardsHtml, machineDialogHtml, stateOf as machineStateOf } from './machine-life.js' // 0.9.16 rename, re-pair, retire, merge
 import { reorderable, reordering } from './reorder.js' // 0.9.16 drag tabs to reorder // 0.9.8 tabs for sessions
@@ -3406,10 +3407,64 @@ document.addEventListener('scroll', (e) => {
   const el = e.target
   if (!el || !el.classList || !el.classList.contains('fs-side-in')) return
   const side = el.closest('.fs-side')
+  // 2026-11-06 not on a phone's sheet: there the head isn't pinned, so slimming it as you scroll moved the
+  // content under your finger by the head's change in height, which flipped it back (the sheet jumped)
+  if (sheetMq.matches) { if (side && side.classList.contains('is-scrolled')) side.classList.remove('is-scrolled'); fsScrolled = null; return }
   fsScrolled = side && el.scrollTop > 8 ? side.dataset.sid : null
   if (side) side.classList.toggle('is-scrolled', !!fsScrolled)
 }, true)
 
+// 2026-11-06 the phone's sheet follows a finger (ui/fs-side.js sheetDragStart): drag the peek up to
+// raise it, drag the raised sheet down from its peek, or from its content scrolled to the top, to lower
+// it. Anything else is the content's own native scroll, untouched.
+const sheetMq = window.matchMedia('(max-width: 600px)')
+{
+  let d = null
+  const travel = (side) => Math.max(0, side.getBoundingClientRect().height - (side.querySelector('.fs-peek') || side).getBoundingClientRect().height)
+  document.addEventListener('touchstart', (e) => {
+    d = null
+    if (!sheetMq.matches || e.touches.length !== 1) return
+    const side = e.target.closest && e.target.closest('#fsSide')
+    if (!side || side.classList.contains('collapsed') || !document.documentElement.classList.contains('live-full')) return
+    const fromPeek = !!e.target.closest('.fs-peek')
+    const inner = side.querySelector('.fs-side-in')
+    if (!fromPeek && e.target.closest('input, textarea, select, [contenteditable], pre, table, .scroll-x')) return
+    // a scroller of its own inside the content (a long list) that's scrolled: that's a scroll
+    for (let n = e.target; n && n !== inner && n !== side; n = n.parentElement) if (n.scrollTop > 0) return
+    const p = e.touches[0]
+    d = { side, x: p.clientX, y: p.clientY, at: Date.now(), up: side.classList.contains('sheet-up'), fromPeek, scrollTop: inner ? inner.scrollTop : 0, mode: null, travel: 0 }
+  }, { passive: true })
+  document.addEventListener('touchmove', (e) => {
+    if (!d || e.touches.length !== 1) return
+    const p = e.touches[0], dy = p.clientY - d.y, dx = p.clientX - d.x
+    if (!d.mode) {
+      d.mode = sheetDragStart({ up: d.up, fromPeek: d.fromPeek, scrollTop: d.scrollTop, dy, dx })
+      if (!d.mode) return
+      if (d.mode === 'scroll') { d = null; return } // the content's own scroll from here on
+      d.travel = travel(d.side)
+      d.side.classList.add('dragging')
+    }
+    if (e.cancelable) e.preventDefault() // the sheet moves, not the content's rubber band
+    const off = sheetDragOffset({ up: d.up, dy, travel: d.travel })
+    d.side.style.transform = 'translateY(' + ((d.up ? 0 : d.travel) + off) + 'px)'
+  }, { passive: false })
+  const end = (e, cancel) => {
+    const g = d
+    d = null
+    if (!g || g.mode !== 'drag') return
+    g.side.classList.remove('dragging')
+    g.side.style.transform = ''
+    const p = e.changedTouches && e.changedTouches[0]
+    if (cancel || !p) return
+    if (sheetDragFlips({ up: g.up, dy: p.clientY - g.y, ms: Date.now() - g.at })) {
+      toggleFsSheet()
+      sheetUi.ignoreClick = Date.now() // the click iOS sends after the drag isn't a tap on the peek
+    }
+  }
+  document.addEventListener('touchend', (e) => end(e, false), { passive: true })
+  document.addEventListener('touchcancel', (e) => end(e, true), { passive: true })
+}
+const sheetUi = { ignoreClick: 0 }
 function toggleFsSheet() {
   const side = document.getElementById('fsSide')
   if (!side) return
@@ -3464,10 +3519,19 @@ 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 } // scroll: window.scrollY as a text box took focus (iOS may scroll the page under the keyboard)
+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
+// 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
+  const typing = isTypingTarget(a)
+  const inSheet = !!(typing && a.closest && a.closest('#fsSide'))
+  const aside = html.classList.contains('live-full') && sheetAside({ typing, inSheet, blurredMs: lfKb.blurAt ? Date.now() - lfKb.blurAt : null })
+  html.classList.toggle('lf-typing', aside)
+}
 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 }
   // 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')
@@ -3520,6 +3584,8 @@ document.addEventListener('visibilitychange', () => { if (document.visibilitySta
 document.addEventListener('focusin', (e) => {
   if (!isTypingTarget(e.target) || !document.documentElement.classList.contains('live-full')) return
   if (lfKb.scroll == null) lfKb.scroll = window.scrollY
+  clearTimeout(lfKb.back); lfKb.blurAt = 0
+  fitSheetAside() // the sheet steps aside the moment the box takes focus, before the keyboard has said anything
   // 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)
@@ -3529,6 +3595,11 @@ document.addEventListener('focusin', (e) => {
 document.addEventListener('focusout', (e) => {
   if (!isTypingTarget(e.target) || !document.documentElement.classList.contains('live-full')) return
   clearTimeout(lfKb.settle)
+  if (!(e.target.closest && e.target.closest('#fsSide'))) { // the sheet comes back a beat after the box lets go
+    lfKb.blurAt = Date.now()
+    clearTimeout(lfKb.back)
+    lfKb.back = setTimeout(() => { lfKb.blurAt = 0; fitSheetAside() }, SHEET_BACK_AFTER_BLUR_MS)
+  }
   let i = 0
   const step = () => {
     fitFullViewport()
@@ -4011,6 +4082,7 @@ document.addEventListener('pointerdown', (ev) => { const a = document.activeElem
 function liveAfterRender(sid) {
   for (const ta of $app.querySelectorAll('.composer-input')) fitComposer(ta)
   bangAfterRender()
+  slashAfterRender()
   const r = liveKeeper.after($app)
   hydrateAttThumbs(); barWidths($app)
   fullAfterRender(sid)
@@ -4434,6 +4506,91 @@ function bangAfterRender() {
     if (w && w.text === ta.value) { const row = box.querySelector('.composer-mode'); if (row && !row.classList.contains('why')) { row.hidden = false; row.classList.add('why'); const t = row.querySelector('.composer-mode-t'); if (t) t.textContent = 'Not run: ' + w.why } }
   }
 }
+// ------------------------------------------------------------ "/" commands (ui/slash.js, ui/slash-commands.js)
+// The menu lives in the Live composer's box, drawn from the text: a repaint draws it again (slashAfterRender).
+const slashUi = { active: -1, closedFor: null } // closedFor: the text Esc closed it on (it stays closed until the text changes)
+function slashFor(ta) {
+  const box = ta && ta.closest('.live-box .composer')
+  if (!box || ta.disabled) return null
+  if (slashUi.closedFor != null && slashUi.closedFor === ta.value) return null
+  return slashMenu(ta.value, { target: slashTarget(wtSession(box.dataset.sid)) })
+}
+function paintSlash(ta, { keep = false } = {}) {
+  const box = ta && ta.closest('.composer')
+  if (!box) return null
+  const menu = slashFor(ta)
+  let el = box.querySelector('.slash-menu')
+  if (!menu) {
+    if (el) el.remove()
+    box.classList.remove('has-slash'); ta.removeAttribute('aria-activedescendant'); ta.setAttribute('aria-expanded', 'false')
+    slashUi.active = -1
+    return null
+  }
+  if (!keep || slashUi.active >= menu.items.length || (menu.items[slashUi.active] || {}).off) slashUi.active = slashMove(menu, -1, 'first')
+  const id = 'slashMenu-' + box.dataset.sid
+  const html = slashMenuHtml(menu, { active: slashUi.active, id, esc })
+  if (el) el.outerHTML = html; else box.insertAdjacentHTML('afterbegin', html)
+  box.classList.add('has-slash')
+  ta.setAttribute('aria-controls', id); ta.setAttribute('aria-expanded', 'true')
+  if (slashUi.active >= 0) ta.setAttribute('aria-activedescendant', id + '-' + slashUi.active); else ta.removeAttribute('aria-activedescendant')
+  const on = box.querySelector('.slash-opt[aria-selected="true"]')
+  if (on && on.scrollIntoView) on.scrollIntoView({ block: 'nearest' })
+  return menu
+}
+function pickSlash(ta, value) {
+  ta.value = value
+  try { ta.setSelectionRange(value.length, value.length) } catch {}
+  ta.dispatchEvent(new Event('input', { bubbles: true })) // the draft, the size, the send button, and the next menu
+  ta.focus({ preventScroll: true })
+}
+document.addEventListener('input', (ev) => {
+  const ta = ev.target
+  if (!ta || !ta.classList || !ta.classList.contains('composer-input') || !ta.closest('.live-box')) return
+  if (slashUi.closedFor != null && slashUi.closedFor !== ta.value) slashUi.closedFor = null
+  paintSlash(ta)
+})
+// before the composer's own Enter (send) and Esc: with the menu open, the keys are the menu's
+window.addEventListener('keydown', (ev) => {
+  const ta = ev.target
+  if (ev.defaultPrevented || !ta || !ta.classList || !ta.classList.contains('composer-input')) return
+  const box = ta.closest('.live-box .composer')
+  if (!box || !box.querySelector('.slash-menu')) return
+  const k = slashKey(ev)
+  if (!k) return
+  const menu = slashFor(ta)
+  if (!menu) return
+  ev.preventDefault(); ev.stopPropagation()
+  if (k === 'move') { slashUi.active = slashMove(menu, slashUi.active, ev.key); paintSlash(ta, { keep: true }); return }
+  if (k === 'close') { slashUi.closedFor = ta.value; paintSlash(ta); return }
+  const it = menu.items[slashUi.active]
+  if (it && !it.off) pickSlash(ta, it.value)
+}, true)
+// a click or a tap picks; the textarea keeps focus (and a phone its keyboard). WebKit sends no click
+// for a tap here, so a tap picks on touchend (a drag that scrolls the list doesn't)
+function pickSlashOpt(o) {
+  if (!o || o.getAttribute('aria-disabled') === 'true') return false
+  const ta = o.closest('.composer') && o.closest('.composer').querySelector('.composer-input')
+  if (ta) pickSlash(ta, o.dataset.value)
+  return !!ta
+}
+let slashTap = null
+document.addEventListener('mousedown', (ev) => { if (ev.target && ev.target.closest && ev.target.closest('.slash-opt')) ev.preventDefault() })
+document.addEventListener('click', (ev) => { pickSlashOpt(ev.target && ev.target.closest && ev.target.closest('.slash-opt')) })
+document.addEventListener('touchstart', (ev) => {
+  const o = ev.target && ev.target.closest && ev.target.closest('.slash-opt')
+  slashTap = o && ev.touches.length === 1 ? { o, x: ev.touches[0].clientX, y: ev.touches[0].clientY } : null
+}, { passive: true })
+document.addEventListener('touchend', (ev) => {
+  const t = slashTap
+  slashTap = null
+  const p = ev.changedTouches && ev.changedTouches[0]
+  if (!t || !p || Math.abs(p.clientX - t.x) > 10 || Math.abs(p.clientY - t.y) > 10) return
+  if (pickSlashOpt(t.o)) ev.preventDefault() // no click after it, and the keyboard stays
+}, { passive: false })
+function slashAfterRender() {
+  const ta = document.activeElement
+  if (ta && ta.classList && ta.classList.contains('composer-input') && ta.closest('.live-box')) paintSlash(ta, { keep: true })
+}
 async function liveSendClick(btn) {
   const box = btn.closest('.live-box')
   const ta = box && box.querySelector('.live-text')
@@ -8932,7 +9089,7 @@ document.addEventListener('click', async (ev) => {
     // 0.9.16 the session panel (ui/fs-side.js)
     if (action === 'fs-side') return toggleFsSide()
     if (action === 'fs-rail') return fsRailGo(btn.dataset.go)
-    if (action === 'fs-sheet') return toggleFsSheet()
+    if (action === 'fs-sheet') { if (Date.now() - sheetUi.ignoreClick < 500) return; return toggleFsSheet() }
     if (action === 'fs-timeline') { location.hash = '#/timeline?session=' + encodeURIComponent(id); return }
     if (action === 'tab-pin') return togglePin(id)
     // 0.9.17 Walk me through it

package/ui/chip-fade.js

@@ -18,7 +18,7 @@ export function paintFade(track) {
   return s
 }
 
-const SEL = '.repos .track'
+const SEL = '.repos .track, #tabStrip .tab-scroll' // 0.9.18: the tab strip fades where tabs run off too
 // Keeps every chip row's fade right: on first paint (any re-render adds new
 // tracks), on its own scroll, and when its width or its chips' widths change.
 export function watchChipFades(doc = document) {

package/ui/decisions.js

@@ -10,6 +10,15 @@ export const SOURCE_WORDS = { asked: 'You answered', plan: 'Plan approved', corr
 export const STATUS_SHAPE = { proposed: '◌', accepted: '●', rejected: '✕', superseded: '↻' }
 export const STATUS_WORD = { proposed: 'Proposed', accepted: 'Accepted', rejected: 'Rejected', superseded: 'Superseded' }
 
+// 2026-11-05: a status Leftoff set on its own (statusAuto), in words beside the source, and why in the tip.
+export const AUTO_WORDS = { asked: 'automatically', plan: 'automatically', reversed: 'you changed it later' }
+export const AUTO_TIPS = {
+  asked: 'Accepted on its own: you picked this answer in the session. Reject keeps it out of new sessions.',
+  plan: 'Accepted on its own: you approved this plan in the session. Reject keeps it out of new sessions.',
+  reversed: 'Rejected on its own: later in the session you answered the same question differently.',
+}
+const autoOf = (d) => (d && ((d.status === 'accepted' && (d.statusAuto === 'asked' || d.statusAuto === 'plan')) || (d.status === 'rejected' && d.statusAuto === 'reversed')) ? d.statusAuto : null)
+const autoBit = (d, esc) => { const a = autoOf(d); return a ? '<span class="dec-auto" data-tip="' + esc(AUTO_TIPS[a]) + '">' + esc(AUTO_WORDS[a]) + '</span>' : '' }
 const normD = (t) => String(t || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim()
 const byNewest = (a, b) => String(b.createdAt || '').localeCompare(String(a.createdAt || ''))
 
@@ -61,11 +70,12 @@ export function decidedListHtml(decided, { esc = escD, log = null, repoId = null
     const rp = (hit && (hit.repo || repoId)) || ''
     const btn = (act, label, cls) => '<button type="button" class="btn' + cls + '" data-action="dec-act" data-act="' + act + '" data-id="' + esc(hit.id) + '" data-repo="' + esc(rp) + '"' + offAttrs(trusted, esc) + '>' + label + '</button>'
     const acts = !readOnly && hit && hit.status === 'proposed' && may ? '<div class="dec-acts dec-acts-panel">' + btn('accept', 'Accept', ' primary') + btn('reject', 'Reject', '') +
-      '<button type="button" class="btn" data-action="dec-edit" data-id="' + esc(hit.id) + '" data-repo="' + esc(rp) + '"' + offAttrs(trusted, esc) + '>Edit</button></div>' : ''
+      '<button type="button" class="btn" data-action="dec-edit" data-id="' + esc(hit.id) + '" data-repo="' + esc(rp) + '"' + offAttrs(trusted, esc) + '>Edit</button></div>'
+      : !readOnly && hit && may && autoOf(hit) && hit.status === 'accepted' ? '<div class="dec-acts dec-acts-panel dec-acts-quiet">' + btn('reject', 'Reject', '') + '</div>' : ''
     const why = (hit && hit.why) || d.why, alts = (hit && hit.alternatives && hit.alternatives.length ? hit.alternatives : d.alternatives) || []
     // a quiet line first (status · id · where it came from), then the decision in words, then why / over
     const src = '<span class="dec-src">' + esc(SOURCE_WORDS[(hit && hit.source) || d.source] || SOURCE_WORDS.agent) + '</span>'
-    const head = [st, hit ? '<span class="dec-id">' + esc(hit.id) + '</span>' : '', src].filter(Boolean).join('<span class="dec-dot" aria-hidden="true"> · </span>')
+    const head = [st, hit ? '<span class="dec-id">' + esc(hit.id) + '</span>' : '', src, autoBit(hit, esc)].filter(Boolean).join('<span class="dec-dot" aria-hidden="true"> · </span>')
     return '<li class="dec-row' + (hit ? ' dec-row-' + esc(hit.status) : '') + '"' + (hit && !readOnly ? ' id="decp-' + esc(hit.id) + '"' : '') + '><div class="dec-row-h">' + head + '</div>' +
       '<div class="dec-text">' + esc(hit && (hit.edited || d.entry) ? hit.text : d.text) + '</div>' +
       (why ? '<div class="dec-why">' + esc(why) + '</div>' : '') +
@@ -155,13 +165,13 @@ export function decisionItemHtml(d, { esc = escD, byId = new Map(), may = true,
   const editBtn = (cls) => edit ? '<button type="button" class="' + cls + '" data-action="dec-edit" data-id="' + esc(d.id) + '" data-repo="' + esc(d.repo) + '"' + offAttrs(trusted, esc) + '>Edit</button>' : ''
   const link = replaces && !(d.supersedes || []).includes(replaces) ? '<button type="button" class="btn" data-action="dec-link" data-id="' + esc(d.id) + '" data-to="' + esc(replaces) + '" data-repo="' + esc(d.repo) + '"' + offAttrs(trusted, esc) + '>Confirm it replaces ' + esc(replaces) + '</button>' : ''
   const acts = !may && !link ? '' : !may ? '<div class="dec-acts">' + link + '</div>' : review ? '<div class="dec-acts">' + btn('accept', 'Accept', ' primary') + btn('reject', 'Reject') + editBtn('btn') + link + '</div>'
-    : '<div class="dec-acts dec-acts-quiet">' + (d.status === 'rejected' ? btn('reopen', 'Review again') : editBtn('linkish')) + link + '</div>'
+    : '<div class="dec-acts dec-acts-quiet">' + (d.status === 'rejected' ? btn('reopen', 'Review again') : (autoOf(d) && d.status === 'accepted' ? btn('reject', 'Reject') : '') + editBtn('linkish')) + link + '</div>'
   return '<li class="dec-item dec-' + esc(d.status) + '" id="dec-' + esc(d.id) + '">' + head +
     '<div class="dec-text">' + esc(d.text) + (d.edited ? ' <span class="faint" data-tip="' + esc('Edited · was: ' + ((d.original && d.original.text) || '')) + '">(edited)</span>' : '') + '</div>' +
     (d.why ? '<div class="dec-why">' + esc(d.why) + '</div>' : '') +
     (d.alternatives && d.alternatives.length ? '<div class="dec-alt">Over: ' + d.alternatives.map(esc).join(' · ') + '</div>' : '') +
     chainBit(d, byId, esc) + sug +
-    '<div class="dec-meta"><span class="dec-src">' + esc(SOURCE_WORDS[d.source] || SOURCE_WORDS.agent) + '</span>' + (sessionBit(d, esc) ? ' · ' + sessionBit(d, esc) : '') + '</div>' + acts + '</li>'
+    '<div class="dec-meta"><span class="dec-src">' + esc(SOURCE_WORDS[d.source] || SOURCE_WORDS.agent) + '</span>' + (autoBit(d, esc) ? ' · ' + autoBit(d, esc) : '') + (sessionBit(d, esc) ? ' · ' + sessionBit(d, esc) : '') + '</div>' + acts + '</li>'
 }
 
 // The storage choice (one per project). Off by default: the log stays in Leftoff's folder.
@@ -195,7 +205,7 @@ export function decisionsPageHtml(v, ui = {}, { esc = escD } = {}) {
     (multi ? '<p class="faint">' + v.repos.map((r) => esc(r.label)).join(' · ') + '</p>' : '') + '</header>'
   if (ui.trusted === false) h += '<p class="faint dec-trust"><span aria-hidden="true">◌</span> View only on this device. ' + esc(DEC_TRUST_TIP) + '</p>' // 1h: the reason in words too (a phone shows no tips)
   if (v && (v.project || sc.kind === 'repo')) h += '<section class="proj-sec">' + storageChoiceHtml(v.project, { esc, may: ui.may !== false, trusted: ui.trusted !== false }) + '</section>'
-  if (review.length) h += '<section class="proj-sec dec-review"><h2>To review <span class="count">' + review.length + '</span></h2><p class="faint">Proposed from checkpoints. Only accepted decisions reach new sessions, Ask and walkthroughs.</p><ul class="dec-tl">' + review.map((d) => decisionItemHtml(d, { ...opts, review: true })).join('') + '</ul></section>'
+  if (review.length) h += '<section class="proj-sec dec-review"><h2>To review <span class="count">' + review.length + '</span></h2><p class="faint">Proposed from checkpoints. Questions you answered and plans you approved are accepted on their own. Only accepted decisions reach new sessions, Ask and walkthroughs.</p><ul class="dec-tl">' + review.map((d) => decisionItemHtml(d, { ...opts, review: true })).join('') + '</ul></section>'
   const ctl = '<div class="dec-ctl"><button type="button" class="sask-opt" data-action="dec-all" aria-pressed="' + !!ui.all + '">' + (ui.all ? 'Showing superseded and rejected' : 'Include superseded and rejected' + (hidden ? ' (' + hidden + ')' : '')) + '</button>' +
     '<button type="button" class="btn" data-action="dec-copy">Copy as Markdown</button>' + testplanLinkHtml(sc, { esc, cls: 'btn' }) + '</div>'
   h += '<section class="proj-sec dec-timeline"><h2>Timeline <span class="count">' + rows.length + '</span></h2>' + ctl +

package/ui/fs-side.js

@@ -80,3 +80,32 @@ export function fsSideHtml({ id, side = '', foot = '', label = '', away = '', cp
   return '<aside class="fs-side' + (collapsed ? ' collapsed' : '') + (sheet ? ' sheet-up' : '') + (scrolled ? ' is-scrolled' : '') + '" id="fsSide" data-sid="' + esc(id) + '" aria-label="This session">' +
     resizeHandleHtml({ width, viewport }, { esc }) + peek + '<div class="fs-side-in">' + side + '</div>' + foot + railHtml({ cpCount, cu, away }, { esc, icon }) + '</aside>'
 }
+
+// 2026-11-06 The phone's sheet follows a finger: drag its peek up to raise it, and drag the raised
+// sheet down to lower it, from the peek or from its content when that's scrolled to the very top.
+// Everywhere else a finger scrolls the sheet's content natively, both ways (a drag never starts
+// once the content has room above it, nor when the finger first heads the way that scrolls it).
+export const SHEET_DRAG_SLOP = 8 // px a finger moves before it's a drag or a scroll
+export const SHEET_DRAG_FLIP = 64 // px of drag that raises or lowers the sheet on letting go
+// up: the sheet is raised; fromPeek: the finger started on the peek; scrollTop: the content's at the touch's start;
+// dy, dx: the finger's travel so far (down and right positive) -> 'drag' | 'scroll' | null (not decided yet)
+export function sheetDragStart({ up = false, fromPeek = false, scrollTop = 0, dy = 0, dx = 0 } = {}) {
+  const ay = Math.abs(dy), ax = Math.abs(dx)
+  if (ay < SHEET_DRAG_SLOP && ax < SHEET_DRAG_SLOP) return null
+  if (ax > ay) return 'scroll' // sideways: a table or code block, never the sheet
+  if (!up) return fromPeek && dy < 0 ? 'drag' : 'scroll' // lowered: only the peek, only upwards
+  if (dy <= 0) return 'scroll' // raised, finger heading up: the content scrolls down
+  return fromPeek || (Number(scrollTop) || 0) <= 0 ? 'drag' : 'scroll'
+}
+// How far the sheet sits from where it rests while dragged (px, down positive; never past either end).
+// travel: the px between raised and lowered.
+export function sheetDragOffset({ up = false, dy = 0, travel = 0 } = {}) {
+  const t = Math.max(0, Number(travel) || 0)
+  return up ? Math.round(Math.max(0, Math.min(t, dy))) : Math.round(Math.max(-t, Math.min(0, dy)))
+}
+// Letting go: true when the sheet should change (raise or lower), from the travel or a quick flick.
+export function sheetDragFlips({ up = false, dy = 0, ms = 1000 } = {}) {
+  const d = up ? dy : -dy
+  if (d >= SHEET_DRAG_FLIP) return true
+  return d >= 24 && ms > 0 && d / ms > 0.5 // a flick: 0.5 px/ms
+}