@gotcos/glasses-server 6.99.33 → 7.0.18

package/server/web-control/app.js

@@ -26,6 +26,153 @@
     }).join('\n');
   }
   function plain(text) { return String(text == null ? '' : text).replace(/\*\*|`/g, '').replace(/^#{1,4}\s+/, ''); }
+  // 7.0.5: a COS answer is written for the G2 lens as plain text, so a numbered list arrives inline ("...for me: 1. Prep
+  // before each meeting. 2. Catching conflicts early. 3. ..."), one long paragraph on the phone. Before md() draws a COS
+  // answer (the chat card, the Messages reader), each run of inline items 1, 2, 3 in order goes on its own line under
+  // its lead-in. Only whitespace changes: every character of the answer stays. The lens and the stored text never see it.
+  // Conservative: text with any Markdown structure is left alone; a marker counts only after a sentence end (". " ": "
+  // "? " "! ") and never inside a code, bold or italic span; fewer than two items, or numbers out of order, are not a list;
+  // words after the last item stay in it, except a short "Label:" sentence followed by a new 1, which starts the next list.
+  // 7.0.7 (final QA W1): a new line never starts with what a renderer reads as a block. A "Label:" that starts with one
+  // stays on the line before it, and a list whose item starts with one is left as it is (never half a list).
+  var LA_STRUCTURED = /^[ \t]*(?:[-*+][ \t]|\d{1,3}[.)][ \t]|#|>|\|)|\n[ \t]*\n|```|~~~/m;
+  var LA_MARK = /([.:?!]["'”’)]?)([ \t]+)([1-9]\d?)\.(?=[ \t]+\S)/g;
+  var LA_END = /[.?!]["'”’)]?([ \t]+)/g;
+  // Spans no cut may enter. Each kind is found on its own, as its renderer finds it, and a cut is refused inside any of
+  // them: md()'s own `code` and **bold** (never empty, no star inside bold), and for the Mac's inline Markdown *italic*,
+  // __bold__ and _italic_, each opening on a non-space and closing after one, on one line ("2 * 3" and a lone "*" are
+  // not spans). A word's own underscores (max_tokens, top_p) are matched first, so they never open a span. A link holds
+  // no whitespace, and only whitespace is ever replaced, so a link is never cut.
+  var LA_GUARD = /`[^`\n]+`/g;
+  var LA_BOLD = /\*\*[^*\n]+\*\*/g;
+  var LA_STAR = /\*(?!\*)\S(?:[^*\n]*(?!\*)\S)?\*/g;
+  var LA_UNDER = /[A-Za-z0-9]_+|__(?!_)\S(?:[^_\n]*(?!_)\S)?__(?![A-Za-z0-9])|_(?!_)\S(?:[^_\n]*(?!_)\S)?_(?![A-Za-z0-9])/g;
+  var LA_SPANS = [LA_GUARD, LA_BOLD, LA_STAR, LA_UNDER];
+  // What a line may not start with when a cut makes it start (md() here; the Mac's COSMarkdownParser also reads
+  // "[Speaker]:" lines and "<details>"): a heading, quote, bullet or table row, a "[" or "<", or a number list marker.
+  var LA_BLOCK_START = /[ \t]*(?:[\-#>*+|<\[]|\d+[.)])/y;
+  // What an item's own words may not start with: a heading, a quote, or a Mac task box ("1. [x] done").
+  var LA_ITEM_START = /[ \t]*(?:[#>]|\[[ xX]\])/y;
+  var LA_LABEL_MAX = 100;
+  // Does `re` (sticky) match at `at` in `line`?
+  function laAt(re, line, at) { re.lastIndex = at; return re.test(line); }
+  function structureLensAnswer(text) {
+    var s = text == null ? '' : String(text);
+    if (s.indexOf('. ') < 0 || LA_STRUCTURED.test(s)) return s;
+    var lines = s.split('\n'), out = [], changed = false;
+    for (var i = 0; i < lines.length; i++) {
+      var r = laLine(lines[i]);
+      if (r !== lines[i]) changed = true;
+      // A line that became a list ends with a blank line before whatever follows it.
+      out.push(r !== lines[i] && i < lines.length - 1 ? r + '\n' : r);
+    }
+    return changed ? out.join('\n') : s;
+  }
+  function laLine(line) {
+    var kinds = [], m;
+    for (var g = 0; g < LA_SPANS.length; g++) {
+      var re = LA_SPANS[g], starts = [], ends = [];
+      re.lastIndex = 0;
+      while ((m = re.exec(line))) { starts.push(m.index); ends.push(m.index + m[0].length); }
+      if (starts.length) kinds.push([starts, ends]);
+    }
+    // Inside a span of any kind? One kind's spans are in order and never overlap: binary search each.
+    var guarded = function (at) {
+      for (var k = 0; k < kinds.length; k++) {
+        var st = kinds[k][0], en = kinds[k][1], lo = 0, hi = st.length - 1;
+        while (lo <= hi) { var mid = (lo + hi) >> 1; if (st[mid] > at) hi = mid - 1; else if (en[mid] <= at) lo = mid + 1; else return true; }
+      }
+      return false;
+    };
+    var marks = [];
+    LA_MARK.lastIndex = 0;
+    while ((m = LA_MARK.exec(line))) {
+      var ws = m.index + m[1].length, at = ws + m[2].length;
+      if (guarded(m.index) || guarded(at)) continue;
+      marks.push({ colon: m[1].charAt(0) === ':', ws: ws, at: at, body: at + m[3].length + 1, n: Number(m[3]) });
+    }
+    // Runs of 1, 2, 3 in order; two items or more make a list.
+    var runs = [], cur = [];
+    for (var k = 0; k < marks.length; k++) {
+      var c = marks[k];
+      if (cur.length && c.n === cur[cur.length - 1].n + 1) { cur.push(c); continue; }
+      if (cur.length >= 2) runs.push(cur);
+      cur = c.n === 1 ? [c] : [];
+    }
+    if (cur.length >= 2) runs.push(cur);
+    var cuts = [], prevEnd = 0, lists = 0;
+    for (var q = 0; q < runs.length; q++) {
+      var run = runs[q], first = run[0];
+      // After a list, only a "Label:" lead-in starts another; anything else stays in the last item.
+      if (lists && !first.colon) continue;
+      // An item whose words start a block leaves its whole list as it is; it still counts as a list, so the words after
+      // it stay in its last item.
+      var clean = true;
+      for (var j = 0; j < run.length; j++) if (laAt(LA_ITEM_START, line, run[j].body)) { clean = false; break; }
+      if (clean) {
+        if (first.colon) {
+          // The lead-in is the "Label:" sentence: it gets its own line when it is short and does not start a block.
+          var from = -1, to = -1, e;
+          LA_END.lastIndex = prevEnd;
+          while ((e = LA_END.exec(line)) && e.index + e[0].length < first.ws) {
+            if (!guarded(e.index)) { to = e.index + e[0].length; from = to - e[1].length; }
+          }
+          if (from >= 0 && first.ws - to <= LA_LABEL_MAX && !laAt(LA_BLOCK_START, line, to)) cuts.push([from, to, '\n\n']);
+        }
+        cuts.push([first.ws, first.at, '\n\n']);
+        for (var r2 = 1; r2 < run.length; r2++) cuts.push([run[r2].ws, run[r2].at, '\n']);
+      }
+      prevEnd = run[run.length - 1].body;   // after the last item's own "5.", which is not a sentence end
+      lists++;
+    }
+    if (!cuts.length) return line;
+    var res = '', pos = 0;
+    for (var x = 0; x < cuts.length; x++) { res += line.slice(pos, cuts[x][0]) + cuts[x][2]; pos = cuts[x][1]; }
+    return res + line.slice(pos);
+  }
+  // Markdown pipe tables (Duo tables). Every pane that draws one asks tableFit how far each column may shrink. Cells
+  // wrap only at spaces (CSS: overflow-wrap break-word, so a column is never narrower than its longest word), a column
+  // whose text is longer than TF_MIN_CH keeps at least that many characters, a first column of short labels stays on
+  // one line, and a long first column gets a fixed width and wraps at words. Only a token of TF_LONG or more characters
+  // (a URL, a hash) may break inside. A table wider than its box scrolls inside it (CSS .tf-wrap), first column sticky.
+  var TF_LONG = 25, TF_MIN_CH = 10, TF_KEY_WORDS = 3, TF_KEY_CHARS = 28, TF_FIRST_MIN = 14, TF_FIRST_MAX = 26;
+  var TF_LONG_RE = new RegExp('[^\\s<>]{' + TF_LONG + ',}', 'g');
+  function tfText(cell) {
+    return String(cell == null ? '' : cell).replace(/<[^>]*>/g, '').replace(/&(?:amp|lt|gt|quot|#39);/g, '_')
+      .replace(/\[([^\]\n]*)\]\([^)\s]*\)/g, '$1').replace(/\*\*|__|~~|`/g, '').replace(/\s+/g, ' ').trim();
+  }
+  function tfLong(html) {
+    return String(html).split(/(<[^>]*>)/).map(function (part) {
+      return part.charAt(0) === '<' ? part : part.replace(TF_LONG_RE, function (t) { return '<span class="tf-long">' + t + '</span>'; });
+    }).join('');
+  }
+  // rows: every row of raw cell text, the header row first when there is one.
+  function tableFit(rows) {
+    rows = (rows || []).filter(Array.isArray);
+    var n = rows.reduce(function (m, r) { return Math.max(m, r.length); }, 0);
+    var key = n > 1 && rows.length > 0 && rows.every(function (r) {
+      var t = tfText(r[0]);
+      return t.length <= TF_KEY_CHARS && (t ? t.split(' ').length : 0) <= TF_KEY_WORDS;
+    });
+    var cols = [];
+    for (var k = 0; k < n; k++) {
+      var len = rows.reduce(function (m, r) { return Math.max(m, tfText(r[k]).length); }, 0);
+      if (k === 0 && key) cols.push({ min: 0, width: 0 });
+      else if (k === 0 && n > 1) cols.push({ min: Math.min(len, TF_FIRST_MIN), width: Math.min(len, TF_FIRST_MAX) });
+      else cols.push({ min: Math.min(len, TF_MIN_CH), width: 0 });
+    }
+    return {
+      key: key, cols: cols,
+      tableClass: 'tf' + (key ? ' tf-key' : ''),
+      // The first row's cells carry each column's floor (an inner block's min-width counts in every engine's table
+      // sizing) and the first column's width; later rows only get their long tokens marked.
+      width: function (k, first) { var c = cols[k]; return first && c && c.width ? 'width:' + c.width + 'ch' : ''; },
+      cell: function (k, html, first) {
+        var c = cols[k], body = tfLong(html);
+        return first && c && c.min >= 3 ? '<span class="tf-min" style="min-width:' + c.min + 'ch">' + body + '</span>' : body;
+      }
+    };
+  }
   var WORDS = ['No', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten'];
   function countWord(n, lower) { var w = n >= 0 && n <= 10 ? WORDS[n] : String(n); return lower ? w.toLowerCase() : w; }
   function plural(n, one, many) { return n === 1 ? one : many; }
@@ -119,7 +266,10 @@
       if (timer && o.responseType !== 'blob') clearTimeout(timer);
       sxNoteClock(res, sentAt);
       noteServer(true);
-      if (res.status === 401 && path.indexOf('/api/web-session/') !== 0) { showAuth(); var gone = new Error('Signed out. Connect this browser again.'); gone.status = 401; throw gone; }
+      // A request that renewed this browser's sign-in says so (lib/api-auth.ts): `<new expiry> <30-day cap>`.
+      var renewedTo = res.headers && typeof res.headers.get === 'function' ? res.headers.get('X-COS-Web-Session') : null;
+      if (renewedTo && typeof signinRemember === 'function') { var rt = String(renewedTo).split(' '); signinRemember({ expiresAt: rt[0], renewUntil: rt[1] }); }
+      if (res.status === 401 && path.indexOf('/api/web-session/') !== 0) { showAuth(typeof signinLapsedCopy === 'function' && signedInOnce() ? signinLapsedCopy() : undefined); var gone = new Error('Signed out. Connect this browser again.'); gone.status = 401; throw gone; }
       if (o.responseType === 'blob' && res.ok) return res.blob();
       return res.text().then(function (text) {
         var data = {};
@@ -210,6 +360,103 @@
     sessions: [], sessionsMode: 'words', workTasks: [], workOpenStages: { complete: false },
     stream: null, lastLoad: {}, livePoll: null
   };
+  // ── Mac reachability and sign-in lifetime (W1, 7.0.x): audit 02 F2, F3, F23 ──
+  // F3: with no offline shell (that needs a service worker, so HTTPS), an open page says plainly when the Mac stops answering,
+  // when it last heard from it, and offers Retry, instead of spinners. Retry asks GET /api/health (public, no state) and then
+  // reloads the pane on screen. While the Mac is down it asks again every 30 s, only while the page is visible.
+  // F2: a sign-in lasts 7 days and, since 7.0.x, renews while in use up to 30 days (lib/web-session-auth.ts). Status and the
+  // login answer carry this browser's own expiresAt; within a day of it the page says when it ends and how to sign in again.
+  // Sign-in (7.0.x, Miles 2026-11-09 "Renew while in use, 30-day cap"): `ends` is this cookie's expiry, `cap` the latest a
+  // renewal can reach (30 days from the first sign-in). A server without renewal sends no cap: then the cookie's end is the end.
+  var CONN = { timer: null, retrying: false, signin: null, hideFor: 0, lapsed: false };
+  var CONN_RETRY_MS = 30000, SIGNIN_WARN_MS = 24 * 3600000, SIGNIN_STORE = 'cos.web.signinEnds';
+  // Names the row, never the Settings page: that page was renamed in COS Control 0.5.387, and a phone may pair with either build.
+  var SIGNIN_HOW = 'On your Mac, open COS Control Settings and choose Open COS on your phone. Or get a code from another signed-in browser, or from the COS Glasses app.';
+  function connWhen(ms) {
+    if (!ms) return '';
+    var d = new Date(ms), same = new Date().toDateString() === d.toDateString();
+    return same ? clock(d) : d.toLocaleDateString(undefined, { weekday: 'short' }) + ' ' + clock(d);
+  }
+  function signinRemember(info) {
+    var ends = info && info.expiresAt ? Date.parse(info.expiresAt) : NaN, cap = info && info.renewUntil ? Date.parse(info.renewUntil) : NaN;
+    // Q1: a signed-in answer with no expiry (the token, or an older server) leaves nothing to warn about.
+    if (info && info.authenticated === true && !info.expiresAt) {
+      CONN.signin = null;
+      try { localStorage.removeItem(SIGNIN_STORE); } catch (e) { /* nothing kept */ }
+      return;
+    }
+    if (!isFinite(ends) || ends <= 0) return;
+    CONN.signin = { ends: ends, cap: isFinite(cap) && cap >= ends ? cap : 0 };
+    try { localStorage.setItem(SIGNIN_STORE, JSON.stringify(CONN.signin)); } catch (e) { /* the notice still works for this page */ }
+    if (typeof connPaint === 'function') connPaint();
+  }
+  function signinKnown() {
+    if (CONN.signin) return CONN.signin;
+    try {
+      var raw = localStorage.getItem(SIGNIN_STORE), v = raw ? JSON.parse(raw) : null;
+      if (typeof v === 'number' && v > 0) return { ends: v, cap: 0 };   // the earlier page kept the expiry alone
+      if (v && typeof v.ends === 'number' && v.ends > 0) return { ends: v.ends, cap: typeof v.cap === 'number' ? v.cap : 0 };
+    } catch (e) { /* nothing known */ }
+    return null;
+  }
+  // When this sign-in really ends while it is in use: the 30-day cap where the server renews, else the cookie's own end.
+  function signinEndsAt() { var k = signinKnown(); return k ? (k.cap || k.ends) : 0; }
+  // Why the sign-in gate opened after this page had been signed in: the 30 days, no use in the cookie's last 2 days (its
+  // only renewal window, so a browser used on day 4 still ends on day 7), or a sign-out. Q1 R-3.
+  function signinLapsedCopy() {
+    var k = signinKnown(), soon = Date.now() + 60000;
+    if (k && k.cap && k.cap <= soon) return 'Your sign-in on this browser reached its 30 days. ' + SIGNIN_HOW;
+    if (k && k.cap && k.ends <= soon) return 'Your sign-in on this browser ended because COS was not used here in its last 2 days. ' + SIGNIN_HOW;
+    if (k && !k.cap && k.ends <= soon) return 'Your sign-in on this browser ended. Sign-ins last 7 days. ' + SIGNIN_HOW;
+    return 'This browser is signed out. ' + SIGNIN_HOW;
+  }
+  // Q1 M1: a request that never got an answer cannot tell a sleeping Mac from this device being offline or off
+  // Tailscale, so the line names both. Only the browser's own "offline" is certain enough to say alone.
+  function connOffline() { return typeof navigator !== 'undefined' && navigator && navigator.onLine === false; }
+  function connTitle() { return connOffline() ? 'This device is offline.' : 'COS on your Mac is not answering.'; }
+  function connWhy() {
+    return connOffline() ? 'Connect to the internet and Tailscale, then try again.'
+      : 'Your Mac may be asleep, or this device may be offline or off Tailscale.';
+  }
+  function connHtml() {
+    var html = '';
+    if (SERVER.up === false) {
+      html += '<div class="conn-line" role="status"><strong>' + esc(connTitle()) + '</strong><span class="conn-sub">' +
+        esc((SERVER.lastUpAt ? 'Last updated ' + connWhen(SERVER.lastUpAt) + '. ' : '') + 'What is on screen may be out of date. ' + connWhy()) + '</span>' +
+        '<button type="button" class="btn small" data-action="conn-retry"' + (CONN.retrying ? ' disabled' : '') + '>' + (CONN.retrying ? 'Checking' : 'Retry') + '</button></div>';
+    }
+    var ends = signinEndsAt(), left = ends - Date.now();
+    if (ends && left > 0 && left <= SIGNIN_WARN_MS && CONN.hideFor !== ends) {
+      html += '<div class="conn-line" role="status"><strong>Sign-in here ends ' + esc(connWhen(ends)) + '.</strong><span class="conn-sub">' +
+        esc('Sign in again before then from COS Control Settings on your Mac: Open COS on your phone.') + '</span>' +
+        '<button type="button" class="btn small" data-action="conn-hide-signin">Hide</button></div>';
+    }
+    return html;
+  }
+  function connPaint() {
+    var box = $('conn-notice'); if (!box) return;
+    var html = connHtml();
+    if (box.innerHTML !== html) box.innerHTML = html;
+    box.hidden = !html;
+  }
+  function connSchedule() {
+    if (CONN.timer) { clearTimeout(CONN.timer); CONN.timer = null; }
+    if (SERVER.up !== false) return;
+    CONN.timer = setTimeout(function () { CONN.timer = null; if (!document.hidden) connRetry(false); else connSchedule(); }, CONN_RETRY_MS);
+  }
+  function connRetry(byHand) {
+    if (CONN.retrying) return Promise.resolve(false);
+    CONN.retrying = true; connPaint();
+    return api('/api/health', { timeoutMs: 10000 }).then(function () { return true; }, function () { return false; }).then(function (up) {
+      CONN.retrying = false;
+      if (up) { connPaint(); if (typeof route === 'function') route(); }
+      else { if (byHand) noteServer(false); connPaint(); connSchedule(); }
+      return up;
+    });
+  }
+  SERVER.hooks.push(function () { connPaint(); connSchedule(); });
+  // ── end Mac reachability and sign-in lifetime
+
   // Control's order (ActivitySection.visibleSections): Today, then Messages to Dictation. Usage is a
   // view inside Sessions on the Mac; its route stays so old links work, and the rail marks Sessions.
   var ROOT_PANES = ['today', 'messages', 'speakers', 'meetings', 'memories', 'threads', 'sessions', 'work', 'dictation', 'usage', 'settings'];
@@ -278,7 +525,10 @@
     var hash = '#/' + [pane].concat(args || []).map(encodeURIComponent).join('/');
     if (location.hash === hash) route(); else location.hash = hash;
   }
-  function isPhone() { return !window.matchMedia('(min-width: 600px)').matches; }
+  // 7.0.2 (A8): a phone is under 600 px wide, or a short touch screen at any width (the unfolded Duo is 951x539 in
+  // Comet): height is its scarce axis, so it gets the phone Ask sheet and the 44 px tap floor (app.css), as folded does.
+  var SHORT_TOUCH_MQ = '(pointer: coarse) and (max-height: 720px)';
+  function isPhone() { return !window.matchMedia('(min-width: 600px)').matches || window.matchMedia(SHORT_TOUCH_MQ).matches; }
   /** A keyboard and a fine pointer are the way in (a Mac, a PC): Return sends. Touch screens type a new line. */
   function keyboardFirst() { return !!(window.matchMedia && window.matchMedia('(hover: hover) and (pointer: fine)').matches); }
   // Return in a text box sends only where a keyboard and a pointer are the way in (cos-chat.js keyboardFirst): never on
@@ -379,7 +629,10 @@
   // ── auth ────────────────────────────────────────────────
   function showAuth(message) {
     readerImagesStop($('session-turns')); readerImagesStop($('ta-last'));
+    if (typeof liveHide === 'function') { liveHide(); liveStopWatch(); LIVE.mode = 'idle'; }
     var alreadyOpen = !$('auth-gate').classList.contains('hidden');
+    if (typeof CONN === 'object' && !$('app-shell').classList.contains('hidden')) CONN.lapsed = true;
+    if (typeof authOffline === 'function') authOffline(false);
     $('app-shell').classList.add('hidden');
     $('auth-gate').classList.remove('hidden');
     // A later 401 from a pane still polling (W.api passes no message) must not blank what the gate already says:
@@ -388,14 +641,19 @@
     setStatus($('auth-error'), message || '', true);
     $('auth-error').classList.toggle('hidden', !message);
   }
+  function signedInOnce() { var shell = typeof $ === 'function' ? $('app-shell') : null; return !!(shell && !shell.classList.contains('hidden')) || CONN.lapsed; }
   function showShell(info) {
+    if (typeof signinRemember === 'function') signinRemember(info);
+    if (typeof authOffline === 'function') authOffline(false);
     $('auth-gate').classList.add('hidden');
     $('app-shell').classList.remove('hidden');
     state.serverName = (info && info.serverName) || 'Your Mac';
     $('host-name').textContent = state.serverName.replace(/-/g, ' ');
     loadTailnetUrl();
     runHooks(shellHooks, info);
+    if (typeof connPaint === 'function') connPaint();
     route();
+    if (typeof liveStart === 'function') liveStart();   // 7.0.1: the one live stream for this page (a no-op if it is already open)
     // Reloaded with Today's overlay open: its history entry is still current. The overlay opens the same thing again
     // (panes/today-actions.js restore), so Back closes it; if it cannot load, the entry is unmarked.
     var held = history.state;
@@ -419,15 +677,24 @@
   // stories all asked for it separately. Now there is one copy: a request younger than maxAgeMs is
   // answered from it, a request already on the wire is shared, and panes can paint the last copy at
   // once while a fresh one loads (sessionListCached).
-  var SL = { data: null, at: 0, inflight: null, waiting: null };
+  var SL = { data: null, at: 0, inflight: null, waiting: null, failed: false };
   function sessionList(maxAgeMs) {
     if (SL.data && Date.now() - SL.at < (maxAgeMs || 0)) return Promise.resolve(SL.data);
     if (SL.inflight) return SL.inflight;
     SL.inflight = api('/api/agent-sessions?limit=80&sort=updated').then(function (d) {
+      // 7.0.5: a sessions read (Sessions pane or Today) that follows a failed one is a reconnect: Today's next summary
+      // ask says so (requestBrief), once.
+      if (SL.failed) { SL.failed = false; if (typeof BRIEF === 'object' && BRIEF) BRIEF.reconnect = true; }
       SL.data = d; SL.at = Date.now(); SL.inflight = null;
+      // 7.0.1: a fresh list is corrected by the live model at once, so it never paints a state the stream already moved.
+      // Only while a stream is open and live (review W1): reconnecting, busy or hidden, the list is the newest truth.
+      if (typeof liveCanOverlay === 'function' && d && Array.isArray(d.sessions)) {
+        if (liveCanOverlay()) liveOverlay(d.sessions, { placeholders: true, unknown: true });
+        else if (liveOn()) LIVE.freshAt = SL.at;
+      }
       noteWaiting(d);
       return d;
-    }, function (err) { SL.inflight = null; throw err; });
+    }, function (err) { SL.inflight = null; SL.failed = true; throw err; });
     return SL.inflight;
   }
   function sessionListCached() { return SL.data ? { data: SL.data, at: SL.at } : null; }
@@ -449,6 +716,438 @@
     if (fresh) questionsNudge();
   }
 
+  // ── live state (7.0.1) ──────────────────────────────────
+  // Miles 11/07: the pet, the session rows, Today's counts and the running clocks showed the last fetch, not now. One
+  // EventSource('/api/events') per page (docs/live-events-contract.md) tells the page when the server's own session
+  // state moves: ids, states, counts and times only. The list (/api/agent-sessions) still carries every word; the
+  // stream corrects its rows in place and asks for a fresh list when a session appears, leaves or replies.
+  //   mode  'idle'         not started (signed out)
+  //         'connecting'   a stream is opening; nothing painted differently yet
+  //         'live'         a frame arrived inside the last 30 s: counts are live
+  //         'reconnecting' the stream dropped or went quiet: "Reconnecting", the list read every 5 s until it is back
+  //         'busy'         the server has no room for another stream (503): retried in 30 s, no fast polling
+  //         'absent'       no /api/events (an older server, or COS_WEB_LIVE_EVENTS=0): exactly what 7.0.0 did
+  // A hidden page holds no stream and runs no timer; coming back re-reads the list at once and resumes from the last
+  // id (`?after=<epoch>.<seq>`, the contract's manual resume, since new EventSource cannot set Last-Event-ID).
+  var LIVE_SILENT_MS = 30000, LIVE_POLL_MS = 5000, LIVE_WATCH_MS = 5000, LIVE_RETRY_MS = 3000, LIVE_RETRY_MAX_MS = 30000;
+  var LIVE_BUSY_MS = 30000, LIVE_ABSENT_RECHECK_MS = 10 * 60000, LIVE_LIST_DEBOUNCE_MS = 1000, LIVE_STALE_MS = 30000, LIVE_REPLY_LIST_GAP_MS = 12000;
+  var LIVE = {
+    mode: 'idle', es: null, lastId: '', epoch: null, seq: -1, frameAt: 0, skew: 0, gotFrame: false,
+    sessions: {},        // key (provider:sessionid, lowercase) -> LiveSession
+    questions: null, queue: null, degraded: {},
+    freshAt: 0,          // when the counts on screen were last confirmed: a frame on a live stream, or a list read
+    retryMs: LIVE_RETRY_MS, retry: null, poll: null, watch: null, listTimer: null, paintTimer: null,
+    absentAt: 0, hooks: [], gen: 0, pendingRows: [], pendingStructural: false, listAt: 0, listDue: 0, noteSaid: null
+  };
+  function liveOnMode(m) { return m === 'live' || m === 'reconnecting' || m === 'busy'; }
+  function liveOn() { return liveOnMode(LIVE.mode); }
+  /** The live model corrects list rows only while a stream is open and live. Reconnecting, busy or hidden, the list
+   *  read is newer than the model (review W1). The model is kept only as the base a resume applies to. */
+  function liveCanOverlay() { return LIVE.mode === 'live' && !!LIVE.es && LIVE.gotFrame; }
+  function liveKey(provider, id) { return String(provider || 'claude').toLowerCase() + ':' + String(id || '').toLowerCase(); }
+  function liveRowKey(s) { var k = splitSessionId(s.provider, s.session_id || s.id); return liveKey(k.provider, k.id); }
+  // The contract's join (review B1): the full id, lowercase. The 8-character prefix joins only when one side is
+  // exactly 8 characters (the list may carry a Claude tab under the registry's short id until it finds the
+  // transcript) and only one candidate matches, the rule countFor uses on the server. Codex ids are UUIDv7: their
+  // first 8 characters are a timestamp and stay the same for about 65 s, so a prefix alone joins parallel sessions.
+  function liveSame(a, b) {
+    if (a === b) return true;
+    var ia = a.slice(a.indexOf(':') + 1), ib = b.slice(b.indexOf(':') + 1);
+    if (a.slice(0, a.length - ia.length) !== b.slice(0, b.length - ib.length)) return false;
+    // One side must BE the other's first 8 characters, so it is exactly 8 long: two full ids never join here.
+    return ia.length === 8 ? ib.slice(0, 8) === ia : ia.slice(0, 8) === ib;
+  }
+  /** The one key in `keys` this key joins, or '' (none, or more than one by prefix). */
+  function liveMatch(key, keys) {
+    if (keys.indexOf(key) >= 0) return key;
+    var hits = keys.filter(function (k) { return liveSame(key, k); });
+    return hits.length === 1 ? hits[0] : '';
+  }
+  function liveIso(ms) { return typeof ms === 'number' && isFinite(ms) ? new Date(ms).toISOString() : null; }
+  /** The list arrays on this page (usually one array, shared): every row a live frame must correct. */
+  function liveLists() {
+    var out = [];
+    [SL.data && SL.data.sessions, state.sessions, typeof SX !== 'undefined' && SX ? SX.rows : null].forEach(function (a) { if (Array.isArray(a) && out.indexOf(a) < 0) out.push(a); });
+    return out;
+  }
+  /** Write one LiveSession onto a list row, in the list's own fields (sxState, running_active, running). */
+  // Claude: the registry and the hooks know whether the tab is open, so the stream decides open or closed too. Codex
+  // and Cursor (review W2): the stream's "open" is only a 30-minute hook window, while the list reads the process
+  // itself, so the list decides open or closed and alive; the stream moves working, waiting or idle and the times.
+  function liveOwnsOpen(provider) { return String(provider || 'claude').toLowerCase() === 'claude'; }
+  function liveWrite(row, ls) {
+    var st = ls.state;
+    row._live = true;
+    row._liveTurnAt = (st === 'working' || st === 'waiting') && typeof ls.turnStartedAt === 'number' ? ls.turnStartedAt : null;
+    row.state_source = ls.source === 'registry' ? 'registry' : 'hook';
+    row.running_active = st === 'working';
+    if (liveOwnsOpen(ls.provider)) {
+      row.running = st !== 'ended';
+      row.alive = st !== 'ended';
+      row.agent_state = st === 'working' ? 'running' : st === 'waiting' ? 'waiting' : st === 'ended' ? 'ended' : ls.failed ? 'failed' : 'idle';
+    } else if (st === 'working' || st === 'waiting') {
+      row.agent_state = st === 'working' ? 'running' : 'waiting';
+    } else if (row.agent_state === 'running' || row.agent_state === 'waiting' || row.agent_state === 'idle' || row.agent_state === 'failed' || !row.agent_state) {
+      row.agent_state = row.running === false ? 'ended' : ls.failed && st !== 'ended' ? 'failed' : 'idle';
+    }
+    if (row._liveTurnAt != null) row.state_since = liveIso(row._liveTurnAt);
+    else if (typeof ls.updatedAt === 'number' && row._liveState !== st) row.state_since = liveIso(ls.updatedAt);
+    if (typeof ls.updatedAt === 'number') row.last_activity_at = liveIso(ls.updatedAt);
+    if (typeof ls.queued === 'number') row.queued_turns = ls.queued;
+    row._liveState = st;
+  }
+  /** A session the stream says left the live model: no longer working or open (it may stay in the list as recent). */
+  function liveForget(row) {
+    row._live = false; row._liveTurnAt = null; row._liveState = '';
+    row.running_active = false;
+    if (!liveOwnsOpen(splitSessionId(row.provider, row.session_id || row.id).provider)) {
+      // Codex and Cursor: still open or closed as the list says; only no longer working or waiting.
+      if (row.agent_state === 'running' || row.agent_state === 'waiting') row.agent_state = row.running === false ? 'ended' : 'idle';
+      return;
+    }
+    row.running = false;
+    if (row.agent_state === 'running' || row.agent_state === 'waiting' || row.agent_state === 'idle') row.agent_state = 'ended';
+  }
+  /** Overlay the live model on the list rows. Returns what moved: { changed: [rows], added: n, unknown: n }. */
+  function liveOverlay(rows, opts) {
+    var o = opts || {}, out = { changed: [], added: 0, unknown: [] }, byJoin = {};
+    Object.keys(LIVE.sessions).forEach(function (k) { var ls = LIVE.sessions[k]; byJoin[liveKey(ls.provider, ls.sessionId)] = ls; });
+    var keys = Object.keys(byJoin), seen = {};
+    (rows || []).forEach(function (row) {
+      if (!row) return;
+      var j = liveMatch(liveRowKey(row), keys), ls = j ? byJoin[j] : null;
+      if (ls) { seen[j] = 1; var before = row._liveState + '|' + row._liveTurnAt + '|' + row.queued_turns; liveWrite(row, ls); if (before !== row._liveState + '|' + row._liveTurnAt + '|' + row.queued_turns) out.changed.push(row); }
+      // A row this page corrected before, now missing from a whole snapshot: it left. Never a row the stream never
+      // spoke for (a Codex or Cursor session whose hooks never reach the server stays as the list says), and never
+      // while the server says it could not read its registry (degraded: absence is not "nothing running").
+      else if (o.whole && row._live && !LIVE.degraded.registry) { liveForget(row); out.changed.push(row); }
+    });
+    // A session the list has not caught up with yet: a placeholder row while it works or waits, so the pet and the
+    // Running count move now, and a fresh list (debounced) brings its title.
+    if (o.placeholders || o.unknown) {
+      Object.keys(byJoin).forEach(function (j) {
+        if (seen[j]) return;
+        var ls = byJoin[j];
+        out.unknown.push(j);
+        if (!o.placeholders || (ls.state !== 'working' && ls.state !== 'waiting')) return;
+        var row = { provider: ls.provider, session_id: ls.sessionId, id: ls.sessionId, title: 'New ' + providerLabel(ls.provider) + ' session', _placeholder: true, running: true, alive: true };
+        liveWrite(row, ls);
+        rows.unshift(row); out.added++; out.changed.push(row);
+      });
+    }
+    return out;
+  }
+  /** Apply the live model to every list on the page, then repaint what shows. */
+  function liveApply(whole) {
+    if (!liveCanOverlay()) return { changed: 0, added: 0, unknown: 0 };
+    var lists = liveLists(), changed = [], added = 0, unknown = [];
+    lists.forEach(function (rows, i) {
+      var r = liveOverlay(rows, { whole: whole, placeholders: i === 0, unknown: i === 0 });
+      changed = changed.concat(r.changed); added += r.added; if (i === 0) unknown = r.unknown;
+    });
+    // A session the list has not shown yet: the snapshot and each new session already ask for one fresh list
+    // (liveListSoon in liveFrame), so nothing more here.
+    if (changed.length || added) livePaint(changed, added > 0);
+    return { changed: changed.length, added: added, unknown: unknown.length };
+  }
+  function liveRunHooks(ev) { LIVE.hooks.slice().forEach(function (fn) { try { fn(ev); } catch (err) { console.error(err); } }); }
+  // One frame. Returns false when the stream must be reopened (a gap or a server restart).
+  function liveFrame(f) {
+    if (!f || typeof f !== 'object' || typeof f.kind !== 'string') return true;
+    var now = Date.now(), couldOverlay = liveCanOverlay();
+    LIVE.frameAt = now;
+    if (typeof f.at === 'number' && isFinite(f.at)) LIVE.skew = now - f.at;
+    var stateFrame = f.kind === 'snapshot' || f.kind === 'session' || f.kind === 'session.removed' || f.kind === 'questions' || f.kind === 'queue';
+    if (f.kind === 'snapshot') {
+      LIVE.epoch = f.epoch; LIVE.seq = typeof f.seq === 'number' ? f.seq : -1;
+      LIVE.sessions = {};
+      (Array.isArray(f.sessions) ? f.sessions : []).forEach(function (ls) { if (ls && ls.sessionId) LIVE.sessions[liveKey(ls.provider, ls.sessionId)] = ls; });
+      LIVE.questions = f.questions || null; LIVE.queue = f.queue || null;
+      LIVE.degraded = f.degraded && typeof f.degraded === 'object' ? f.degraded : {};
+    } else if (typeof f.seq === 'number') {
+      if (LIVE.epoch !== null && f.epoch != null && f.epoch !== LIVE.epoch) return false;   // a new server life
+      if (stateFrame ? f.seq > LIVE.seq + 1 : f.seq > LIVE.seq) return false;              // missed a frame
+      if (stateFrame && f.seq <= LIVE.seq) return true;                                     // already applied
+    }
+    if (stateFrame && typeof f.seq === 'number') { LIVE.seq = f.seq; if (f.epoch != null) LIVE.epoch = f.epoch; LIVE.lastId = LIVE.epoch + '.' + LIVE.seq; }
+    if (!LIVE.gotFrame) { LIVE.gotFrame = true; LIVE.retryMs = LIVE_RETRY_MS; }
+    var wasMode = LIVE.mode;
+    LIVE.mode = 'live';
+    if (!LIVE.degraded.registry) LIVE.freshAt = now;
+    liveStopPoll();
+    // The first frame on a (re)opened stream, after a list read won (Reconnecting, busy, or hidden and back): the
+    // resumed model corrects the rows again, including a resume that replayed nothing.
+    if (!couldOverlay && f.kind !== 'snapshot') liveApply(false);
+    if (f.kind === 'snapshot') {
+      liveApply(true);
+      liveListSoon();
+      questionsNudge();
+      liveRunHooks({ kind: 'snapshot' });
+    } else if (f.kind === 'session' && f.session && f.session.sessionId) {
+      var k = liveKey(f.session.provider, f.session.sessionId), was = LIVE.sessions[k];
+      LIVE.sessions[k] = f.session;
+      var r = liveApply(false);
+      // New: the words come from the list now. A reply landed (`replies` went up): the words come from the list, at
+      // most one read per LIVE_REPLY_LIST_GAP_MS (ghost W7: dozens of sessions ending turns would poll the list).
+      if (f.change === 'added' || !was) liveListSoon();
+      else if (typeof f.session.replies === 'number' && f.session.replies > (was.replies || 0)) liveListSoon(LIVE_REPLY_LIST_GAP_MS);
+      if (f.session.state === 'waiting' && (!was || was.state !== 'waiting')) questionsNudge();
+      liveRunHooks({ kind: 'session', key: k, session: f.session, previous: was || null, moved: r.changed });
+    } else if (f.kind === 'session.removed') {
+      var j = liveKey(f.provider, f.sessionId), gone = [];
+      delete LIVE.sessions[j];
+      var others = Object.keys(LIVE.sessions).map(function (k) { return liveKey(LIVE.sessions[k].provider, LIVE.sessions[k].sessionId); });
+      liveLists().forEach(function (rows) {
+        for (var i = rows.length - 1; i >= 0; i--) {
+          var row = rows[i]; if (!row) continue;
+          var rk = liveRowKey(row);
+          // This row is the removed session's (by the same join), and no remaining live session claims it.
+          if (liveMatch(rk, others.concat([j])) !== j) continue;
+          if (row._placeholder) { rows.splice(i, 1); gone.push(row); } else if (row._live) { liveForget(row); gone.push(row); }
+        }
+      });
+      if (gone.length) livePaint(gone, true);
+      liveListSoon();
+      liveRunHooks({ kind: 'session.removed', key: liveKey(f.provider, f.sessionId) });
+    } else if (f.kind === 'questions') {
+      LIVE.questions = { total: f.total, approvals: f.approvals, bySession: f.bySession };
+      questionsNudge();   // the cards come from /api/session-questions (questions.js keeps its own poll as the fallback)
+      liveRunHooks({ kind: 'questions' });
+    } else if (f.kind === 'queue') {
+      LIVE.queue = { total: f.total, bySession: f.bySession };
+      liveRunHooks({ kind: 'queue' });
+    }
+    if (wasMode !== 'live') livePaint([], true);
+    return true;
+  }
+  function liveUrl() { return '/api/events' + (LIVE.lastId ? '?after=' + encodeURIComponent(LIVE.lastId) : ''); }
+  function liveVisible() { return !document.hidden; }
+  function liveSignedIn() { var sh = $('app-shell'); return !!(sh && !sh.classList.contains('hidden')); }
+  /** Open the one stream (never a second while one is open). */
+  function liveOpen() {
+    clearTimeout(LIVE.retry); LIVE.retry = null;
+    if (LIVE.es || !liveVisible() || !liveSignedIn()) return;
+    if (typeof EventSource !== 'function') { liveSetMode('absent'); return; }
+    var es, gen = ++LIVE.gen;
+    try { es = new EventSource(liveUrl()); } catch (_e) { liveSetMode('absent'); return; }
+    LIVE.es = es; LIVE.gotFrame = false;
+    if (LIVE.mode !== 'live' && LIVE.mode !== 'reconnecting' && LIVE.mode !== 'busy') LIVE.mode = 'connecting';
+    LIVE.frameAt = Date.now();
+    es.onmessage = function (ev) {
+      if (LIVE.es !== es || gen !== LIVE.gen) return;
+      var f; try { f = JSON.parse(ev.data); } catch (_e) { return; }
+      if (liveFrame(f) === false) {
+        // A gap or a new server life: reopen. A gap resumes from the last applied id; a new life starts fresh.
+        if (f && f.epoch != null && LIVE.epoch !== null && f.epoch !== LIVE.epoch) { LIVE.lastId = ''; LIVE.epoch = null; LIVE.seq = -1; }
+        liveClose(); liveOpen();
+      }
+    };
+    es.onerror = function () {
+      if (LIVE.es !== es || gen !== LIVE.gen) return;
+      if (!LIVE.gotFrame) {
+        // Never got a frame: EventSource hides the status, so one GET reads it (the readers' fallback-status pattern).
+        liveClose();
+        liveProbe(gen);
+        return;
+      }
+      // The stream had been live. The browser reconnects on its own with Last-Event-ID while readyState is 0; a closed
+      // stream (2) is reopened here with ?after. Either way the page says so and reads the list until a frame lands.
+      LIVE.gotFrame = false;
+      if (es.readyState === 2) { liveClose(); liveReconnect(); }
+      else liveSetMode('reconnecting');
+    };
+    liveStartWatch();
+  }
+  function liveClose() {
+    if (LIVE.es) { try { LIVE.es.close(); } catch (_e) {} }
+    LIVE.es = null; LIVE.gen++;
+  }
+  // What the route answered, read once without signing the page out: 404 (no route, or the switch off) and 401 or 403
+  // mean no live stream here, so the page does exactly what 7.0.0 did. 503 is a full server. Anything else (a
+  // network failure, a 200 that dropped) is a stream to reopen.
+  function liveProbe(gen) {
+    var ctrl = typeof AbortController === 'function' ? new AbortController() : null;
+    var timer = ctrl ? setTimeout(function () { ctrl.abort(); }, 10000) : null;
+    fetch(liveUrl(), { headers: { 'X-COS-Web': '1', Accept: 'text/event-stream' }, credentials: 'same-origin', signal: ctrl ? ctrl.signal : undefined })
+      .then(function (res) {
+        var code = res.status, type = '';
+        try { type = String((res.headers && res.headers.get && res.headers.get('content-type')) || ''); } catch (_e) { type = ''; }
+        if (ctrl) ctrl.abort();
+        return { code: code, stream: type.indexOf('text/event-stream') === 0 };
+      }, function () { return { code: 0, stream: false }; })
+      .then(function (r) {
+        if (timer) clearTimeout(timer);
+        if (LIVE.es || LIVE.mode === 'idle') return;
+        if (r.code === 503) { liveSetMode('busy'); LIVE.retry = setTimeout(liveOpen, LIVE_BUSY_MS); return; }
+        if (r.code === 0 || (r.code === 200 && r.stream)) { liveReconnect(); return; }
+        // 404, 401, 403, any other status, or a 200 that is not a stream: polling as today.
+        liveSetMode('absent');
+      });
+  }
+  function liveReconnect() {
+    liveSetMode('reconnecting');
+    clearTimeout(LIVE.retry);
+    var wait = LIVE.retryMs;
+    LIVE.retryMs = Math.min(LIVE.retryMs * 2, LIVE_RETRY_MAX_MS);
+    LIVE.retry = setTimeout(liveOpen, wait);
+  }
+  function liveSetMode(m) {
+    var was = LIVE.mode;
+    LIVE.mode = m;
+    if (m === 'absent') {
+      // Exactly 7.0.0: no stream, no extra timer, no label. Rows this page corrected keep their last values until the
+      // next list read replaces them, as 7.0.0's rows did.
+      liveClose(); liveStopPoll(); liveStopWatch(); clearTimeout(LIVE.retry); LIVE.retry = null;
+      LIVE.absentAt = Date.now(); LIVE.sessions = {};
+    }
+    if (m === 'reconnecting') liveStartPoll(); else if (m !== 'live') liveStopPoll();
+    if (was === 'live' && m !== 'live') liveLetGo();
+    if (was !== m && (liveOnMode(was) || liveOnMode(m))) livePaint([], true);
+  }
+  /** Leaving live (review W1): placeholder rows go, and no row keeps a live mark the next list read would not
+   *  replace. The model stays only as the base a resume applies to; nothing overlays it until a frame lands. */
+  function liveLetGo() {
+    liveLists().forEach(function (rows) {
+      for (var i = rows.length - 1; i >= 0; i--) {
+        var row = rows[i]; if (!row) continue;
+        if (row._placeholder) rows.splice(i, 1); else if (row._live) { row._live = false; row._liveTurnAt = null; row._liveState = ''; }
+      }
+    });
+  }
+  // ── the fallbacks: a watchdog for a quiet stream, and the 5 s list read while reconnecting ──
+  function liveStartWatch() {
+    if (LIVE.watch) return;
+    LIVE.watch = setInterval(function () {
+      if (!liveVisible()) return;
+      if ((LIVE.mode === 'live' || LIVE.mode === 'connecting' || LIVE.mode === 'reconnecting') && LIVE.es && Date.now() - LIVE.frameAt > LIVE_SILENT_MS) {
+        // No frame of any kind for 30 s (the heartbeat is every 15 s): the stream is dead whatever readyState says.
+        liveClose(); liveReconnect();
+      }
+      if (liveOn() || LIVE.mode === 'connecting') liveNoteTick();
+    }, LIVE_WATCH_MS);
+  }
+  function liveStopWatch() { clearInterval(LIVE.watch); LIVE.watch = null; }
+  function liveStartPoll() {
+    if (LIVE.poll) return;
+    LIVE.poll = setInterval(function () { if (liveVisible() && LIVE.mode === 'reconnecting') livePollOnce(); }, LIVE_POLL_MS);
+  }
+  function liveStopPoll() { clearInterval(LIVE.poll); LIVE.poll = null; }
+  /** Read the list now, and swap it in on every pane that shows it. Resolves when it landed (or failed). */
+  function livePollOnce() {
+    var before = SL.data && SL.data.sessions;
+    LIVE.listAt = Date.now();
+    var keysOf = function (a) { return (a || []).map(function (s) { return s ? liveRowKey(s) : ''; }).join(','); };
+    return sessionList(0).then(function (d) {
+      var rows = (d && d.sessions) || [];
+      var moved = keysOf(before) !== keysOf(rows);
+      if (state.sessions === before || !state.sessions || !state.sessions.length) state.sessions = rows;
+      if (typeof SX !== 'undefined' && SX && SX.rows === before) { SX.rows = rows; SX.loadedAt = Date.now(); }
+      LIVE.freshAt = Date.now();
+      if (liveOn()) livePaint(rows, moved);
+      return true;
+    }, function () { if (liveOn()) livePaint([], false); return false; });
+  }
+  /** A fresh list soon (debounced), for the words of a session that appeared, left or replied. With `gapMs` (a reply),
+   *  no sooner than gapMs after the last list read, and never later than a read already due. */
+  function liveListSoon(gapMs) {
+    var now = Date.now(), due = now + LIVE_LIST_DEBOUNCE_MS;
+    if (gapMs) {
+      if (LIVE.listTimer) return;   // a read is already due; it brings this reply's words too
+      due = Math.max(due, (LIVE.listAt || 0) + gapMs);
+    }
+    clearTimeout(LIVE.listTimer);
+    LIVE.listDue = due;
+    LIVE.listTimer = setTimeout(function () { LIVE.listTimer = null; if (liveVisible()) livePollOnce(); }, due - now);
+  }
+  // ── coming back: visible, back from the back-forward cache, back online ──
+  function liveResume() {
+    if (!liveSignedIn()) return;
+    var wasOn = liveOn();
+    if (LIVE.mode === 'absent') {
+      // 7.0.0 behaviour; look again only after a long while (a server updated or switched on since). That look is one
+      // stream attempt, nothing else: the panes read what 7.0.0 read.
+      if (Date.now() - LIVE.absentAt < LIVE_ABSENT_RECHECK_MS) return;
+      LIVE.mode = 'connecting';
+    }
+    if (LIVE.mode === 'idle') return;
+    if (wasOn) livePollOnce();
+    if (!LIVE.es) { clearTimeout(LIVE.retry); LIVE.retry = null; LIVE.retryMs = LIVE_RETRY_MS; liveOpen(); }
+    liveStartWatch();
+    liveTickStart();   // stops itself at once when nothing on screen ticks
+    liveNoteTick();
+  }
+  function liveHide() {
+    // A hidden page holds no stream (a locked phone drops it anyway) and runs no live timer: not the stream, the list
+    // read, the retry, the watchdog or the 1 s clock (ghost note 1).
+    liveClose(); liveStopPoll(); liveStopWatch(); liveTickStop(); clearTimeout(LIVE.retry); LIVE.retry = null; clearTimeout(LIVE.listTimer); LIVE.listTimer = null;
+  }
+  function liveStart() {
+    if (LIVE.mode !== 'idle') return;
+    LIVE.mode = 'connecting';
+    liveOpen();
+  }
+  // ── honesty: how old the counts on screen are ──
+  /** "As of 2 min ago" when the counts are older than 30 s and the page is not live; '' when live, or with no stream
+   *  at all (7.0.0 showed none). */
+  function liveAge(now) {
+    if (LIVE.mode === 'idle' || LIVE.mode === 'absent' || LIVE.mode === 'connecting') return '';
+    var at = Math.max(LIVE.freshAt || 0, LIVE.mode === 'live' && !LIVE.degraded.registry ? LIVE.frameAt : 0);
+    if (!at) return '';
+    var s = Math.max(0, ((now || Date.now()) - at) / 1000);
+    if (s * 1000 < LIVE_STALE_MS) return '';
+    if (s < 60) return 'As of ' + Math.floor(s) + ' s ago';
+    if (s < 3600) return 'As of ' + Math.floor(s / 60) + ' min ago';
+    return 'As of ' + Math.floor(s / 3600) + ' h ago';
+  }
+  /** The running clock: "12s", "4m 12s", "1h 5m". */
+  function liveClock(sec) {
+    var s = Math.max(0, Math.floor(sec));
+    if (s < 60) return s + 's';
+    if (s < 3600) return Math.floor(s / 60) + 'm ' + (s % 60) + 's';
+    return Math.floor(s / 3600) + 'h ' + Math.floor((s % 3600) / 60) + 'm';
+  }
+  /** Seconds a working row has run: from the stream's turnStartedAt (skew from the frame's `at`), else the row's own
+   *  state_since on the Mac's clock. */
+  function liveElapsed(row, now) {
+    var t = now || Date.now();
+    if (row && typeof row._liveTurnAt === 'number') return (t - LIVE.skew - row._liveTurnAt) / 1000;
+    var d = row ? toDate(row.state_since || row.last_activity_at) : null;
+    return d ? (sxServerTime(t) - d.getTime()) / 1000 : 0;
+  }
+  /** Server ms a row's clock counts from, for the data attribute the 1 s tick reads. */
+  function liveSince(row) {
+    if (row && typeof row._liveTurnAt === 'number') return row._liveTurnAt;
+    var d = row ? toDate(row.state_since || row.last_activity_at) : null;
+    return d ? d.getTime() - SX_CLOCK.skew - LIVE.skew : null;
+  }
+  // ── the 1 s tick: every running clock on screen, never on a hidden page ──
+  var LIVE_TICK = { timer: null };
+  function liveTickStart() {
+    if (LIVE_TICK.timer) return;
+    LIVE_TICK.timer = setInterval(liveTickOnce, 1000);
+  }
+  function liveTickStop() { clearInterval(LIVE_TICK.timer); LIVE_TICK.timer = null; }
+  function liveTickOnce() {
+    if (document.hidden) return;   // paused while hidden; visible again paints at once (liveResume, liveNoteTick)
+    var els = document.querySelectorAll('[data-live-since]'), now = Date.now();
+    if (!els.length && !liveNoteBusy()) { liveTickStop(); return; }
+    for (var i = 0; i < els.length; i++) {
+      var since = Number(els[i].getAttribute('data-live-since'));
+      if (isFinite(since)) els[i].textContent = liveClock((now - LIVE.skew - since) / 1000);
+    }
+    liveNoteTick();
+  }
+  // Repaints are batched: a burst of frames paints once.
+  function livePaint(rows, structural) {
+    LIVE.pendingRows = (LIVE.pendingRows || []).concat(rows || []);
+    LIVE.pendingStructural = LIVE.pendingStructural || !!structural;
+    if (LIVE.paintTimer) return;
+    LIVE.paintTimer = setTimeout(function () {
+      var r = LIVE.pendingRows || [], st = LIVE.pendingStructural;
+      LIVE.paintTimer = null; LIVE.pendingRows = []; LIVE.pendingStructural = false;
+      try { liveRepaint(r, st); } catch (err) { console.error(err); }
+    }, 30);
+  }
   // ── the session pet (Today) ─────────────────────────────
   // Same pet and the same pose rule as COS Control (PetSpritePose.resolve): waiting with nothing running
   // is "waiting", then one, two, three, four or more sessions in play are working, duel, trio, swarm, an open
@@ -665,28 +1364,32 @@
   }
 
   // ── Today ───────────────────────────────────────────────
-  function loadToday() {
+  // force (7.0.1, Today's Refresh): every source read again now, none from a cache. Resolves when the sessions, Work,
+  // welcome and recording reads have painted.
+  function loadToday(force) {
     var now = new Date();
     $('today-date').textContent = now.toLocaleDateString(undefined, { weekday: 'long', month: 'long', day: 'numeric' }) + ', ' + clock(now);
     var gen = ++TODAY.gen;
     // Voices and memories answer on their own time (the memories status runs a CLI on the Mac): Today paints what it
     // has and says it is still reading, then repaints as each one lands.
-    if (Date.now() - TODAY.extraAt > 60000 || TODAY.voices.state === 'failed' || TODAY.memories.state === 'failed') {
+    var extras = [];
+    if (force === true || Date.now() - TODAY.extraAt > 60000 || TODAY.voices.state === 'failed' || TODAY.memories.state === 'failed') {
       TODAY.extraAt = Date.now();
       TODAY.voices = { state: 'pending', groups: [] }; TODAY.memories = { state: 'pending', n: 0 };
-      api('/api/voice/held-groups').then(function (d) {
+      extras.push(api('/api/voice/held-groups').then(function (d) {
         TODAY.voices = { state: 'answered', groups: (d && Array.isArray(d.groups)) ? d.groups : [] };
-      }, function () { TODAY.voices = { state: 'failed', groups: [] }; }).then(function () { paintNeeds(); });
-      api('/api/web-bridge/memories', { method: 'POST', body: { id: 'today-status', op: 'status', args: {} } }).then(function (d) {
+      }, function () { TODAY.voices = { state: 'failed', groups: [] }; }).then(function () { paintNeeds(); }));
+      extras.push(api('/api/web-bridge/memories', { method: 'POST', body: { id: 'today-status', op: 'status', args: {} } }).then(function (d) {
         var n = d && d.details ? d.details.learningToReview : null;
         TODAY.memories = typeof n === 'number' ? { state: 'answered', n: Math.max(0, n) } : { state: 'failed', n: 0 };
-      }, function () { TODAY.memories = { state: 'failed', n: 0 }; }).then(function () { paintNeeds(); });
+      }, function () { TODAY.memories = { state: 'failed', n: 0 }; }).then(function () { paintNeeds(); }));
     }
-    Promise.all([
-      sessionList(15000).catch(function () { return null; }),
+    var main = Promise.all([
+      sessionList(force === true ? 0 : 15000).catch(function () { return null; }),
       api('/api/work-board/your-move').catch(function () { return null; }),
       api('/api/welcome-context').catch(function () { return null; }),
-      api('/api/meetings/live-chunks').catch(function () { return null; })
+      api('/api/meetings/live-chunks').catch(function () { return null; }),
+      loadRunJobs()
     ]).then(function (res) {
       if (gen !== TODAY.gen) return;
       var sessions = (res[0] && res[0].sessions) || [];
@@ -698,6 +1401,9 @@
       var open = sessions.filter(function (s) { return s.running && !s.running_active; });
       var recent = live.filter(function (s) { return Date.now() - (s.mtimeMs || 0) < LIVE_FRESH_MS; });
       var offline = !res[0] && !res[1];
+      // 7.0.5: the sessions or Today read recovered from a failed one, so the next summary ask says "reconnect" (the
+      // server lets that one start skip its 10-minute spacing, at most once per 10 minutes).
+      if ((TODAY.sessionsState === 'failed' || TODAY.offline === true) && res[0] && !offline) BRIEF.reconnect = true;
       TODAY.needs = needs; TODAY.working = working; TODAY.open = open; TODAY.welcome = welcome; TODAY.offline = offline; TODAY.at = Date.now();
       // your-move answers {available:false} when the board cannot be read: that is a failed read, not "nothing".
       TODAY.sessionsState = res[0] ? 'answered' : 'failed';
@@ -706,19 +1412,25 @@
       TODAY.recording = false;
 
       renderRunning(working, open);
+      runJobsSchedule();
       if (!offline) renderPet(sessions);
       paintNeeds();
       renderWeather(welcome);
       renderNext(welcome);
+      // PH plan P1: the rest of today under Next up. Kept out of renderNext so that stays a pure render.
+      var nx = welcome && welcome.nextEvent;
+      loadCalendarLater(nx, nx && toDate(nx.time));
       loadTodayIntake();
       setBadge('sessions', working.length > 0);
-      liveSession(recent).then(function (rec) {
+      return liveSession(recent).then(function (rec) {
         if (gen !== TODAY.gen) return;
         renderRecording(rec);
         setBadge('meetings', !!rec);
         if (rec) { TODAY.recording = true; paintNeeds(); }
       });
     });
+    // A forced read waits for the voices and memories too, so the summary it asks for sees every source.
+    return force === true ? Promise.all([main].concat(extras)) : main;
   }
   // A capture counts as live only while it is still being written: an abandoned
   // active-sessions file must never read as "Recording now".
@@ -738,19 +1450,21 @@
     var box = $('today-rec');
     if (!rec) { box.innerHTML = ''; return; }
     box.innerHTML = '<button type="button" class="rec-banner" data-goto="meetings"><span class="rec-dot"></span>' +
-      '<span class="rec-copy"><strong>Recording now</strong><span>' + esc(rec.source + (rec.startTime ? ', ' + span(rec.startTime) + ' so far' : '')) + '</span></span>' +
+      '<span class="rec-copy"><strong>Recording now</strong><span>' + esc(rec.source + (rec.startTime ? ', ' + span(rec.startTime) + ' so far' : '') + (rec.source === SOURCES.mac ? '. Stop it in COS Control on your Mac.' : '')) + '</span></span>' +
       '<span class="btn small">Live view</span></button>';
   }
   // ── The Today summary (6.99.26 candidate) ───────────────
-  // "The orchestrator's eyes" (Miles, 11/07): two or three sentences on what the sessions add up to, written by Haiku on
+  // "The orchestrator's eyes" (Miles, 11/07): two or three sentences on what the sessions add up to, written by Sonnet on
   // the server (lib/today-brief.ts). Today sends what it already read: session titles, states, how long, each session's
   // latest line and what needs you. The server decides whether a new one is written (off unless switched on, only when
-  // the inputs changed, 10 minutes apart, 60 a day, a breaker). Today never waits for it: the counts line paints at once
-  // and the summary replaces it when one arrives. Never shown over a session list that was not read.
-  var BRIEF = { view: null, inflight: false, sentKey: '', sentAt: 0 };
+  // the inputs changed, 10 minutes apart, the Summaries per day cap, a breaker). Today never waits for it: the counts line paints at once
+  // and the summary replaces it when one arrives. T1 spec (lead 23:04, same rule as Control 0.5.388): today's summary
+  // stays through a pending or failed session read (its age line already says what could not be read), the block keeps
+  // its tallest height so nothing under it moves while Miles reads, and unchanged text is never written again.
+  var BRIEF = { view: null, inflight: false, sentKey: '', sentAt: 0, reconnect: false, heldPx: 0, heldDay: '', heldWidth: -1, shownKind: '', shownText: '', shownEl: null };
   // 6.99.26 QA: the same rows are asked about again only after five minutes (a Today that sits open still learns what
   // the server reads itself: sub-agents and Work cards); changed rows are asked about at once, one ask at a time.
-  var BRIEF_RESEND_MS = 5 * 60000, BRIEF_OFF_RECHECK_MS = 5 * 60000, BRIEF_TICK_MS = 60000;
+  var BRIEF_RESEND_MS = 5 * 60000, BRIEF_OFF_RECHECK_MS = 5 * 60000, BRIEF_TICK_MS = 60000, BRIEF_LIVE_GAP_MS = 60000;
   function briefMinutes(v) { var d = toDate(v); return d ? Math.max(0, Math.round((Date.now() - d.getTime()) / 60000)) : 0; }
   function briefInputs(m) {
     var sessions = [];
@@ -783,23 +1497,68 @@
     var body = briefInputs(m);
     var key = JSON.stringify([body.sessions.map(function (s) { return [s.title, s.state, s.line, s.waiting, s.agents]; }), body.needs, body.later, body.sessionsRead, body.needsComplete, body.unread, body.recording]);
     var since = Date.now() - BRIEF.sentAt;
-    if (BRIEF.view && BRIEF.view.state === 'off' ? since < BRIEF_OFF_RECHECK_MS : key === BRIEF.sentKey && since < BRIEF_RESEND_MS) return;
+    // 7.0.5: right after a read recovered, ask at once (the server still holds its own gates).
+    var reconnect = BRIEF.reconnect && !(BRIEF.view && BRIEF.view.state === 'off');
+    if (!reconnect) {
+      if (BRIEF.view && BRIEF.view.state === 'off' ? since < BRIEF_OFF_RECHECK_MS : key === BRIEF.sentKey && since < BRIEF_RESEND_MS) return;
+      // 7.0.1: with the live stream Today repaints on every session move, so a changed Today asks at most once a minute
+      // (Refresh asks at once). Without it, 7.0.0's rule above is the only one.
+      if (typeof liveOn === 'function' && liveOn() && since < BRIEF_LIVE_GAP_MS) return;
+    }
+    BRIEF.reconnect = false;
+    if (reconnect) body.reason = 'reconnect';
     BRIEF.inflight = true; BRIEF.sentKey = key; BRIEF.sentAt = Date.now();
-    api('/api/today/brief', { method: 'POST', body: body, timeoutMs: 45000 }).then(function (v) {
+    var ask = function (b) { return api('/api/today/brief', { method: 'POST', body: b, timeoutMs: 45000 }); };
+    ask(body).catch(function (err) {
+      // A server before 7.0.5 refuses the unknown `reason` (400 invalid_today_brief): ask it the ordinary way.
+      if (!(reconnect && err && err.status === 400 && err.code === 'invalid_today_brief')) throw err;
+      var again = {};
+      Object.keys(body).forEach(function (k) { if (k !== 'reason') again[k] = body[k]; });
+      return ask(again);
+    }).then(function (v) {
       BRIEF.view = v && typeof v === 'object' ? v : null;
     }, function () { /* keep what was shown: the counts line or the last summary */ }).then(function () {
       BRIEF.inflight = false;
       if (TODAY.model && state.pane === 'today') renderStory(TODAY.model);
     });
   }
-  /** The summary to show, or null: only with text, only over a session list that was read. */
+  /** The summary to show, or null: only with text, fresh or stale, and written today. T1 spec 0: a session read that is
+   *  pending or failed no longer swaps it for the counts line (an offline Today still hides it, in renderStory). */
   function briefShown() {
     var v = BRIEF.view;
-    if (!v || !v.text || (v.state !== 'fresh' && v.state !== 'stale') || TODAY.sessionsState !== 'answered') return null;
+    if (!v || !v.text || (v.state !== 'fresh' && v.state !== 'stale')) return null;
+    var at = toDate(v.at);
+    if (!at || at.toDateString() !== new Date().toDateString()) return null;
     return v;
   }
-  // Forget the summary (Settings turned it on or off): the next Today paint asks at once.
-  function resetBrief() { BRIEF.view = null; BRIEF.sentKey = ''; BRIEF.sentAt = 0; }
+  // Forget the summary (Settings turned it on or off): the next Today paint asks at once, and the block may shrink.
+  function resetBrief() { BRIEF.view = null; BRIEF.sentKey = ''; BRIEF.sentAt = 0; BRIEF.heldPx = 0; }
+  // T1 spec 1 and 2: #today-story keeps the tallest height it has had, so a shorter rewrite, or the fall back to the
+  // counts line, never pulls the page up under Miles. It may shrink on a new local day, when its width changes (resize,
+  // Duo fold or unfold, rotation reflow the text anyway), after Refresh lands and after resetBrief; never on a rewrite.
+  function storyHold(el) {
+    if (!el || !el.style || typeof el.getBoundingClientRect !== 'function') return;
+    var day = new Date().toDateString(), w = el.clientWidth || 0;
+    if (BRIEF.heldDay !== day || Math.abs(w - BRIEF.heldWidth) >= 1) { BRIEF.heldPx = 0; BRIEF.heldDay = day; BRIEF.heldWidth = w; }
+    el.style.minHeight = '';
+    var h = Math.ceil(el.getBoundingClientRect().height || 0);
+    if (h > BRIEF.heldPx) BRIEF.heldPx = h;
+    el.style.minHeight = BRIEF.heldPx ? BRIEF.heldPx + 'px' : '';
+  }
+  // T1 spec 3: Today repaints on every session move; the same words are not written again (no reflow, no aria-live
+  // re-announcement). Only the age line under a summary moves on.
+  function storyWrite(el, kind, text, when) {
+    if (BRIEF.shownEl !== el || BRIEF.shownKind !== kind || BRIEF.shownText !== text) {
+      if (kind === 'brief') el.innerHTML = esc(text) + '<span class="story-when">' + esc(when) + '</span>';
+      else el.textContent = text;
+      BRIEF.shownEl = el; BRIEF.shownKind = kind; BRIEF.shownText = text;
+    } else if (kind === 'brief') {
+      var w = typeof document !== 'undefined' && document.querySelector ? document.querySelector('#today-story .story-when') : null;
+      if (w) { if (w.textContent !== when) w.textContent = when; }
+      else el.innerHTML = esc(text) + '<span class="story-when">' + esc(when) + '</span>';
+    }
+    storyHold(el);
+  }
   // Every minute while Today is on screen: "Updated N min ago" moves on, and an unchanged Today asks again once its
   // five minutes are up (requestBrief's own throttle). Hidden or another pane: nothing.
   setInterval(function () {
@@ -821,13 +1580,22 @@
   function renderStory(m) {
     var el = $('today-story');
     el.className = 'story';
-    if (TODAY.offline) { el.textContent = 'COS on ' + state.serverName + ' is not answering right now. Today fills in when it does.'; return; }
+    // Today round 2: "Ask about this" shows under a model summary only (paintTodayAsk, below the Today block). The test
+    // harnesses that run this block alone do not have it, so it is looked up, never assumed.
+    var askBox = typeof paintTodayAsk === 'function' ? paintTodayAsk : function () {};
+    // The harnesses that run this block alone have no storyWrite either: a plain write there.
+    var write = typeof storyWrite === 'function' ? storyWrite : function (e, kind, text, when) {
+      if (kind === 'brief') e.innerHTML = esc(text) + '<span class="story-when">' + esc(when) + '</span>'; else e.textContent = text;
+    };
+    if (TODAY.offline) { askBox(null); write(el, 'offline', 'COS on ' + state.serverName + ' is not answering right now. Today fills in when it does.'); return; }
     // The model's summary when there is one (it never blocks: the counts line below shows until it lands). The test
     // harnesses that run this block alone have no requestBrief, so it is looked up, never assumed.
+    askBox(null);
     if (typeof requestBrief === 'function') {
       requestBrief(m);
       var brief = briefShown();
-      if (brief) { el.innerHTML = esc(brief.text) + '<span class="story-when">' + esc(briefWhen(brief, m)) + '</span>'; return; }
+      askBox(brief);
+      if (brief) { write(el, 'brief', brief.text, briefWhen(brief, m)); return; }
     }
     var first = '';
     if (m.sessionsWaiting > 0) first = countWord(m.sessionsWaiting) + ' ' + plural(m.sessionsWaiting, 'session is', 'sessions are') + ' waiting on you';
@@ -851,35 +1619,240 @@
     var others = m.failed.filter(function (n) { return n !== 'sessions'; });
     if (!m.settled && !m.now.length && !m.later.length) out += (unread ? others : m.failed).length ? ' Couldn\u2019t read ' + listWords(unread ? others : m.failed) + ', so this may not be everything.' : unread ? ' This may not be everything that needs you.' : ' Still reading what needs you.';
     else if (unread) out += ' This may not be everything that needs you.';
-    el.textContent = out;
+    write(el, 'counts', out);
   }
   function listWords(names) { return names.length < 2 ? names.join('') : names.slice(0, -1).join(', ') + ' and ' + names[names.length - 1]; }
   function runRow(s, activeNow) {
     var key = splitSessionId(s.provider, s.session_id);
+    // 7.0.1: with the live stream, a working row's clock ticks every second from the turn's start (liveTickOnce).
+    // Without it (an older server, the switch off), the minute line 7.0.0 showed.
+    var since = activeNow && typeof liveOn === 'function' && liveOn() ? liveSince(s) : null;
     var meta = activeNow
-      ? 'Working for ' + span(s.state_since || s.last_activity_at)
+      ? 'Working for ' + (since != null ? '\u0000' : span(s.state_since || s.last_activity_at))
       : 'Open, quiet for ' + span(s.last_activity_at || s.state_since);
     if (s.project && s.project !== usualProject()) meta += ', in ' + String(s.project).replace(/^-Users-[^-]+-/, '');
+    var metaHtml = since != null
+      ? esc(meta).replace('\u0000', '<span class="run-clock" data-live-since="' + esc(String(since)) + '">' + esc(liveClock(liveElapsed(s))) + '</span>')
+      : esc(meta);
     // A tap opens the peek on Today (panes/today-actions.js); it falls back to the reader if the peek cannot load.
     return '<button type="button" class="run-row" data-today="run" data-key="' + esc(key.provider) + '|' + esc(key.id) + '">' +
       '<span class="run-who">' + badge(key.provider) + (activeNow ? '<span class="pulse" aria-label="working"></span>' : '') + '</span>' +
       '<span class="run-title">' + esc(sessionTitle(s)) + '</span>' +
-      '<span class="run-meta">' + esc(meta) + '</span></button>';
+      '<span class="run-meta">' + metaHtml + '</span></button>';
   }
   function renderRunning(working, open) {
-    $('run-count').textContent = working.length ? String(working.length) : '';
+    // W1: COS's own jobs (questions it is answering, routines, Work runs) count as running too, as on the Mac.
+    var jobs = typeof runJobsHtml === 'function' ? runJobsHtml() : { html: '', n: 0 };
+    $('run-count').textContent = working.length + jobs.n ? String(working.length + jobs.n) : '';
     var list = $('run-list');
     // Never "Nothing running" about a list that was not read.
-    if (TODAY.sessionsState === 'failed') { list.innerHTML = '<button type="button" class="run-more run-failed" data-today-needs="retry">Couldn\u2019t read sessions. Try again</button>'; return; }
+    if (TODAY.sessionsState === 'failed') { list.innerHTML = jobs.html + '<button type="button" class="run-more run-failed" data-today-needs="retry">Couldn\u2019t read sessions. Try again</button>'; return; }
     var shown = working.slice(0, 3);
-    var html = shown.map(function (s) { return runRow(s, true); }).join('');
+    var html = jobs.html + shown.map(function (s) { return runRow(s, true); }).join('');
     if (!shown.length) {
-      html = open.slice(0, 2).map(function (s) { return runRow(s, false); }).join('');
+      html = jobs.html + open.slice(0, 2).map(function (s) { return runRow(s, false); }).join('');
       if (!html) html = '<div class="run-empty">Nothing running. Start a session on your Mac and it shows here.</div>';
     }
     var more = (working.length - shown.length) + (shown.length ? open.length : Math.max(0, open.length - 2));
     if (more > 0) html += '<button type="button" class="run-more" data-goto="sessions">' + countWord(more) + ' more open. All sessions</button>';
     list.innerHTML = html;
+    if (typeof liveTickStart === 'function' && list.querySelector && list.querySelector('[data-live-since]')) liveTickStart();
+  }
+  // ── Running beyond sessions (W1, 7.0.x): audit 02 F10, Q1 M6. The same job rows COS Control 0.5.386 draws
+  // (Models.swift TodayHome running rows, b02d1ad 14185-14207), from the same server list, GET /api/query-jobs/active
+  // (titles only, never a prompt or an answer):
+  //   person   "A question to COS" row, "COS is answering, N min", Open in Messages
+  //   routine  "Routine" row, "running since 7:30 PM", Open in Messages
+  //   task     "A captured task" row, "a captured task, on the server, N min", In Sessions
+  //   other    never a row: it is a Control Work session or a meeting review, already shown as the row it is
+  // No Stop on any of them, as on the Mac: Control's only Stop is on a Work run it started itself, which lives in the Mac's
+  // own handoff store and is not visible to this page.
+  var RUN_JOB_ROW = {
+    person: { word: 'Question', title: 'A question to COS', open: 'messages', label: 'Open in Messages' },
+    routine: { word: 'Routine', title: 'Routine', open: 'messages', label: 'Open in Messages' },
+    task: { word: 'Work', title: 'A captured task', open: 'sessions', label: 'In Sessions' },
+  };
+  var RUN_JOBS = { items: null, timer: null };
+  var RUN_JOBS_POLL_MS = 15000;
+  function runJobValid(j) { return j && typeof j.jobId === 'string' && /^[A-Za-z0-9_-]{1,80}$/.test(j.jobId) && RUN_JOB_ROW[j.origin]; }
+  function loadRunJobs() {
+    return api('/api/query-jobs/active').then(function (d) {
+      // An older server answers 400 or no protocol: no jobs row, never an error line (Control keys off the field, not the status).
+      RUN_JOBS.items = d && d.protocolVersion === 1 && d.enabled !== false && Array.isArray(d.items) ? d.items.filter(runJobValid).slice(0, 8) : [];
+    }, function () { RUN_JOBS.items = null; });
+  }
+  function runJobsSchedule() {
+    if (RUN_JOBS.timer) { clearTimeout(RUN_JOBS.timer); RUN_JOBS.timer = null; }
+    if (!RUN_JOBS.items || !RUN_JOBS.items.length) return;
+    RUN_JOBS.timer = setTimeout(function () {
+      RUN_JOBS.timer = null;
+      // Only while Today is in front: a hidden page reads nothing (it reads again when Today comes back).
+      if (state.pane !== 'today' || document.hidden) return;
+      loadRunJobs().then(function () { renderRunning(TODAY.working || [], TODAY.open || []); runJobsSchedule(); });
+    }, RUN_JOBS_POLL_MS);
+  }
+  function runJobMinutes(j) { return Math.max(0, Math.round((Number(j.elapsedMs) || 0) / 60000)); }
+  function runJobRow(j) {
+    var kind = RUN_JOB_ROW[j.origin], mins = runJobMinutes(j);
+    var started = new Date(Date.now() - (Number(j.elapsedMs) || 0));
+    var meta = j.origin === 'routine' ? 'running since ' + clock(started)
+      : j.origin === 'person' ? 'COS is answering, ' + mins + ' min'
+      : 'a captured task, on the server, ' + mins + ' min';
+    return '<div class="run-row run-job"><span class="run-who"><span class="badge work">' + esc(kind.word) + '</span></span>' +
+      '<span class="run-title">' + esc(plain(j.title || '').trim() || kind.title) + '</span>' +
+      '<span class="run-meta">' + esc(meta) + '</span>' +
+      '<span class="row-actions"><button type="button" class="link-btn" data-goto="' + kind.open + '">' + esc(kind.label) + '</button></span></div>';
+  }
+  function runJobsHtml() {
+    var items = RUN_JOBS.items || [];
+    return { html: items.map(runJobRow).join(''), n: items.length };
+  }
+  // ── end running beyond sessions
+
+  // ── live state on screen (7.0.1): Today's counts and rows, the pet, the Sessions rows, the header line ──
+  // The live model (above) calls this, batched, after a frame or a list read moved something.
+  function liveRepaint(rows, structural) {
+    if (!liveSignedIn()) return;
+    if (state.pane === 'today' && TODAY.at && !TODAY.offline && TODAY.sessionsState === 'answered') {
+      var sessions = state.sessions || [];
+      TODAY.working = sessions.filter(function (s) { return s.running_active; });
+      TODAY.open = sessions.filter(function (s) { return s.running && !s.running_active; });
+      renderRunning(TODAY.working, TODAY.open);
+      renderPet(sessions);
+      paintNeeds();
+      setBadge('sessions', TODAY.working.length > 0);
+    }
+    if (state.pane === 'sessions' && SX.rows && SX.view === 'sessions') liveSessionRows(rows, structural);
+    liveNoteTick();
+  }
+  // Sessions: a row whose state moved is redrawn where it stands (the list never jumps under a finger); a session that
+  // appeared or left redraws the list. A search on screen keeps its hits; only the hero's counts move.
+  function liveSessionRows(rows, structural) {
+    var list = $('sessions-list');
+    if (!list) return;
+    if (sxQueryActive()) { paintSessionsHero(); return; }
+    if (structural) { renderSessionGroups(); return; }
+    var amb = sxAmbiguous(sxVisible());
+    (rows || []).forEach(function (s) {
+      if (!s || sxKeepWarm(s)) return;
+      var k = splitSessionId(s.provider, s.session_id || s.id), want = k.provider + '|' + k.id;
+      var els = list.querySelectorAll('[data-session]');
+      for (var i = 0; i < els.length; i++) {
+        if (els[i].getAttribute('data-session') !== want) continue;
+        var html = sxRow(s, null, amb);
+        if (els[i].__liveHtml !== html) {
+          var tmp = document.createElement('div'); tmp.innerHTML = html;
+          var next = tmp.firstElementChild || tmp.firstChild;
+          if (next) { next.__liveHtml = html; els[i].parentNode.replaceChild(next, els[i]); }
+        }
+        break;
+      }
+    });
+    paintSessionsHero();
+  }
+  // ── Today's header line and Refresh ──
+  // Refresh (Miles 11/07: "a 'refresh' button to the home 'today' tab that allows the user to get the latest state and
+  // to update the summary"): every Today source read again now, then a new summary asked for with force (the server
+  // still holds its switch, its one-per-30-s refresh limit and its daily cap, and says which in `reason`).
+  var TR = { busy: false, doneAt: 0, msg: '', retryAt: 0 };
+  var TR_REASONS = {
+    daily_cap: 'Daily summary limit reached',
+    recording: 'No new summary while a meeting records',
+    maintenance: 'No new summary while COS updates',
+    paused: 'The summary is paused for now. Try again later',
+    failed: 'The summary did not update',
+    interval: 'The summary updated recently. Try again in a few minutes'
+  };
+  /** The words for a refresh answer, or '' when the summary updated (or is switched off). */
+  function refreshWords(v) {
+    if (!v || typeof v !== 'object') return '';
+    if (typeof v.message === 'string' && v.message.trim()) return v.message.trim();
+    if (v.state === 'off') return '';
+    if (v.reason === 'refresh_throttled') return '';
+    return v.state === 'fresh' && !v.reason ? '' : (TR_REASONS[v.reason] || '');
+  }
+  function todayRefresh() {
+    if (TR.busy) return Promise.resolve(false);
+    TR.busy = true; TR.msg = ''; TR.retryAt = 0;
+    var btn = $('today-refresh'); if (btn) btn.disabled = true;
+    liveNoteTick();
+    var done = function (msg) {
+      TR.busy = false; TR.doneAt = Date.now(); TR.msg = msg || '';
+      var b = $('today-refresh'); if (b) b.disabled = false;
+      liveNoteTick(); liveTickStart();
+      return true;
+    };
+    return Promise.resolve(loadToday(true)).then(function () {
+      if (typeof liveOn === 'function' && liveOn()) LIVE.freshAt = Date.now();
+      if (!TODAY.model || TODAY.offline) return done('');
+      // The summary switched off: the state only.
+      if (BRIEF.view && (BRIEF.view.state === 'off' || BRIEF.view.enabled === false)) return done('');
+      var body = briefInputs(TODAY.model);
+      body.force = true;
+      BRIEF.inflight = true;
+      // A 7.0.0 server refuses the unknown `force` (400 invalid_today_brief): ask it the ordinary way instead.
+      var ask = function (b) { return api('/api/today/brief', { method: 'POST', body: b, timeoutMs: 45000 }); };
+      return ask(body).catch(function (err) {
+        if (!(err && err.status === 400 && err.code === 'invalid_today_brief')) throw err;
+        delete body.force;
+        return ask(body);
+      }).then(function (v) {
+        BRIEF.inflight = false;
+        if (v && typeof v === 'object') { BRIEF.view = v; BRIEF.sentAt = Date.now(); }
+        if (v && v.reason === 'refresh_throttled') TR.retryAt = Date.now() + Math.max(1000, Number(v.retryAfterMs) || 30000);
+        // T1 spec 2: Refresh re-fits the block to what it now holds.
+        BRIEF.heldPx = 0;
+        if (TODAY.model && state.pane === 'today') renderStory(TODAY.model);
+        return done(refreshWords(v));
+      }, function (err) {
+        BRIEF.inflight = false;
+        return done(err && err.code === 'unreachable' ? err.message : 'The summary did not update');
+      });
+    }, function () { return done('Could not read everything. Try again'); });
+  }
+  function liveNoteBusy() {
+    var now = Date.now();
+    return TR.busy || TR.retryAt > now || (TR.doneAt && now - TR.doneAt < 10 * 60000) || !!liveAge(now) || LIVE.mode === 'reconnecting';
+  }
+  /** The line beside Refresh: Updating, Reconnecting, the counts' age, when Today was refreshed, the server's limit. */
+  function liveNoteText(now) {
+    now = now || Date.now();
+    if (TR.busy) return 'Updating';
+    var parts = [];
+    if (LIVE.mode === 'reconnecting') parts.push('Reconnecting');
+    var age = liveAge(now);
+    if (age) parts.push(age);
+    if (TR.doneAt && !age) {
+      var m = Math.floor((now - TR.doneAt) / 60000);
+      if (m < 10) parts.push(m < 1 ? 'Updated just now' : 'Updated ' + m + ' min ago');
+    }
+    if (TR.retryAt > now) parts.push('Try again in ' + Math.ceil((TR.retryAt - now) / 1000) + ' s');
+    else if (TR.msg && TR.doneAt && now - TR.doneAt < 10 * 60000) parts.push(TR.msg);
+    return parts.join('. ');
+  }
+  /** What the line says, without its numbers: the polite status line speaks only when this changes (review N10). */
+  function liveNoteState(now) {
+    now = now || Date.now();
+    var age = liveAge(now);
+    return [TR.busy ? 'busy' : '', LIVE.mode === 'reconnecting' ? 'reconnecting' : '', age ? 'age' : '',
+      TR.doneAt && !age && now - TR.doneAt < 10 * 60000 ? 'done' : '', TR.retryAt > now ? 'retry' : '',
+      TR.msg && TR.doneAt && now - TR.doneAt < 10 * 60000 ? TR.msg : ''].join('|');
+  }
+  function liveNoteTick() {
+    var el = $('today-live-note'), t = liveNoteText();
+    if (el) { if (el.textContent !== t) el.textContent = t; el.classList.toggle('warn', LIVE.mode === 'reconnecting'); }
+    var said = $('today-live-status'), key = liveNoteState();
+    if (said && LIVE.noteSaid !== key) { LIVE.noteSaid = key; said.textContent = t; }
+    var sx = document.querySelector('#sessions-hero .sx-live-note');
+    if (sx) { var n = liveSessionsNote(); sx.textContent = n ? ' · ' + n : ''; }
+  }
+  /** The Sessions hero's honesty suffix: "Reconnecting" and the counts' age, or ''. */
+  function liveSessionsNote() {
+    var bits = [];
+    if (LIVE.mode === 'reconnecting') bits.push('Reconnecting');
+    var age = liveAge();
+    if (age) bits.push(age.charAt(0).toLowerCase() + age.slice(1));
+    return bits.join(' · ');
   }
   function needWhy(item) {
     var p = item.progress || {};
@@ -900,8 +1873,29 @@
   // Control's askedTitle and askedWhy for a session waiting on you.
   // Control's TodayHome: guarded(title) ?? "A session". Never the workspace path or the session id: this line is shown
   // on Today and goes into the Today summary sent to the model, which carries no ids.
+  // ── A turn that ended asking you (7.0.18, X1 contract v1; Miles 2026-11-10 07:14) ──
+  // A Claude session ended its turn with the app's next-step box: a question and reply buttons. The server marks the row
+  // (waiting_source 'turn_end', waiting_choices: 0 to 2 labels) only while COS_TURN_END_ASKS is on. Unlike a question at
+  // the Mac's prompt, a reply IS the answer here, so Today and the reader offer the choices and the reply box. What is
+  // sent is the contract's exact text: it never reads as typed at the desk, and the session may ask him to confirm.
+  var TURN_END_PREFIX = 'Answer sent from COS Control Web through COS, not typed in this session: ';
+  var TURN_END_LINE = 'A choice or a reply here reaches the session as a message from COS, not typed in the session, and the session may ask you to confirm.';
+  /** The turn-end ask on a session row, or null: any other row, an older server, or the switch off. */
+  function turnEndOf(s) {
+    if (!s || s.waiting_source !== 'turn_end' || s.agent_state !== 'waiting') return null;
+    var clean = function (v, n) { return String(v == null ? '' : v).replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2066-\u2069]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, n); };
+    var choices = Array.isArray(s.waiting_choices) ? s.waiting_choices.filter(function (c) { return typeof c === 'string' && clean(c, 40); }).map(function (c) { return clean(c, 40); }).slice(0, 2) : [];
+    return { ask: clean(s.waiting_detail, 160), choices: choices };
+  }
+  /** The exact words a choice or a reply sends (contract v1): attributed to COS Control Web, never to the desk. */
+  function turnEndPrompt(text) { return TURN_END_PREFIX + turnEndBare(text); }
+  /** The words as he wrote them: a message that came back to the box already carries the prefix, never twice. */
+  function turnEndBare(text) { var t = String(text || '').trim(); return t.indexOf(TURN_END_PREFIX) === 0 ? t.slice(TURN_END_PREFIX.length).trim() : t; }
   function askedTitle(s) {
     var t = plain(s.display_label || s.custom_title || '').replace(/\s+/g, ' ').trim() || 'A session';
+    // The harnesses that run this block alone have no turnEndOf: looked up, never assumed.
+    var te = typeof turnEndOf === 'function' ? turnEndOf(s) : null;
+    if (te) return te.ask ? t + ' asked: ' + te.ask : t + ' asked you something';
     if (sxProvider(s.provider) !== 'claude') return t + ' is waiting for your reply';
     if (s.waiting_kind === 'plan') return t + ' has a plan for you to approve';
     if (s.waiting_kind === 'permission') return t + ' wants your permission';
@@ -912,12 +1906,20 @@
   var TOOL_NAMES = ['AskUserQuestion', 'ExitPlanMode', 'Bash', 'BashOutput', 'KillShell', 'Edit', 'Write', 'Read', 'Grep', 'Glob', 'LS', 'Task', 'Agent',
     'WebFetch', 'WebSearch', 'TodoWrite', 'NotebookEdit', 'MultiEdit', 'SlashCommand', 'Skill', 'ToolSearch'];
   function askedWhy(s) {
+    var te = typeof turnEndOf === 'function' ? turnEndOf(s) : null;
+    if (te) return te.choices.length ? 'Tap a choice or reply here' : 'Reply here';
     if (s.waiting_kind === 'plan') return 'Has a plan for you to approve';
     var d = String(s.waiting_detail || '').trim();
     if (TOOL_NAMES.indexOf(d) >= 0) d = '';
-    if (s.waiting_kind === 'permission' && d) return 'Wants to run ' + (d.length > 80 ? d.slice(0, 79) + '…' : d);
+    // 7.0.4 W5: the server shows the home folder in this command as "[home]" (lib/local-path-redact.ts COMMAND_KEYS), so
+    // the line is a display, labelled as one. The exact command is on the approval card, which is not redacted.
+    if (s.waiting_kind === 'permission' && d) {
+      var shown = d.length > 80 ? d.slice(0, 79) + '…' : d;
+      return d.indexOf('[home]') >= 0 ? 'Wants to run (home folder hidden) ' + shown : 'Wants to run ' + shown;
+    }
     if (s.waiting_kind === 'question' && d) return d.length > 160 ? d.slice(0, 159) + '…' : d;
-    return 'Waiting for you' + (sxProvider(s.provider) === 'claude' ? '. Paused until you answer.' : '');
+    // W1 A5: a Claude session waits on its own prompt; the card under it says where, once.
+    return sxProvider(s.provider) === 'claude' ? 'Waiting for your answer' : 'Waiting for you';
   }
   // 6.99.26: where a waiting session's question can be answered. 'here': this page holds it (panes/questions.js), as
   // cards in its waiting sheet. 'mac': a Claude session's own prompt (or a held one that went back to the Mac), which
@@ -932,16 +1934,111 @@
     return q && q.question ? clipWords(q.question, 160) : '';
   }
   function clipWords(text, n) { var t = String(text || '').replace(/\s+/g, ' ').trim(); return t.length > n ? t.slice(0, n - 1) + '…' : t; }
-  function whereFor(provider, id) {
+  function whereFor(provider, id, row) {
     var q = sessionQs();
     var held = q ? q.itemsFor(id) : [], mac = q && q.atMacFor ? q.atMacFor(id) : [];
     if (held.length) return { where: 'here', ask: askedHere(held) };
+    // 7.0.18: a turn that ended asking him is answered by a reply, here or anywhere: never "at the Mac".
+    var te = row && typeof turnEndOf === 'function' ? turnEndOf(row) : null;
+    if (te) return { where: 'turnend', ask: te.ask, choices: te.choices };
     if (q && q.answeredFor && q.answeredFor(id)) return { where: 'answered', ask: '' };
-    var words = mac.length && q.wordsOf ? q.wordsOf(mac[0].id) : null;
+    // X1 contract: a card built from the server's `waiting` list carries its own words; a held one gone back to the Mac
+    // has the words this page saw while it was held.
+    var first = mac[0];
+    var words = first && first.fromWaiting ? { questions: (first.questions || []).map(function (x) { return x.question; }), summary: '' }
+      : first && q.wordsOf ? q.wordsOf(first.id) : null;
     var ask = words ? clipWords(words.questions[0] || (words.summary ? 'Wants to run ' + words.summary : ''), 160) : '';
-    if (mac.length || sxProvider(provider) === 'claude') return { where: 'mac', ask: ask };
+    if (mac.length) return { where: 'mac', ask: ask };
+    // DESIGN.md step 4 #5: the Mac line only for a Claude row that waits on a question or an approval, never for any
+    // waiting Claude session. A row the page has not read says nothing about it, so it keeps the Mac line as before.
+    var kind = row ? String(row.waiting_kind || '') : '';
+    if (sxProvider(provider) === 'claude' && (!row || kind === 'question' || kind === 'permission')) return { where: 'mac', ask: ask };
     return { where: '', ask: '' };
   }
+  // ── At the Mac's prompt, in the session reader (W1 A5) ──
+  // Miles 11/09: "when I actually navigate to the session, there is no ability to answer the question." The reader cannot
+  // answer a question that waits on the Mac's own prompt either, so it says so at the top, with the words when this page
+  // has them (a held question it saw, or the server's waiting line) and plainly when it does not. Nothing here sends.
+  var MAC_Q = { line: "Answer this at your Mac's prompt. A message sent from here does not answer it; it waits until the question is answered at the Mac.", none: "COS cannot read this question's words from here. They show at the Mac's prompt." };
+  /** 7.0.18: the reader's card for a turn that ended asking him: the question, a button per choice, the honest line. */
+  function readerTurnEndHtml(r, row) {
+    var te = turnEndOf(row);
+    if (!te) return '';
+    var title = plain((row && (row.display_label || row.custom_title)) || '').replace(/\s+/g, ' ').trim() || 'This session';
+    var busy = !!(r && r.teSending);
+    return '<p class="sx-mac-q-title"><strong>' + esc(te.ask ? title + ' asked:' : title + ' asked you something') + '</strong></p>' +
+      (te.ask ? '<blockquote class="ta-quote sx-te-ask">' + esc(te.ask) + '</blockquote>' : '') +
+      (te.choices.length ? '<div class="sx-te-choices">' + te.choices.map(function (c, i) {
+        return '<button type="button" class="cx-btn' + (i === 0 ? ' primary' : '') + '" data-sx="turnend" data-i="' + i + '"' + (busy ? ' disabled' : '') + '>' + esc(c) + '</button>';
+      }).join('') + '</div>' : '') +
+      '<p class="sx-note sx-te-line">' + esc(TURN_END_LINE) + '</p>';
+  }
+  function readerMacHtml(provider, id, row) {
+    var w = whereFor(provider, id, row);
+    if (w.where !== 'mac') return '';
+    // X1 contract: when the server listed this question (`waiting`), the shared card list mounted above draws it, with
+    // its options. This block is only for a question it did not list (an older server, or asked before a restart).
+    var qs0 = sessionQs();
+    if (qs0 && qs0.atMacFor && qs0.atMacFor(id).length) return '';
+    var q = sessionQs();
+    var why = row ? askedWhy(row) : '';
+    var words = w.ask || (why && !/^Waiting for (you|your answer)/.test(why) ? why : '');
+    return '<p class="sx-mac-q-title"><strong>Waiting for your answer at the Mac</strong></p>' +
+      (words ? '<blockquote class="ta-quote sx-mac-q-words">' + esc(words) + '</blockquote>' : '<p class="sx-note sx-mac-q-none">' + esc((q && q.macNoWords) || MAC_Q.none) + '</p>') +
+      '<p class="sx-note sx-mac-q-line">' + esc((q && q.macLine) || MAC_Q.line) + '</p>';
+  }
+  function readerRowOf(r) {
+    return (state.sessions || []).filter(function (s) { var k = splitSessionId(s.provider, s.session_id || s.id); return k.provider === r.provider && String(k.id).toLowerCase() === String(r.id).toLowerCase(); })[0] || null;
+  }
+  // 7.0.18: a tap on a choice sends the contract's exact text through the reader's own Continue (continueSession), so the
+  // queue, the held reply and the turn watch behave as for any message. The outcome is said in the status line.
+  var TURN_END_SENT = function (label) { return 'Sent \u201c' + label + '\u201d. It reaches the session as a message from COS; it may ask you to confirm.'; };
+  var TURN_END_GONE = 'Already answered on another screen, or the session moved on. Nothing was sent.';
+  function sendTurnEndChoice(r, i) {
+    if (!r || r.sending) return;
+    var te = turnEndOf(readerRowOf(r));
+    if (!te) { sessionStatus(TURN_END_GONE); readerMacPaint(r, r.waitingNow); return; }
+    var label = te.choices[i];
+    if (!label) return;
+    r.sending = true; r.teSending = true; readerMacPaint(r, r.waitingNow);
+    var done = function () { r.sending = false; r.teSending = false; if (state.reading === r) readerMacPaint(r, r.waitingNow); };
+    return continueSession(r, turnEndPrompt(label), {}).then(function (how) {
+      done();
+      if (state.reading !== r) return how;
+      if (how === 'sent') sessionStatus(TURN_END_SENT(label));
+      else if (how === 'changed') {
+        // The box under it would offer Continue anyway for the composer's words, not this choice: a choice says it plainly.
+        r.refusal = null; r.sendAnyway = null; renderVerdict(r);
+        sessionStatus('The session moved on before this reached it. \u201c' + label + '\u201d was not sent.', 'error');
+      } else if (how === 'refused') sessionStatus('The session did not take \u201c' + label + '\u201d. Try again, or answer it on your Mac.', 'error');
+      return how;
+    }, function (err) {
+      done();
+      if (state.reading !== r) return;
+      var why = err && err.name === 'AbortError' ? 'No answer from your Mac yet. It may still land; tapping again is safe, it will not post twice.' : (err && err.message) || 'Could not reach your Mac.';
+      sessionStatus('Not sent: ' + why, 'error');
+    });
+  }
+  function readerMacPaint(r, waiting) {
+    var el = $('session-mac-q');
+    if (!el || !r) return;
+    r.waitingNow = !!waiting;
+    var row = readerRowOf(r);
+    // 7.0.18: a turn that ended asking him gets its card whether or not the reader thinks it waits (the row is the truth).
+    var te = typeof turnEndOf === 'function' ? turnEndOf(row) : null;
+    r.turnEnd = te;
+    var html = te ? readerTurnEndHtml(r, row) : waiting ? readerMacHtml(r.provider, r.id, row) : '';
+    if (el.innerHTML !== html) el.innerHTML = html;
+    el.hidden = !html;
+    // Q1 M3: the Send box under it says plainly that a message is not the answer, whichever block shows the question
+    // (this one, a Mac card or a held card above).
+    var qs1 = sessionQs(), open = (!!html && !te) || !!(qs1 && ((qs1.itemsFor && qs1.itemsFor(r.id).length) || (qs1.atMacFor && qs1.atMacFor(r.id).length)));
+    var box = $('session-input');
+    // 7.0.18: here a reply IS the answer (sent with the contract's attribution), so the box says so.
+    if (box && box.setAttribute) box.setAttribute('placeholder', te ? 'Or write your own answer' : open ? 'Message this session (not an answer)' : 'Continue this session…');
+  }
+  // ── end at the Mac's prompt
+
   function needsModel() {
     var states = { sessions: TODAY.sessionsState, work: TODAY.workState, voices: TODAY.voices.state, memories: TODAY.memories.state };
     var rows = [], seen = {};
@@ -949,8 +2046,8 @@
       if (sxKeepWarm(s) || sxState(s) !== 'waiting') return;
       var k = splitSessionId(s.provider, s.session_id || s.id);
       seen[k.provider + '|' + String(k.id).toLowerCase()] = 1;
-      var w = whereFor(k.provider, k.id);
-      rows.push({ kind: 'session', tier: 1, title: askedTitle(s), why: askedWhy(s), since: s.state_since || s.last_activity_at, key: k.provider + '|' + k.id, where: w.where, ask: w.ask });
+      var w = whereFor(k.provider, k.id, s);
+      rows.push({ kind: 'session', tier: 1, title: askedTitle(s), why: askedWhy(s), since: s.state_since || s.last_activity_at, key: k.provider + '|' + k.id, where: w.where, ask: w.ask, choices: w.choices || [] });
     });
     // A question this page holds for a session the list has not shown waiting yet: its own row, so every held
     // question is in front of you (two at once each get one).
@@ -966,6 +2063,11 @@
     (TODAY.needs || []).forEach(function (it) {
       var k = splitSessionId(it.provider, it.sessionId);
       if (k.id && seen[k.provider + '|' + String(k.id).toLowerCase()]) return;   // Control: a Work row for a waiting session is the session's row
+      // 7.0.1 (Miles 11/07): the server saw you start a turn in the session after its needs-input or blocked report
+      // (work-activity.ts supersededBy). That report is history, not something waiting on you. Only the item that
+      // regrouped to running leaves: a superseded completed handoff regroups to "Needs a look", which the Messages
+      // badge counts, so it stays here too (review N6).
+      if (it.supersededAt && it.group === 'running') return;
       rows.push({ kind: 'work', tier: 3, item: it, key: k.id ? k.provider + '|' + k.id : '' });
     });
     var groups = TODAY.voices.groups || [];
@@ -1005,7 +2107,8 @@
     return bits.join(', ');
   }
   function needRowHtml(r, i) {
-    var age = r.since ? ago(r.since) : r.item ? ago(r.item.updatedAt || r.item.createdAt) : '';
+    // A Work row is dated by when it started waiting (7.0.1), not by the card's newest event.
+    var age = r.since ? ago(r.since) : r.item ? ago(r.item.waitingSince || r.item.updatedAt || r.item.createdAt) : '';
     var top = function (title) { return '<span class="need-top"><span class="need-title">' + esc(title) + '</span>' + (age ? '<span class="need-age">' + esc(age) + '</span>' : '') + '</span>'; };
     if (r.kind === 'work') {
       var it = r.item, k = splitSessionId(it.provider, it.sessionId);
@@ -1020,7 +2123,8 @@
       // The session's question shows in the overlay's peek, with its cards to answer. Under it, where it can be answered.
       var q = sessionQs(), whereLine = r.where === 'here' ? 'Answer it here.' : r.where === 'mac' ? (q && q.macLine) || '' : r.where === 'answered' ? (q && q.answeredLine) || '' : '';
       return '<div class="need-row">' +
-        '<button type="button" class="need-open" data-today="wait" data-key="' + esc(r.key) + '">' + top(r.title) + '<span class="need-foot">' + esc(r.ask || r.why) + '</span>' +
+        // 7.0.18: a turn-end row's title already says the question, so its foot says how to answer.
+        '<button type="button" class="need-open" data-today="wait" data-key="' + esc(r.key) + '">' + top(r.title) + '<span class="need-foot">' + esc(r.where === 'turnend' ? r.why : (r.ask || r.why)) + '</span>' +
         (whereLine ? '<span class="need-foot need-where" data-where="' + esc(r.where) + '">' + esc(whereLine) + '</span>' : '') + '</button>' +
         '<div class="need-actions"><button type="button" class="btn small' + (i === 0 ? ' primary' : '') + '" data-session="' + esc(r.key) + '">Open session</button></div></div>';
     }
@@ -1066,16 +2170,237 @@
     // Control's Next up (todayPrepButtons): Prep me opens the Prep composer in the COS chat (panes/cos-chat.js prepFor),
     // Open meeting opens Meetings. Without a server to answer, Prep me is not offered.
     var prep = !TODAY.offline && window.COSWeb && window.COSWeb.cosChat && window.COSWeb.cosChat.prepFor;
+    // Prep on every row (Miles 11/09): "Add context" opens the same inline panel the later rows' Prep opens, for this
+    // meeting. Not on a hold (the server's nextEvent.hold), and not while neither Prep nor Ask is on the Mac.
+    var key = nextPrepKey(n.title, d), ctx = !n.hold && nextPrepMode();
+    if (ctx) NEXT_PREP.rows[key] = { title: n.title, start: d.toISOString() };
     $('next-actions').innerHTML = (prep ? '<button type="button" class="btn small primary" data-today-next="prep">Prep me</button>' : '') +
+      (ctx ? '<button type="button" class="link-btn next-prep-open" data-next-prep="' + esc(key) + '" aria-expanded="' + (NEXT_PREP.open === key) + '">Add context</button>' : '') +
       '<button type="button" class="link-btn" data-goto="meetings">Open meeting</button>';
+    NEXT_PREP.firstKey = ctx ? key : '';
+    paintNextPrepSlot($('next-first-prep'), ctx && NEXT_PREP.open === key ? key : '');
     card.classList.remove('hidden');
   }
+  // PH plan P1: the rest of today from GET /api/calendar/today (selected calendars), under Next up.
+  // An aging snapshot says when it was read. Not connected or nothing more: the block stays hidden.
+  // Today round 2 (Miles 11/09): Next up is 5 rows in all, the event above plus up to 4 more, then "+N more today"
+  // (opens Meetings) when the calendar has more meetings left today than are shown. Desktop Control 0.5.384 matches.
+  function loadCalendarLater(n, d) {
+    var LATER_ROWS = 4;
+    var box = $('next-later'); if (!box) return;
+    if (!n || !n.title || !d) { NEXT_PREP.later = null; clearLater(box); return; }
+    var gen = TODAY.gen;
+    api('/api/calendar/today').then(function (c) {
+      if (gen !== TODAY.gen) return;
+      if (!c || !c.connected) { NEXT_PREP.later = null; clearLater(box); return; }
+      var same = function (r) { var rd = toDate(r.start); return r.title === n.title && rd && d && Math.abs(rd.getTime() - d.getTime()) < 60000; };
+      var list = c.next || [];
+      var rows = list.filter(function (r) { return !r.allDay && !same(r); }).slice(0, LATER_ROWS);
+      // What is left today past the rows on screen (the event above counts when it is one of today's).
+      var shown = rows.length + (list.some(same) ? 1 : 0), more = (Number(c.remainingCount) || 0) - shown;
+      NEXT_PREP.later = { rows: rows, more: more, asOf: c.stale && c.asOf ? toDate(c.asOf) : null };
+      paintCalendarLater();
+    }, function () { NEXT_PREP.later = null; clearLater(box); });
+  }
+  // Emptied, and its last write forgotten, so the next read that has rows writes them again (writeKeepingPrep skips a
+  // write that matches the last one).
+  function clearLater(box) { box.classList.add('hidden'); box.innerHTML = ''; box.cosPrepHtml = ''; }
+  // The later rows from the last calendar read. Each meeting that is not a hold (the server's `hold`) gets a quiet
+  // Prep, and the open row's panel sits under it. Written only when the markup changed, so a poll never takes the words
+  // or the caret from the panel; when it is written, the words, the focus and the caret are put back.
+  function paintCalendarLater() {
+    var box = $('next-later'), L = NEXT_PREP.later; if (!box || !L) return;
+    var mode = nextPrepMode(), openKey = '';
+    var html = L.rows.map(function (r) {
+      var rd = toDate(r.start), key = rd ? nextPrepKey(r.title, rd) : '', can = !!(mode && key && r.hold !== true);
+      if (can) { NEXT_PREP.rows[key] = { title: r.title, start: rd.toISOString() }; if (NEXT_PREP.open === key) openKey = key; }
+      return '<div class="later-row"><span class="later-when">' + esc(rd ? clock(rd) : '') + '</span><span class="later-what">' + esc(r.title) + '</span>' +
+        (can ? '<button type="button" class="link-btn later-prep" data-next-prep="' + esc(key) + '" aria-expanded="' + (NEXT_PREP.open === key) + '">Prep</button>' : '') + '</div>' +
+        (can && NEXT_PREP.open === key ? nextPrepPanelHtml(key, mode) : '');
+    }).join('');
+    if (L.more > 0) html += '<button type="button" class="link-btn later-more" data-goto="meetings">' + esc('+' + L.more + ' more today') + '</button>';
+    if (L.asOf) html += '<div class="later-asof">' + esc('Calendar as of ' + clock(L.asOf)) + '</div>';
+    // Shown before it is written: autoGrow measures the box, and a hidden one measures 0.
+    box.classList.toggle('hidden', !html);
+    writeKeepingPrep(box, html, openKey);
+  }
+
+  // ── Prep on every Next up row (Miles typed 2026-11-09 13:00 CST) ─────────
+  // "Inline options to prep for a given meeting which starts the gotCOS ask and gives us the ability to add in more
+  // context for the prep." Prep on a later row (or Add context beside the first row's Prep me) opens a small panel
+  // under that row: the context box, Add files, Start prep and Cancel. One panel at a time; Escape closes it. The words
+  // and files are kept per meeting (title plus start) while the page polls. Start prep goes to Messages, then COS, and
+  // hands them to cos-chat.js prepStart: the Prep composer for that meeting (the context joins its notes, the files go
+  // up through its own path, then Prep me runs), or, with Prep off on the Mac and Ask on, the plain Ask with the context
+  // as its quoted reference. Neither on (or the Mac not answering): no Prep on any row.
+  var NEXT_PREP = { open: '', rows: {}, drafts: {}, later: null, firstKey: '', busy: false, capsAsked: false };
+  function nextPrepKey(title, d) { return String(title || '') + '|' + (d ? d.toISOString() : ''); }
+  function nextPrepChat() { return typeof window !== 'undefined' && window.COSWeb && window.COSWeb.cosChat || null; }
+  /** 'prep' (Prep on the Mac), 'ask' (Ask only), or '' (neither, the Mac not answering, or not known yet). */
+  function nextPrepMode() {
+    var chat = nextPrepChat();
+    if (TODAY.offline || !chat || !chat.prepStart) return '';
+    if (chat.known && !chat.known()) {
+      // The chat reads /api/health once per page; paint the rows again when it lands.
+      if (!NEXT_PREP.capsAsked && chat.ensureCaps) {
+        NEXT_PREP.capsAsked = true;
+        chat.ensureCaps().then(function () { if (TODAY.welcome) renderNext(TODAY.welcome); paintCalendarLater(); }, function () {});
+      }
+      return '';
+    }
+    if (chat.prepCaps && chat.prepCaps()) return 'prep';
+    return chat.askOn && chat.askOn() ? 'ask' : '';
+  }
+  function nextPrepDraft(key) { return NEXT_PREP.drafts[key] || (NEXT_PREP.drafts[key] = { text: '', files: [] }); }
+  function nextPrepMax() { var chat = nextPrepChat(), c = chat && chat.prepCaps && chat.prepCaps(); return c || { maxFiles: 10, steerChars: 4000 }; }
+  function nextPrepPanelHtml(key, mode) {
+    var row = NEXT_PREP.rows[key] || { title: '' }, dr = nextPrepDraft(key), chat = nextPrepChat();
+    var label = 'Add context for this prep (goals, people, what you want out of it)';
+    var files = mode === 'prep' && dr.files.length ? '<ul class="next-prep-files">' + dr.files.map(function (f, i) {
+      return '<li><span class="next-prep-file">' + esc(f.name || 'File') + '</span><button type="button" class="link-btn" data-next-prep-remove="' + i + '" aria-label="' + esc('Remove ' + (f.name || 'file')) + '">Remove</button></li>';
+    }).join('') + '</ul>' : '';
+    var add = mode === 'prep' ? '<label class="cx-btn quiet next-prep-add" title="Add files to this prep"><svg class="icon" aria-hidden="true"><use href="#i-clip"/></svg><span>Add files</span>' +
+      '<input type="file" class="cc-file" multiple accept="' + esc((chat && chat.prepAccept) || '') + '" data-next-prep-file aria-label="' + esc('Add files to the prep for ' + row.title) + '"></label>' : '';
+    return '<form class="next-prep" data-next-prep-form data-key="' + esc(key) + '" autocomplete="off" aria-label="' + esc('Prep for ' + row.title) + '">' +
+      '<textarea class="field next-prep-input" rows="2" maxlength="' + (mode === 'prep' ? nextPrepMax().steerChars : 2000) + '" data-next-prep-steer placeholder="' + esc(label) + '" aria-label="' + esc(label) + '"></textarea>' +
+      files +
+      '<div class="next-prep-acts">' + add + '<span class="next-prep-gap"></span>' +
+        '<button type="button" class="link-btn next-prep-cancel" data-next-prep-cancel>Cancel</button>' +
+        '<button type="submit" class="cx-btn primary next-prep-start"' + (NEXT_PREP.busy ? ' disabled' : '') + '>Start prep</button></div>' +
+      '</form>';
+  }
+  // The first row's panel, in its own slot under Prep me and Open meeting.
+  function paintNextPrepSlot(slot, key) {
+    if (!slot) return;
+    var mode = key ? nextPrepMode() : '';
+    // Shown before it is written: autoGrow measures the box, and a hidden one measures 0.
+    slot.classList.toggle('hidden', !(key && mode));
+    writeKeepingPrep(slot, key && mode ? nextPrepPanelHtml(key, mode) : '', key);
+  }
+  /** Writes `html` into `el` unless it is already there, then puts the open panel's words back (and the focus and caret). */
+  function writeKeepingPrep(el, html, key) {
+    if (el.cosPrepHtml === html) return;
+    var doc = typeof document !== 'undefined' ? document : null, active = doc && doc.activeElement;
+    var had = !!(active && el.contains && el.contains(active) && active.hasAttribute && active.hasAttribute('data-next-prep-steer'));
+    var a = had ? active.selectionStart : 0, b = had ? active.selectionEnd : 0;
+    el.innerHTML = html;
+    el.cosPrepHtml = html;
+    var box = key && el.querySelector ? el.querySelector('[data-next-prep-steer]') : null;
+    if (!box) return;
+    box.value = nextPrepDraft(key).text;
+    autoGrow(box);
+    if (had) { box.focus(); try { box.setSelectionRange(a, b); } catch (_e) {} }
+  }
+  function repaintNextPrep() {
+    if (TODAY.welcome && TODAY.welcome.nextEvent) renderNext(TODAY.welcome);
+    paintCalendarLater();
+  }
+  function toggleNextPrep(key) {
+    NEXT_PREP.open = NEXT_PREP.open === key ? '' : key;
+    repaintNextPrep();
+    if (!NEXT_PREP.open || typeof document === 'undefined') return;
+    var box = document.querySelector('[data-next-prep-form] [data-next-prep-steer]');
+    if (box) { box.focus(); if (box.scrollIntoView) box.scrollIntoView({ block: 'nearest' }); }
+  }
+  // Escape closes the panel and keeps the words (they come back when it opens again); Cancel closes it and drops them.
+  function closeNextPrep(drop) {
+    var key = NEXT_PREP.open; if (!key) return false;
+    if (drop) delete NEXT_PREP.drafts[key];
+    NEXT_PREP.open = '';
+    repaintNextPrep();
+    var opener = typeof document !== 'undefined' && typeof CSS !== 'undefined' && CSS.escape ? document.querySelector('[data-next-prep="' + CSS.escape(key) + '"]') : null;
+    if (opener && opener.focus) opener.focus();
+    return true;
+  }
+  function nextPrepInput(box) { var key = NEXT_PREP.open; if (key) nextPrepDraft(key).text = box.value; }
+  function addNextPrepFiles(list) {
+    var key = NEXT_PREP.open; if (!key) return;
+    var dr = nextPrepDraft(key), max = nextPrepMax().maxFiles, chat = nextPrepChat(), refused = [];
+    Array.prototype.slice.call(list || []).forEach(function (f) {
+      if (dr.files.length >= max) { refused.push('A prep holds ' + max + ' files. ' + (f.name || 'A file') + ' was not added.'); return; }
+      var c = chat && chat.classify ? chat.classify(f) : {};
+      if (c && c.refuse) { refused.push(c.refuse); return; }
+      if (c && c.kind === 'video') { refused.push((f.name || 'That video') + ' is a video. Prep reads documents and the text in images.'); return; }
+      dr.files.push(f);
+    });
+    if (refused.length) toast(refused.join(' '));
+    repaintNextPrep();
+  }
+  function removeNextPrepFile(i) {
+    var key = NEXT_PREP.open; if (!key) return;
+    nextPrepDraft(key).files.splice(Number(i), 1);
+    repaintNextPrep();
+  }
+  function startNextPrep() {
+    var key = NEXT_PREP.open, row = key && NEXT_PREP.rows[key], chat = nextPrepChat();
+    if (!row || NEXT_PREP.busy || !chat || !chat.prepStart) return;
+    var mode = nextPrepMode(); if (!mode) return;
+    var dr = nextPrepDraft(key);
+    var extra = { steer: dr.text.trim(), files: mode === 'prep' ? dr.files.slice() : [] };
+    NEXT_PREP.busy = true; NEXT_PREP.open = '';
+    repaintNextPrep();
+    go('messages', ['cos']);
+    // The words and files stay with the meeting until the prep (or the Ask) is on its way; a failure keeps them.
+    chat.prepStart(row.title, row.start, extra).then(function (how) {
+      if (how) delete NEXT_PREP.drafts[key];
+      else toast('Prep is not on for this Mac.');
+    }, function (err) {
+      toast((err && err.message) || 'Prep did not start. Your context is still under the meeting on Today.');
+    }).then(function () { NEXT_PREP.busy = false; });
+  }
   function prepNext() {
     var n = TODAY.welcome && TODAY.welcome.nextEvent, d = n && toDate(n.time), chat = window.COSWeb && window.COSWeb.cosChat;
     if (!n || !n.title || !chat || !chat.prepFor) return;
     go('messages', ['cos']);
     chat.prepFor(n.title, d ? d.toISOString() : null).catch(function (err) { toast((err && err.message) || 'Prep me did not start.'); });
   }
+  // ── Ask about this (Today round 2, Miles 11/09) ─────────
+  // "Ask COS from this page about the summary and take action coming off of that summary": one box under the model's
+  // summary. Send goes to Messages, then COS, and submits an Ask (panes/cos-chat.js askAbout) that carries the summary,
+  // when it was written and the sessions it read, as the Ask's quoted reference (data, never instructions; no transcript
+  // text, only the last message into each session). COS can then answer, or pass an instruction to a session by its
+  // title through the Ask's own relay ("Sent to <title>" on the answer card). Hidden without a model summary, without
+  // Ask on the Mac (capabilities: durable query jobs) or while the Mac does not answer.
+  function paintTodayAsk(brief) {
+    var form = $('today-ask'); if (!form) return;
+    var chat = window.COSWeb && window.COSWeb.cosChat;
+    // Ask's capability is read once per page (the chat's /api/health read); paint again when it lands.
+    if (brief && chat && chat.known && !chat.known() && chat.ensureCaps && !TODAY.askCaps) {
+      TODAY.askCaps = true;
+      chat.ensureCaps().then(function () { if (TODAY.model && state.pane === 'today') renderStory(TODAY.model); }, function () {});
+    }
+    // T1 spec 0: the box stays while a session read is pending or failed; briefShown decides whether there is a summary.
+    var on = !!(brief && !TODAY.offline && chat && chat.askAbout && chat.askOn && chat.askOn());
+    form.classList.toggle('hidden', !on);
+  }
+  // The sessions the summary read: the server's own list with the summary (7.0.10+ round 2 `sessions`: title, provider,
+  // state, when it last moved, the last message into it), else what this page holds for the same rows.
+  function todayAskContext(b) {
+    var rows = [];
+    if (Array.isArray(b.sessions) && b.sessions.length) {
+      b.sessions.forEach(function (r) { if (r && r.title) rows.push({ title: String(r.title), provider: String(r.provider || 'claude'), state: String(r.state || ''), movedAt: r.movedAt || null, lastAsk: r.lastAsk ? String(r.lastAsk) : '' }); });
+    } else {
+      (state.sessions || []).forEach(function (s) {
+        if (sxKeepWarm(s)) return;
+        var kind = sxState(s) === 'waiting' ? 'waiting' : s.running_active ? 'working' : s.running ? 'open' : '';
+        if (!kind) return;
+        var k = splitSessionId(s.provider, s.session_id || s.id);
+        rows.push({ title: sessionTitle(s), provider: k.provider, state: kind, movedAt: kind === 'open' ? (s.last_activity_at || s.state_since) : (s.state_since || s.last_activity_at), lastAsk: '' });
+      });
+    }
+    return { summary: String(b.text || ''), at: b.at || null, sessions: rows };
+  }
+  function sendTodayAsk() {
+    var input = $('today-ask-input'), text = input ? input.value.trim() : '';
+    var chat = window.COSWeb && window.COSWeb.cosChat, b = briefShown();
+    if (!text || TODAY.askBusy || !b || !chat || !chat.askAbout) return;
+    TODAY.askBusy = true;
+    var ctx = todayAskContext(b);
+    go('messages', ['cos']);
+    chat.askAbout(text, ctx).then(function () { input.value = ''; autoGrow(input); }, function (err) {
+      toast((err && err.message) || 'Ask did not send. Your words are still in the box on Today.');
+    }).then(function () { TODAY.askBusy = false; });
+  }
   // From today's meetings: Work's suggestions from meetings held today. They stay here until
   // midnight, then join Sort in Work; Review opens them in Work's Sort.
   function localDay(d) { return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0'); }
@@ -1291,7 +2616,7 @@
     var stats = view === 'sessions' ? sxStats(vis) : [];
     var busy = view === 'sessions' ? SX.loading : SX.usageLoading;
     hero.innerHTML = '<span class="cx-glyph"><svg class="icon"><use href="#i-sessions"/></svg></span>' +
-      '<div class="cx-hero-text"><h1 class="cx-title">Sessions</h1><p class="cx-detail-line">' + esc(detail) + '</p></div>' +
+      '<div class="cx-hero-text"><h1 class="cx-title">Sessions</h1><p class="cx-detail-line">' + esc(detail) + liveHeroNote(view) + '</p></div>' +
       '<div class="cx-actions"><button type="button" class="cx-btn quiet" data-sx="refresh"' + (busy ? ' disabled' : '') + '><svg class="icon"><use href="#i-refresh"/></svg>Refresh</button></div>' +
       (stats.length ? '<div class="cx-stats">' + stats.map(function (s) { return '<span class="cx-stat"><b>' + esc(typeof s[0] === 'number' ? s[0].toLocaleString() : s[0]) + '</b><span>' + s[1] + '</span></span>'; }).join('') + '</div>' : '');
     var clockOn = view === 'sessions' && !sxQueryActive();
@@ -1306,6 +2631,12 @@
     if (usage) usage.classList.toggle('hidden', view === 'sessions');
   }
 
+  // 7.0.1: the hero's counts say when they are not live ("Reconnecting", "as of 2 min ago"); nothing without a stream.
+  function liveHeroNote(view) {
+    if (view !== 'sessions' || typeof liveSessionsNote !== 'function') return '';
+    var n = liveSessionsNote();
+    return '<span class="sx-live-note">' + (n ? ' · ' + esc(n) : '') + '</span>';
+  }
   function loadSessions(force) {
     var r = parseRoute();
     var reading = r.pane === 'sessions' && r.args.length === 2;
@@ -1371,7 +2702,7 @@
     var meta = sxBadge(key.provider) +
       (s.pinned ? '<span class="sx-pinned">PINNED</span>' : '') +
       (label ? '<span class="sx-chip ' + st + '">' + esc(label) + '</span>' : '') +
-      (notSentFor(key.provider, key.id) ? '<span class="sx-chip refused" title="' + esc(notSentFor(key.provider, key.id).line) + '">Not sent</span>' : '') +
+      (notSentFor(key.provider, key.id) ? '<span class="sx-chip refused" title="' + esc(notSentFor(key.provider, key.id).line) + '">' + esc(notSentFor(key.provider, key.id).label || 'Not sent') + '</span>' : '') +
       (upd ? '<span class="sx-when">Updated ' + esc(sxShortDate(upd)) + '</span>' : '') +
       (ambiguous[title] && opened ? '<span class="sx-opened" title="Another session on screen has the same name. This one was opened ' + esc(sxShortDate(opened)) + '.">Opened ' + esc(sxShortDate(opened)) + '</span>' : '') +
       (s.project && String(s.project) !== title ? '<span class="sx-ws">' + esc(s.project) + '</span>' : '');
@@ -1514,20 +2845,84 @@
       renderSessionGroups();
     });
   }
-  // The meaning finder the Ask sheet offers ("Find a session about this").
-  function findByMeaning(q) {
-    return api('/api/agent-sessions/find', { method: 'POST', body: { query: q } }).then(function (d) {
-      if (d && d.available === false) return emptyBox('Meaning search is off', d.message || 'Turn on a decision provider in Settings.');
-      var results = (d && d.results) || [];
-      if (!results.length) return emptyBox('Nothing matched that meaning', 'Try different words, or search by Words.');
-      return '<h2 class="group-title"><span>About “' + esc(q) + '”</span><span>' + results.length + '</span></h2><div class="list">' + results.map(function (r) {
-        var s = r.session || r;
-        if (!s.provider && r.provider) s.provider = r.provider;
-        if (!s.session_id) s.session_id = r.sessionId || r.id;
-        return sessionRow(s, r.reason || s.project);
-      }).join('') + '</div>';
-    }).catch(function (err) { return emptyBox('Meaning search did not run', err.message); });
+  // ── Meaning search (W1, 7.0.x): "Find a session about this", as COS Control's command panel does it
+  // (SetupAssistant.swift 1476-1900). POST /api/agent-sessions/find takes exactly { query, consentedProvider, stage }
+  // (routes/session-find.ts:45-51). Nothing is sent before the person says yes for the decision model that decides search
+  // now. A yes for Jev is no yes for SubQ. The yes is kept in this browser only (the Mac keeps its own).
+  var MEANING_STORE = 'cos.web.meaningConsent';
+  var MEANING_NAME = { jev: 'Jev', subq: 'SubQ' };
+  var MEANING_TITLE = { consent_required: 'Meaning search needs your okay', provider_changed: 'The decision model changed',
+    decision_not_configured: 'Meaning search needs a key', jev_not_configured: 'Meaning search needs a key', sessions_off: 'Sessions are off',
+    find_off: 'Meaning search is off', cap_reached: 'Meaning search is used up for today', breaker_open: 'Meaning search is paused',
+    query_too_short: 'Type a few more words', failed: 'Meaning search did not answer' };
+  var MEANING_STRENGTH = { strong: 'Strong match', likely: 'Likely match', possible: 'Possible match' };
+  var MEANING = { view: null, at: 0 };
+  function meaningChoices() {
+    try { var v = JSON.parse(localStorage.getItem(MEANING_STORE) || '{}'); return v && typeof v === 'object' && !Array.isArray(v) ? v : {}; } catch (e) { return {}; }
+  }
+  function meaningChoose(provider, choice) {
+    if (!MEANING_NAME[provider]) return;
+    var c = meaningChoices();
+    if (choice === 'on' || choice === 'never') c[provider] = choice; else delete c[provider];
+    try { localStorage.setItem(MEANING_STORE, JSON.stringify(c)); } catch (e) { /* private mode: the question comes back next time */ }
+  }
+  // GET /api/decision-provider: the model that decides search now, whether its key is saved, and whether this server can
+  // find sessions by meaning at all (capabilities.sessionFind). Read again after a minute, or after a refusal.
+  function meaningSettings(force) {
+    if (!force && MEANING.view && Date.now() - MEANING.at < 60000) return Promise.resolve(MEANING.view);
+    return api('/api/decision-provider').then(function (d) {
+      var p = d && d.effective ? d.effective.search : null;
+      p = MEANING_NAME[p] ? p : null;
+      MEANING.view = { provider: p, keyed: !!(p && d.configured && d.configured[p] === true), capable: !!(d && d.capabilities && d.capabilities.sessionFind === true) };
+      MEANING.at = Date.now();
+      return MEANING.view;
+    });
   }
+  function meaningConsentText(provider) {
+    return 'Each search sends the words you type here, plus the title and first 150 characters of the first prompt from up to 508 recent sessions, to ' +
+      MEANING_NAME[provider] + '. Emails, links, home-folder paths and key-shaped text are removed first. Names and other details are not.' +
+      (provider === 'subq' ? ' SubQ keeps what it is sent.' : '');
+  }
+  function meaningConsentHtml(provider) {
+    // Lead decision (11/09): the choice is kept in this browser only, and the card says so.
+    return '<div class="list meaning-consent"><p class="empty"><strong>Find sessions by meaning with ' + esc(MEANING_NAME[provider]) + '?</strong>' + esc(meaningConsentText(provider)) +
+      ' ' + esc('Your choice applies to this browser only.') + '</p>' +
+      '<div class="row-actions"><button type="button" class="btn small primary" data-action="meaning-consent" data-provider="' + esc(provider) + '" data-choice="on">Turn on</button>' +
+      '<button type="button" class="btn small" data-action="meaning-consent" data-provider="' + esc(provider) + '" data-choice="never">Never</button></div></div>';
+  }
+  function meaningRows(q, d) {
+    var rows = (d && Array.isArray(d.rows)) ? d.rows : [];
+    return '<h2 class="group-title"><span>About \u201c' + esc(q) + '\u201d</span><span>' + rows.length + '</span></h2><div class="list">' + rows.map(function (r) {
+      var s = { provider: r.provider, session_id: r.session_id, display_label: r.display_label, custom_title: r.custom_title, first_prompt: r.first_prompt, project: r.project,
+        modified: r.modified, last_activity_at: r.last_activity_at, alive: r.alive, pinned: r.pinned, slug: r.slug };
+      return sessionRow(s, MEANING_STRENGTH[r.strength] || MEANING_STRENGTH.possible);
+    }).join('') + '</div>';
+  }
+  function meaningRun(q, provider, stage) {
+    return api('/api/agent-sessions/find', { method: 'POST', body: { query: q, consentedProvider: provider, stage: stage }, timeoutMs: 90000 }).then(function (d) {
+      if (d && d.available === false) {
+        if (d.reason === 'provider_changed') MEANING.view = null;
+        return emptyBox(MEANING_TITLE[d.reason] || 'Meaning search did not run', d.message || '');
+      }
+      var rows = (d && Array.isArray(d.rows)) ? d.rows : [];
+      // The first stage reads the newest 254 sessions; with nothing there, look once further back (Control's "Looking further back").
+      if (!rows.length && stage === 'first') return meaningRun(q, provider, 'full');
+      if (!rows.length) return emptyBox('Nothing close by meaning', 'Checked ' + (Number(d && d.asked) || 0) + ' sessions. Try other words, or search by words.');
+      return meaningRows(q, d);
+    });
+  }
+  function findByMeaning(q) {
+    return meaningSettings(false).then(function (m) {
+      if (!m.capable) return emptyBox('Meaning search is not on here', 'This COS server cannot find sessions by meaning. Search by words instead.');
+      if (!m.provider || !m.keyed) return emptyBox('Meaning search needs a decision model', 'Choose Jev or SubQ in Settings, then save its key in COS Control on your Mac: search Settings there for Jev key or SubQ key.');
+      var choice = meaningChoices()[m.provider];
+      if (choice === 'never') return emptyBox('Meaning search is off in this browser', 'You chose Never for ' + MEANING_NAME[m.provider] + '.') +
+        '<div class="row-actions"><button type="button" class="btn small" data-action="meaning-consent" data-provider="' + esc(m.provider) + '" data-choice="ask">Ask me again</button></div>';
+      if (choice !== 'on') return meaningConsentHtml(m.provider);
+      return meaningRun(q, m.provider, 'first');
+    }).catch(function (err) { return emptyBox('Meaning search did not run', (err && err.message) || ''); });
+  }
+  // ── end meaning search
 
   // The hooks banner (ActivityWindow.swift 2867-2905). Installing hooks writes to the Mac's Claude
   // settings, which stays a Mac action, so the web names where to do it.
@@ -1577,10 +2972,12 @@
       }
       if (act === 'clear') { var input = $('sessions-q'); input.value = ''; searchSessions(); input.focus(); return; }
       if (act === 'copy-session') return copySessionBrief();
+      if (act === 'full') { if (SX_SPLIT) SX_SPLIT.toggleFull(); return; }
       if (act === 'refresh-turns' && rd) { rd.refusal = null; renderVerdict(rd); refreshTurns(rd.provider, rd.id); return; }
       if (act === 'retry' && rd) { rd.refusal = null; renderVerdict(rd); return sendSessionTurn(!!rd.retryFork); }
       if (act === 'caution-send' && rd) { rd.cautionAck = true; rd.cautionAsk = false; renderVerdict(rd); return sendSessionTurn(false); }
       if (act === 'caution-cancel' && rd) { rd.cautionAsk = false; renderVerdict(rd); return; }
+      if (act === 'turnend' && rd) return sendTurnEndChoice(rd, Number(t.getAttribute('data-i')));
       if (act === 'usage-clear') { SX.uTool = 'All tools'; SX.uModel = 'All models'; SX.uToolBefore = null; uSliceChanged(); return paintUsage(); }
       if (act === 'usage-range') return uOpenRange(t, true);
     });
@@ -1605,6 +3002,153 @@
     });
   }
 
+  // Duo tables: the divider between two columns, where both show side by side. One kit (splitKit) for every pane that
+  // has them: a list beside its reader in Sessions (760 px and up), Memories (760 px and up) and Messages with the COS
+  // chat (860 px and up), and a reader beside its side panel in a meeting (Ask, 860 px and up) and a Work card (900 px).
+  // Drag it with a finger, mouse or pen (pointer events, captured, so a table's own sideways scroll and text selection
+  // in the panes never start a drag), or focus it and use the arrow keys (Shift for bigger steps, Home and End).
+  // A double tap or double click goes back to the default width. The width is a share of the split (CSS clamps it so the
+  // list keeps 240 px and the reader 380 px, also after the screen turns) and is remembered on this device, one key per
+  // pane; "Full width" in the reader hides the list and "Show list" brings it back. Storage that throws (a private
+  // window) only means the choice lasts this visit. Below a pane's own breakpoint the divider is hidden by CSS and the
+  // kit does nothing (o.media), so a phone's layout never changes.
+  var SX_SPLIT_KEY = 'cos_web_sessions_split', SX_LIST_MIN = 240, SX_READER_MIN = 380, SX_HANDLE_W = 18, SX_KEY_STEP = 16, SX_DOUBLE_MS = 350;
+  // o: key (storage), prefix (class names: <prefix>-sized, -full and -dragging), cssVar (the share, default
+  // --<prefix>-list-share), label (what the divider sizes, for screen readers), sized (the column the share sizes,
+  // default the list), side ('end' when that column is on the right: a side panel grows as the line moves left),
+  // fullSel (the Full width buttons), media (where the divider shows), listMin (the sized column's minimum), readerMin
+  // (the other column's), handleW (px, the same numbers as the pane's CSS clamp), memo (this visit's choice, kept across
+  // a pane's repaint when storage is off).
+  function splitKit(split, handle, storage, o) {
+    var KEY = o.key, PRE = o.prefix || 'split', LIST_MIN = o.listMin || SX_LIST_MIN, READER_MIN = o.readerMin || SX_READER_MIN,
+      HANDLE_W = o.handleW || SX_HANDLE_W, LIST_SEL = o.sized || '.split-list', FULL_SEL = o.fullSel || '[data-split-full="' + KEY + '"]', memo = o.memo || null,
+      VAR = o.cssVar || '--' + PRE + '-list-share', END = o.side === 'end';
+    var saved = {};
+    try { var raw = JSON.parse(storage.getItem(KEY) || 'null'); if (raw && typeof raw === 'object') saved = raw; } catch (_e) { saved = {}; }
+    if (memo && memo.at) saved = memo;
+    var share = typeof saved.share === 'number' && saved.share > 0 && saved.share < 100 ? saved.share : null, full = saved.full === true, lastTap = 0;
+    function save() {
+      if (memo) { memo.share = share; memo.full = full; memo.at = Date.now(); }
+      try { storage.setItem(KEY, JSON.stringify({ share: share, full: full })); } catch (_e) { /* this visit only */ }
+    }
+    // Narrow (a phone, the folded Duo): the divider is not shown, and nothing here may move the layout.
+    function narrow() { return !!o.media && typeof matchMedia === 'function' && !matchMedia(o.media).matches; }
+    function total() { return split.getBoundingClientRect().width; }
+    function listWidth() { var l = split.querySelector(LIST_SEL); return l ? l.getBoundingClientRect().width : 0; }
+    function bounds(t) { return { min: LIST_MIN, max: Math.max(LIST_MIN, t - HANDLE_W - READER_MIN) }; }
+    function aria() {
+      var t = total(); if (!(t > 0)) return;
+      var b = bounds(t), pct = function (px) { return Math.round(px / t * 100); }, now = pct(listWidth());
+      handle.setAttribute('aria-valuemin', String(pct(b.min)));
+      handle.setAttribute('aria-valuemax', String(pct(b.max)));
+      handle.setAttribute('aria-valuenow', String(now));
+      handle.setAttribute('aria-valuetext', (o.label || 'List') + ' ' + now + '% of the width');
+    }
+    function paint() {
+      split.classList.toggle(PRE + '-sized', share != null);
+      if (share != null) split.style.setProperty(VAR, share.toFixed(2) + '%'); else split.style.removeProperty(VAR);
+      split.classList.toggle(PRE + '-full', full);
+      document.querySelectorAll(FULL_SEL).forEach(function (b) { b.setAttribute('aria-pressed', String(full)); b.textContent = full ? 'Show list' : 'Full width'; });
+      aria();
+    }
+    // px: the sized column's width asked for; kept inside both columns' minimums for the split's width now.
+    function setWidth(px, persist) {
+      if (narrow()) return;
+      var t = total(); if (!(t > 0)) return;
+      var b = bounds(t);
+      share = Math.min(b.max, Math.max(b.min, px)) / t * 100;
+      paint();
+      if (persist) save();
+    }
+    function reset() { share = null; paint(); save(); }
+    handle.addEventListener('pointerdown', function (e) {
+      if (e.pointerType === 'mouse' && e.button !== 0) return;
+      if (narrow()) return;
+      e.preventDefault();
+      var x0 = e.clientX, start = listWidth(), moved = false, id = e.pointerId;
+      try { handle.setPointerCapture(id); } catch (_e) {}
+      split.classList.add(PRE + '-dragging');
+      // A column on the right grows as the pointer moves left.
+      function dx(ev) { return END ? x0 - ev.clientX : ev.clientX - x0; }
+      function move(ev) {
+        if (ev.pointerId !== id) return;
+        if (!moved && Math.abs(ev.clientX - x0) < 4) return;
+        moved = true;
+        setWidth(start + dx(ev), false);
+      }
+      function end(ev) {
+        if (ev.pointerId !== id) return;
+        handle.removeEventListener('pointermove', move); handle.removeEventListener('pointerup', end); handle.removeEventListener('pointercancel', end);
+        split.classList.remove(PRE + '-dragging');
+        // The lift's own position counts: a browser may fold the last moves into it.
+        if (moved) { if (ev.type === 'pointerup') setWidth(start + dx(ev), false); save(); lastTap = 0; return; }
+        if (ev.type !== 'pointerup') return;
+        var now = Date.now();
+        if (now - lastTap < SX_DOUBLE_MS) { lastTap = 0; reset(); } else lastTap = now;
+      }
+      handle.addEventListener('pointermove', move); handle.addEventListener('pointerup', end); handle.addEventListener('pointercancel', end);
+    });
+    handle.addEventListener('dblclick', function (e) { if (narrow()) return; e.preventDefault(); reset(); });
+    handle.addEventListener('keydown', function (e) {
+      if (narrow()) return;
+      var t = total(), b = bounds(t), w = listWidth(), step = e.shiftKey ? SX_KEY_STEP * 4 : SX_KEY_STEP;
+      // The arrows move the line the way they point; Home and End take it to the left and right limits.
+      var left = END ? 1 : -1;
+      var to = e.key === 'ArrowLeft' ? w + left * step : e.key === 'ArrowRight' ? w - left * step : e.key === 'Home' ? (END ? b.max : b.min) : e.key === 'End' ? (END ? b.min : b.max) : null;
+      if (to == null) return;
+      e.preventDefault();
+      setWidth(to, true);
+    });
+    paint();
+    return {
+      setWidth: setWidth, reset: reset, paint: paint,
+      toggleFull: function () { full = !full; paint(); save(); },
+      state: function () { return { share: share, full: full }; }
+    };
+  }
+  // Sessions: the first pane with the divider, unchanged (its markup is in index.html, its CSS in panes/sessions.css).
+  var SX_SPLIT_OPTS = { key: SX_SPLIT_KEY, prefix: 'sx', label: 'Session list', fullSel: '[data-sx="full"]', media: '(min-width: 760px)',
+    listMin: SX_LIST_MIN, readerMin: SX_READER_MIN, handleW: SX_HANDLE_W };
+  function sxSplitKit(split, handle, storage) { return splitKit(split, handle, storage, SX_SPLIT_OPTS); }
+  // The other panes (W.splitKit): the divider's markup, a Full width button, and mount, which binds the kit to a split
+  // the pane just drew. One live kit per key; a pane that draws its split again gets a fresh kit with this visit's choice.
+  var SPLITS = {}, SPLIT_MEMO = {}, SPLIT_NO_STORE = { getItem: function () { return null; }, setItem: function () {} };
+  function splitStorage() { try { return window.localStorage || null; } catch (_e) { return null; } }
+  function splitHandleHtml(o) {
+    return '<div class="split-handle" role="separator" aria-orientation="vertical" aria-controls="' + esc(o.controls) + '" aria-label="' + esc(o.label + ' width') +
+      '" tabindex="0" title="Drag to resize. Double-tap or double-click to reset."' + (o.id ? ' id="' + esc(o.id) + '"' : '') + '></div>';
+  }
+  function splitFullButton(key, controls) {
+    var live = SPLITS[key], full = !!(live && live.kit.state().full);
+    return '<button type="button" class="cx-btn quiet split-full-btn" data-split-full="' + esc(key) + '" aria-controls="' + esc(controls || '') + '" aria-pressed="' + full + '">' + (full ? 'Show list' : 'Full width') + '</button>';
+  }
+  function mountSplit(split, handle, o) {
+    if (!split || !handle || !o || !o.key) return null;
+    var live = SPLITS[o.key];
+    if (live && live.split === split && live.handle === handle) return live.kit;
+    var memo = SPLIT_MEMO[o.key] || (SPLIT_MEMO[o.key] = {});
+    var kit = splitKit(split, handle, splitStorage() || SPLIT_NO_STORE, Object.assign({}, o, { memo: memo }));
+    SPLITS[o.key] = { kit: kit, split: split, handle: handle };
+    return kit;
+  }
+  var SX_SPLIT = null;
+  (function () {
+    var split = $('sessions-split'), handle = $('sessions-handle');
+    if (!split || !handle) return;
+    var store = splitStorage();
+    SX_SPLIT = sxSplitKit(split, handle, store || SPLIT_NO_STORE);
+  })();
+  // A turned screen or a fold changes the split's width: every divider on the page repaints its limits.
+  window.addEventListener('resize', function () {
+    if (SX_SPLIT) SX_SPLIT.paint();
+    Object.keys(SPLITS).forEach(function (k) { var s = SPLITS[k]; if (s.split.isConnected) s.kit.paint(); });
+  });
+  document.addEventListener('click', function (e) {
+    var b = e.target && e.target.closest ? e.target.closest('[data-split-full]') : null;
+    var live = b ? SPLITS[b.getAttribute('data-split-full')] : null;
+    if (live) live.kit.toggleFull();
+  });
+
   // ── Sessions: read, send, queue, fork, stop (the glasses' Continue, from a browser) ──
   // The server owns every safety rule (agent-session-bindings.ts): COS writes into a desktop
   // thread only through a binding, attaches only when no live process owns the thread, and
@@ -1654,14 +3198,19 @@
   // queue replaces it, so a row the server drops clears the mark.
   var NOT_SENT_KEY = 'cos_web_not_sent', NOT_SENT_KEEP_MS = 86400000;
   function notSentRows(rows) { return (rows || []).filter(function (t) { return t && (t.status === 'refused' || t.status === 'expired'); }); }
+  // A row COS cannot tell went in or not (deliveryState unknown, e.g. a steer it could not confirm) is not "Not sent":
+  // it may be in the session already, so it has its own label and its own line, never a "Not sent:" prefix.
+  function maybeSent(t) { return !!(t && t.deliveryState === 'unknown'); }
+  function notSentLabel(t) { return maybeSent(t) ? 'May have been sent' : 'Not sent'; }
   function notSentLine(t) {
+    if (maybeSent(t)) return String(t.reasonCopy || 'May not have been sent. Read it, then say it again.').trim();
     var why = String((t && t.reasonCopy) || (t && t.status === 'expired' ? 'the thread stayed busy too long.' : 'the session refused it.')).trim();
     return /^not sent\b/i.test(why) ? why : 'Not sent: ' + why.charAt(0).toLowerCase() + why.slice(1);
   }
   function noteNotSent(provider, id, rows) {
     var all = readStore(NOT_SENT_KEY), k = provider + '|' + id, now = Date.now(), list = notSentRows(rows);
     Object.keys(all).forEach(function (x) { if (!all[x] || now - (Number(all[x].at) || 0) > NOT_SENT_KEEP_MS) delete all[x]; });
-    if (list.length) all[k] = { n: list.length, line: notSentLine(list[list.length - 1]).slice(0, 240), at: now }; else delete all[k];
+    if (list.length) all[k] = { n: list.length, line: notSentLine(list[list.length - 1]).slice(0, 240), label: notSentLabel(list[list.length - 1]), at: now }; else delete all[k];
     writeStore(NOT_SENT_KEY, all);
   }
   function notSentFor(provider, id) {
@@ -1738,6 +3287,11 @@
     return 'Showing the last ' + turns.length + (total > turns.length && !d.truncated ? ' of ' + total : '') + ' turns. Copy session keeps the original request plus the newest context.';
   }
 
+  // Wide layouts: give the reader the whole width, or bring the list back (sxSplitKit). Hidden under 760 px by CSS.
+  function sxFullButton() {
+    var full = !!(SX_SPLIT && SX_SPLIT.state().full);
+    return '<button type="button" class="cx-btn quiet sx-full-btn" data-sx="full" aria-controls="sessions-list-col" aria-pressed="' + full + '">' + (full ? 'Show list' : 'Full width') + '</button>';
+  }
   function openSession(provider, id) {
     var reader = $('session-reader');
     if (!provider || !id) return;
@@ -1752,7 +3306,7 @@
     var listed = (SX.rows || []).filter(function (s) { return sxSame(sxKey(s), provider + ':' + String(id).toLowerCase()); })[0];
     if (listed) window.COSWeb.setCrumb(sxTitle(listed));
     reader.innerHTML = '<div class="sx-reader-head"><div class="skeleton" style="height:26px;width:70%;margin:6px 0 10px"></div><div class="skeleton" style="width:45%"></div></div>' + skeletonRows(3);
-    api(sessionPath(provider, id, '?turns=' + SX_TURNS)).then(function (d) {
+    api(sessionPath(provider, id, '?turns=' + SX_TURNS + '&cards=1')).then(function (d) {
       if (state.reading !== r) return;
       var turns = Array.isArray(d && d.recent_turns) ? d.recent_turns : ((d && d.recent_turns && d.recent_turns.turns) || (d && d.turns) || []);
       r.detail = d; r.turns = turns; r.more = d.recent_turns_more === true;
@@ -1761,15 +3315,19 @@
       window.COSWeb.setCrumb(title);
       var trunc = sxTruncNote(d, turns, r.more);
       reader.innerHTML =
-        '<div class="sx-reader-head"><div class="sx-head-line">' + sxBadge(provider) + '<h2 class="sx-reader-title">' + esc(title) + '</h2></div>' +
+        '<div class="sx-reader-head"><div class="sx-head-line">' + sxBadge(provider) + '<h2 class="sx-reader-title">' + esc(title) + '</h2>' + sxFullButton() + '</div>' +
           '<p class="sx-subtitle">' + esc(sxSubtitle(d, provider, turns, r.more)) + '</p></div>' +
         '<div class="sx-activity" id="session-live" aria-live="polite"></div>' +
+        '<div class="sx-mac-q" id="session-mac-q" role="status" hidden></div>' +
         (trunc ? '<p class="sx-note">' + esc(trunc) + '</p>' : '') +
         '<div class="turns sx-turns" id="session-turns">' + renderTurns(turns, d) + '</div>' +
         '<div class="sx-foot"><button type="button" class="cx-btn quiet" data-sx="copy-session" title="A kickstart brief for another agent, built from the turns COS serves. Not a Claude Code resume: it does not reopen this session.">Copy session</button>' +
           '<span class="sx-foot-note">Kickstart brief for another agent. Not a Claude Code resume.</span></div>' +
         '<p class="sx-copy-note hidden" id="session-copy-note" role="status"></p>' +
         '<div class="sx-chat">' +
+          // DESIGN.md step 4 #3: this session's question cards (held and answerable, or at the Mac with its words), above
+          // the verdict and the Send box, the same component Today's sheet mounts, so the full hold lights up here.
+          '<div class="sx-questions" id="session-questions"></div>' +
           '<div id="session-verdict"></div>' +
           '<form class="composer att-composer" id="session-form" data-provider="' + esc(provider) + '" data-id="' + esc(id) + '">' +
             '<div class="cc-chips att-files hidden" id="session-files"></div>' +
@@ -1783,9 +3341,13 @@
       readerImagesMount($('session-turns'), r);
       sxNoteList(r, d);
       setLive({});
+      if (typeof readerMacPaint === 'function') readerMacPaint(r, sxState(d) === 'waiting');
+      var qk = window.COSWeb.sessionQuestions, qhost = $('session-questions');
+      if (qk && qk.mount && qhost) r.qMount = qk.mount(qhost, id, function () { if (state.reading === r && typeof readerMacPaint === 'function') readerMacPaint(r, r.waitingNow); });
       paintReaderFiles();
+      paintWebKeyOffer(r);
       // The Mac's answer about files may not be in yet: ask once, then draw the clip.
-      var kitR = readerKit(); if (kitR && !kitR.turnFiles()) kitR.ensureCaps().then(paintReaderFiles, function () {});
+      var kitR = readerKit(); if (kitR && !kitR.turnFiles()) kitR.ensureCaps().then(function () { paintReaderFiles(); paintWebKeyOffer(r); }, function () {});
       renderHeld(state.reading);
       loadQueue(provider, id);
       sxProbeAttach(r);
@@ -2057,6 +3619,7 @@
         var waiting = !working && (e.state === 'waiting' || e.state === 'needs_input' || e.agent_state === 'waiting');
         var el = $('session-state');
         if (el) el.textContent = working ? 'Working now' : waiting ? 'Waiting for you' : 'Open';
+        if (typeof readerMacPaint === 'function') readerMacPaint(r, waiting);
         if (wasWorking && !working) { refreshTurns(provider, id); replyEnded(r); }
         wasWorking = working;
         // Gone to waiting: its question may be parked for this page now (6.99.27).
@@ -2082,7 +3645,7 @@
   }
   function refreshTurns(provider, id) {
     var reading = state.reading;
-    api(sessionPath(provider, id, '?turns=' + SX_TURNS)).then(function (d) {
+    api(sessionPath(provider, id, '?turns=' + SX_TURNS + '&cards=1')).then(function (d) {
       var r = state.reading;
       if (!r || r !== reading || r.id !== id || r.provider !== provider) return;
       var turns = Array.isArray(d && d.recent_turns) ? d.recent_turns : [];
@@ -2122,7 +3685,7 @@
             (mine ? '<button type="button" class="cx-btn quiet" data-action="unqueue" data-turn-key="' + esc(t.clientTurnId) + '" title="Cancel this queued message. It will not be sent.">Cancel</button>' : '') + '</div>';
         }).join('') +
         notSent.map(function (t) {
-          return '<div class="sx-queue-row sx-queue-refused"><span class="sx-queue-state">Not sent</span><span class="sx-queue-text">' + esc(t.preview || t.prompt || 'Message') +
+          return '<div class="sx-queue-row sx-queue-refused"><span class="sx-queue-state">' + esc(notSentLabel(t)) + '</span><span class="sx-queue-text">' + esc(t.preview || t.prompt || 'Message') +
             '<span class="sx-queue-reason">' + esc(notSentLine(t)) + '</span></span></div>';
         }).join('') + '</div>';
     }).catch(function () {});
@@ -2143,7 +3706,9 @@
       var b = a.body || {};
       if (a.status !== 200 || typeof b.attachable !== 'boolean') { failed(); return; }
       var owners = Number(b.ownerCount) || 0;
-      r.verdict = { attachable: b.attachable, reason: String(b.reason || ''), reasonCopy: String(b.reasonCopy || ''), ownerCount: owners, caution: b.attachable === true && owners > 0 };
+      r.verdict = { attachable: b.attachable, reason: String(b.reason || ''), reasonCopy: String(b.reasonCopy || ''), ownerCount: owners, caution: b.attachable === true && owners > 0,
+        // Steer mid-turn: the server says whether a message sent now goes into the running turn.
+        midTurn: !!(b.midTurn && b.midTurn.available === true) };
       // 6.99.29: the gate's answer is a signal of the one state, as of now.
       sxNoteGate(r, b.attachable === false && b.reason === 'native_thread_working');
       sxRepaint(r);
@@ -2154,6 +3719,17 @@
     codex: 'Working right now. A message you send joins the Codex app’s queue for this thread.',
     claude: 'Working right now. A message you send waits and lands when this turn ends.'
   };
+  // Steer mid-turn: only when the server says this session takes a message inside its running turn.
+  var SX_PARK_MIDTURN = 'Working right now. Your message lands at its next step.';
+  // QA 7.0.0: a message with files never goes in mid-turn (the drain steers words only; a row with files waits for the
+  // turn end, and the park answer says landsAt turn_end). With files in the box the note says so.
+  var SX_PARK_FILES = 'Working right now. A message with files waits and lands when this turn ends.';
+  // `hasFiles`: a view (Today's sheet) says whether its own box holds files; the reader's box is read here.
+  function sxParkLine(r, hasFiles) {
+    if (!(r.verdict && r.verdict.midTurn === true)) return SX_PARK[sxProvider(r.provider)];
+    if (hasFiles === undefined) hasFiles = sxReaderHasFiles(r);
+    return hasFiles ? SX_PARK_FILES : SX_PARK_MIDTURN;
+  }
   /** The composer's "Working right now" note: a busy gate verdict, and the one state agrees. */
   function sxParkNoteShows(r) {
     var v = r.verdict;
@@ -2186,7 +3762,7 @@
         (f.fork ? forkBtn : ''));
     } else if (v && v.attachable === false && /^(native_thread_working|native_target_busy)$/.test(v.reason)) {
       // 6.99.29: "Working right now" only while the one state says so.
-      if (sxParkNoteShows(r)) html = '<div class="sx-park"><p>' + esc(SX_PARK[sxProvider(r.provider)]) + '</p>' + (/fork/i.test(v.reasonCopy) ? '<div class="sx-box-actions">' + forkBtn + '</div>' : '') + '</div>';
+      if (sxParkNoteShows(r)) html = '<div class="sx-park"><p>' + esc(sxParkLine(r)) + '</p>' + (/fork/i.test(v.reasonCopy) ? '<div class="sx-box-actions">' + forkBtn + '</div>' : '') + '</div>';
     } else if (v && v.attachable === false && v.reasonCopy) {
       html = refusalBox(v.reasonCopy, sxSupplement(v.reason), /fork/i.test(v.reasonCopy) ? forkBtn : '');
     }
@@ -2221,7 +3797,8 @@
   // The box is cleared only of the very words that were sent; anything typed since stays.
   function clearBoxOf(text) {
     var input = $('session-input');
-    if (input && input.value.trim() === String(text).trim()) { input.value = ''; autoGrow(input); }
+    // 7.0.18: an answer to a turn-end ask was sent with the attribution in front; the box holds his words without it.
+    if (input && (input.value.trim() === String(text).trim() || input.value.trim() === turnEndBare(text))) { input.value = ''; autoGrow(input); }
     if (state.reading && state.reading.draft && state.reading.draft.text === text) state.reading.draft = null;
   }
   // Words go back in the box only if the box is empty; otherwise the status line keeps them. `files` says what became
@@ -2282,6 +3859,12 @@
     if (!READER_FILES[key].anyBytes && !READER_FILES[key].atts.length && kit.turnFileBytes()) READER_FILES[key].anyBytes = kit.turnFileBytes();
     return READER_FILES[key];
   }
+  // Whether the reader's own box holds a file for this session (any state: a file still uploading goes with the message).
+  function sxReaderHasFiles(r) {
+    if (!r || r.view || state.reading !== r || !readerFilesOn()) return false;
+    var box = readerBox(r);
+    return !!(box && box.atts.length);
+  }
   function readerFilesState(box) {
     var kit = readerKit();
     if (!kit || !box || !box.atts.length) return 'none';
@@ -2297,6 +3880,8 @@
     Array.prototype.forEach.call(slot.querySelectorAll('[data-sx-file]'), function (i) { i.disabled = full || !!r.sending; });
     list.innerHTML = kit.chipsHtml(box, 'data-action') + (box.atts.length ? '<p class="att-limit">' + esc(kit.limitLine(box)) + '</p>' : '');
     list.classList.toggle('hidden', !box.atts.length);
+    // QA 7.0.0: the "Working right now" note depends on whether files go with the message (sxParkLine).
+    if (r && r.verdict) renderVerdict(r);
     // Send and Fork wait while a file uploads. A failed file never greys them out (QA 6.99.27): a tap says why.
     var st = readerFilesState(box), form = $('session-form');
     if (!form || r.sending) return;
@@ -2360,6 +3945,9 @@
     // during the first attach could park the same text in the queue while the first lands.
     if (r.sending) return;
     if (r.refusal || r.cautionAsk) { r.refusal = null; r.cautionAsk = false; renderVerdict(r); }
+    // 7.0.18: while a turn-end ask is open, the box's words are his own answer ('Other' in the contract): sent with the
+    // same attribution as a choice. A fork goes to a copy and is not an answer, so it is sent as written.
+    if (!fork && r.turnEnd && turnEndOf(readerRowOf(r))) text = turnEndPrompt(text);
     r.sending = true;
     var btns = form.querySelectorAll('button'); btns.forEach(function (b) { b.disabled = true; });
     var done = function () { r.sending = false; btns.forEach(function (b) { b.disabled = false; }); paintReaderFiles(); };
@@ -2462,6 +4050,205 @@
     });
   }
 
+  // ── BEGIN web-key handoff (6.99.31, Phase 3, review W2) ──
+  // With the Mac's webKeySigner capability (only with COS_WEB_KEY_AUTHORITY on) and an enrolled phone key, the session
+  // composer offers "Approve on this phone". That is a TOP-LEVEL navigation to the signer page on port 3144 carrying a
+  // one-use handoff id in the fragment. The words stay on the Mac until the signer claims them; they are never in a URL.
+  // Without the capability nothing here runs: no request, no button, the composer exactly as before.
+  var WEB_KEY = { status: null, statusAt: 0, loading: null, generation: 0, views: [], refreshing: null, navigation: null };
+  var WEB_KEY_COPY = {
+    no_phone_key: 'No phone has a key yet. Set one up on the approval page first.',
+    attachments_not_signable: 'Files cannot be approved on the phone yet. Remove them, or use Send.',
+    words_too_long: 'That message is too long to approve on the phone. Shorten it, or use Send.',
+    handoff_cap_reached: 'Too many approvals are waiting. Finish one, or wait two minutes.',
+    origin_unavailable: 'Your Mac does not know its Tailscale name yet, so the approval page cannot open.',
+    web_key_authority_off: 'Phone approval is turned off on the Mac.'
+  };
+  function webKeyCapable() { var k = readerKit(); return !!(k && typeof k.webKeySigner === 'function' && k.webKeySigner() === 1); }
+  function webKeyStatus() {
+    var age = Date.now() - WEB_KEY.statusAt;
+    if (WEB_KEY.status && age >= 0 && age < 30000) return Promise.resolve(WEB_KEY.status);
+    if (!WEB_KEY.loading) {
+      var generation = WEB_KEY.generation;
+      WEB_KEY.loading = apiAnswer('/api/web-key/status', { timeoutMs: 15000 }).then(function (a) {
+        if (generation !== WEB_KEY.generation) return null;
+        WEB_KEY.loading = null;
+        WEB_KEY.status = a.status === 200 && a.body && a.body.ok === true && Number.isSafeInteger(a.body.activeKeys) && a.body.activeKeys >= 0 ? { activeKeys: a.body.activeKeys } : null;
+        WEB_KEY.statusAt = Date.now();
+        return WEB_KEY.status;
+      }, function () { if (generation === WEB_KEY.generation) { WEB_KEY.loading = null; WEB_KEY.status = null; } return null; });
+    }
+    return WEB_KEY.loading;
+  }
+  function webKeySetupUrl() {
+    var host = location.hostname;
+    // The passkey belongs to this Mac's full MagicDNS host, never an IP, local alias or public suffix.
+    if (typeof host !== 'string' || host.length > 253 || !/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.){2,}ts\.net$/.test(host)) return null;
+    return 'https://' + host + ':3144/';
+  }
+  function phoneApprovalView(r, opts) {
+    opts = opts || {};
+    var prefix = opts.prefix || 'session';
+    return { prefix: prefix, form: $(prefix + '-form'), send: $(prefix + '-send'), input: $(prefix + '-input'),
+      live: opts.live || function () { return state.reading === r; },
+      status: opts.status || sessionStatus, files: opts.files || function () { return readerFilesState(readerFilesOn() ? readerBox(r) : null); } };
+  }
+  function phoneApprovalViewLive(view) {
+    return view.live() && view.form && view.send && view.form === $(view.prefix + '-form') && view.send === $(view.prefix + '-send');
+  }
+  function clearPhoneOffer(r, view) {
+    var offer = view.form.querySelector('[data-phone-offer]'), packets = view.form.querySelector('[data-phone-packets]');
+    if (offer && offer.parentNode) offer.parentNode.removeChild(offer);
+    if (packets && packets.parentNode) packets.parentNode.removeChild(packets);
+    r.phonePackets = {}; r.phonePacketSha256 = ''; r.phoneDraft = null;
+  }
+  function refreshWebKeyOffers() {
+    if (!webKeyCapable() || WEB_KEY.refreshing) return;
+    WEB_KEY.status = null; WEB_KEY.statusAt = 0; WEB_KEY.loading = null; WEB_KEY.generation += 1;
+    WEB_KEY.views = WEB_KEY.views.filter(function (entry) { return phoneApprovalViewLive(entry.view); });
+    if (!WEB_KEY.views.length) return;
+    var views = WEB_KEY.views.slice();
+    views.forEach(function (entry) { clearPhoneOffer(entry.r, entry.view); });
+    var fresh = webKeyStatus(); WEB_KEY.refreshing = fresh;
+    fresh.then(function () { if (WEB_KEY.refreshing === fresh) WEB_KEY.refreshing = null; });
+    views.forEach(function (entry) { paintWebKeyOffer(entry.r, entry.opts); });
+  }
+  // Safari can restore this exact DOM after enrollment or revocation on the separate signer origin.
+  // Refetch once per persisted return; closed/replaced readers are pruned and no timer is installed.
+  // (Guarded: it runs at load, and a host without window events, the web-control vm harnesses, must still load.)
+  if (window.addEventListener) window.addEventListener('pageshow', function (e) {
+    if (!e || !e.persisted) return;
+    var nav = WEB_KEY.navigation; WEB_KEY.navigation = null;
+    if (nav && nav.token.completed && nav.r.phoneNavigation === nav.token) {
+      if (nav.r.sending === nav.token) nav.r.sending = false;
+      nav.r.phoneNavigation = null;
+    }
+    refreshWebKeyOffers();
+  });
+  function phonePacketDetails(p, sha) {
+    return 'Requested ' + p.action + ': ' + p.artifact + ' ' + p.version + '\nChannel: ' + p.channel + '\nDigest: ' + p.digest +
+      '\nReceiver: ' + p.provider + ' / ' + p.sessionId + '\nExpires: ' + new Date(p.exp).toISOString() + '\nPacket: ' + sha +
+      '\nThis request approves nothing until you review it and confirm on the phone.';
+  }
+  function paintWebKeyOffer(r, opts) {
+    if (!webKeyCapable()) return;
+    var view = phoneApprovalView(r, opts);
+    if (!phoneApprovalViewLive(view)) return;
+    WEB_KEY.views = WEB_KEY.views.filter(function (entry) { return phoneApprovalViewLive(entry.view) && entry.view.form !== view.form; });
+    WEB_KEY.views.push({ r: r, opts: opts, view: view });
+    var generation = WEB_KEY.generation;
+    webKeyStatus().then(function (st) {
+      if (generation !== WEB_KEY.generation || !phoneApprovalViewLive(view)) return;
+      if (!st) { clearPhoneOffer(r, view); return; }
+      var offer = view.form.querySelector('[data-phone-offer]');
+      if (offer && !!view.form.querySelector('[data-phone-setup]') === (st.activeKeys === 0)) return;
+      if (offer || st.activeKeys === 0) clearPhoneOffer(r, view);
+      if (st.activeKeys === 0) {
+        var setupUrl = webKeySetupUrl(); if (!setupUrl) return;
+        var setup = document.createElement('a');
+        setup.className = 'btn small'; setup.setAttribute('data-phone-offer', '1');
+        setup.setAttribute('data-phone-setup', '1'); setup.setAttribute('href', setupUrl); setup.setAttribute('target', '_top');
+        setup.textContent = 'Set up phone approvals';
+        view.send.parentNode.insertBefore(setup, view.send);
+        return;
+      }
+      var b = document.createElement('button');
+      b.type = 'button'; b.className = 'btn small'; b.setAttribute('data-phone-offer', '1');
+      b.setAttribute(view.prefix === 'ta' ? 'data-ta' : 'data-action', view.prefix === 'ta' ? 'approve-phone' : 'approve-on-phone');
+      b.title = 'Review an exact request on the approval page, then confirm with your phone passkey';
+      b.textContent = 'Approve on this phone';
+      view.send.parentNode.insertBefore(b, view.send);
+      return apiAnswer('/api/web-key/packets?provider=' + encodeURIComponent(r.provider) + '&sessionId=' + encodeURIComponent(r.id)).then(function (a) {
+        if (generation !== WEB_KEY.generation || !phoneApprovalViewLive(view) || view.form.querySelector('[data-phone-offer]') !== b) return;
+        var rows = a.status === 200 && a.body && a.body.ok === true && Array.isArray(a.body.packets) ? a.body.packets : [];
+        rows = rows.filter(function (row) { var p = row && row.packet; return p && p.provider === r.provider && p.sessionId === r.id &&
+          (p.action === 'install' || p.action === 'publish') && Number.isSafeInteger(p.exp) && p.exp >= Date.now() && /^[0-9a-f]{64}$/.test(row.packetSha256 || ''); });
+        r.phonePackets = {}; rows.forEach(function (row) { r.phonePackets[row.packetSha256] = row.packet; });
+        if (!rows.length) return;
+        var box = document.createElement('div'), label = document.createElement('label'), select = document.createElement('select'), disclosure = document.createElement('details'), summary = document.createElement('summary'), detail = document.createElement('pre');
+        box.className = 'phone-approval-packet'; box.setAttribute('data-phone-packets', '1'); select.id = view.prefix + '-phone-packet'; detail.id = view.prefix + '-phone-details';
+        label.textContent = 'What to approve'; label.setAttribute('for', select.id);
+        var message = document.createElement('option'); message.value = ''; message.textContent = 'Message only — no release approval'; select.appendChild(message);
+        rows.forEach(function (row) { var option = document.createElement('option'), p = row.packet; option.value = row.packetSha256;
+          option.textContent = p.action + ' ' + p.artifact + ' ' + p.version + ' / ' + p.channel; select.appendChild(option); });
+        select.value = r.phonePacketSha256 || '';
+        var update = function () { r.phonePacketSha256 = select.value; var p = r.phonePackets[select.value];
+          detail.textContent = p ? phonePacketDetails(p, select.value) : 'Message only. This authorizes no install, publish or push.';
+          if (p && view.input && !view.input.value.trim()) view.input.value = 'Approve ' + p.action + ' ' + p.artifact + ' ' + p.version + ' on ' + p.channel + '.';
+        };
+        select.addEventListener('change', update); update();
+        summary.textContent = 'Review release request'; disclosure.appendChild(summary); disclosure.appendChild(detail);
+        box.appendChild(label); box.appendChild(select); box.appendChild(disclosure); view.form.insertBefore(box, view.form.firstChild);
+      }, function () { /* No packet is selected implicitly when this read fails. */ });
+    });
+  }
+  // Only the signer on this same host, port 3144, path /, with nothing but the handoff id in the fragment.
+  function webKeySignerUrlOk(u) {
+    try {
+      var x = new URL(u);
+      return x.protocol === 'https:' && x.hostname === location.hostname && x.port === '3144' && x.pathname === '/' && !x.search && /^#h=[A-Za-z0-9_-]{16,64}$/.test(x.hash);
+    } catch (_e) { return false; }
+  }
+  function approveOnPhone(opts) {
+    opts = opts || {};
+    var r = opts.r || state.reading; if (!r || r.sending) return Promise.resolve('busy');
+    var view = phoneApprovalView(r, opts), say = view.status;
+    if (!view.live()) return Promise.resolve('stale');
+    var input = view.input, text = input ? input.value.trim() : '';
+    if (!text) { say('Write a message first.', 'error'); return Promise.resolve('empty'); }
+    if (view.files() !== 'none') { say(WEB_KEY_COPY.attachments_not_signable, 'error'); return Promise.resolve('files'); }
+    var provider = r.provider, id = r.id, packetSha = r.phonePacketSha256 || '';
+    var packet = packetSha && r.phonePackets && r.phonePackets[packetSha];
+    if (packetSha && (!packet || packet.exp < Date.now() || packet.provider !== provider || packet.sessionId !== id)) { say('That release request expired or changed. Reopen this session to load its current request.', 'error'); return Promise.resolve('packet'); }
+    var draft = r.phoneDraft;
+    if (!draft || draft.text !== text || draft.packetSha256 !== packetSha) draft = r.phoneDraft = { text: text, key: newTurnKey(), packetSha256: packetSha };
+    var bound = bindingFor(provider, id);
+    // Other senders assign boolean true. This unique truthy owner lets late callbacks and a BFCache return
+    // release only this phone operation, never a newer ordinary send or another phone operation.
+    var operation = { completed: false };
+    r.phoneNavigation = operation; r.sending = operation;
+    var ownsSending = function () { return r.sending === operation && r.phoneNavigation === operation; };
+    var releaseSending = function () { if (ownsSending()) { r.sending = false; r.phoneNavigation = null; } };
+    say('Opening the approval page.');
+    var attach = bound ? Promise.resolve(bound) : apiAnswer(sessionPath(provider, id, '/attach'), { method: 'POST', body: { cosSessionId: cosSessionId() }, timeoutMs: 20000 }).then(function (a) {
+      if (a.status >= 200 && a.status < 300 && a.body.attached === true && a.body.bindingId && typeof a.body.epoch === 'number') {
+        var b = { bindingId: a.body.bindingId, epoch: a.body.epoch, at: Date.now() };
+        rememberBinding(provider, id, b);
+        return b;
+      }
+      return null;
+    });
+    return attach.then(function (b) {
+      if (!ownsSending() || !phoneApprovalViewLive(view)) return 'stale';
+      if (!b) { say('COS cannot write to this session right now.', 'error'); return 'refused'; }
+      var request = { bindingId: b.bindingId, epoch: b.epoch, targetKey: targetKey(provider, id), clientTurnId: draft.key, prompt: draft.text };
+      if (packetSha) request.packetSha256 = packetSha;
+      return apiAnswer('/api/web-key/handoff', { method: 'POST', timeoutMs: 15000, body: request }).then(function (h) {
+        if (!ownsSending() || !phoneApprovalViewLive(view)) return 'stale';
+        var body = h.body || {};
+        if (h.status === 201 && body.ok === true && webKeySignerUrlOk(body.signerUrl)) {
+          say('Opening the approval page.');
+          location.assign(body.signerUrl);
+          operation.completed = true;
+          WEB_KEY.navigation = { r: r, token: operation };
+          return 'opened';
+        }
+        if (h.status === 201) { say('Open Control from your Mac’s Tailscale name to approve on this phone.', 'error'); return 'refused'; }
+        if (/^(binding_changed|unknown_binding)$/.test(body.error || '') && !opts.reattached) {
+          rememberBinding(provider, id, null);
+          releaseSending();
+          return approveOnPhone(Object.assign({}, opts, { r: r, reattached: true }));
+        }
+        say(WEB_KEY_COPY[body.error] || 'The Mac did not open an approval for that message.', 'error');
+        return 'refused';
+      });
+    }).then(function (how) { if (how !== 'opened') releaseSending(); return how; }, function () {
+      if (ownsSending()) { releaseSending(); say('Could not reach your Mac.', 'error'); }
+      return 'failed';
+    });
+  }
+  // ── END web-key handoff ──
+
   var HELD_MAX_MS = 5 * 60000, HELD_RETRY_MS = 8000;
   function holdUntilReplyEnds(r, draft) {
     if (!r.held.some(function (h) { return h.key === draft.key; })) {
@@ -2526,7 +4313,7 @@
         rememberParked(r, draft.key);
         if (opts.held) settleHeld(r, opts.held, 'parked');
         else { view.pending(r, draft.text, 'waiting in line'); view.clear(r, draft.text); }
-        view.status(r, b.error === 'duplicate_turn' ? 'Already waiting to send.' : (b.position ? 'The session is busy. Yours is #' + (b.position + 1) + ' in line and sends on its own.' : 'The session is busy. Yours sends next, on its own.'));
+        view.status(r, b.error === 'duplicate_turn' ? 'Already waiting to send.' : (b.landsAt === 'next_step' ? 'The session is busy. Yours lands at its next step.' : b.position ? 'The session is busy. Yours is #' + (b.position + 1) + ' in line and sends on its own.' : 'The session is busy. Yours sends next, on its own.'));
         view.queue(r);
         // 6.99.29: "The session is busy" is the gate's word as of now; the card shows the same. Last, and
         // never allowed to cost the parked message its settlement.
@@ -2622,11 +4409,50 @@
   }
 
   // Output previews are separate from composer attachments. Only the DTO fields reach the lazy viewer.
+  // opts.part (sxTurnHtml): 'before' is only the step that came before a reply's words, drawn above them; 'after' is
+  // everything else, drawn below; 'user' is a YOU turn's attached images and never a reply's outputs. No opts: all of it.
   function readerImagesHtml(turn) {
+    var opts = arguments[1], part = opts && opts.part;
+    // 6.99.35: "Show files and images your sessions make" is off (Settings, Privacy). The server sent no names, only this mark.
+    if (turn && turn.previewsOff === true) return part === 'before' ? '' : '<p class="rm-status rm-off">Previews are off. Turn them on in Settings, Privacy.</p>';
+    if (part === 'before') return readerToolsHtml(turn, true);
+    if (part === 'user') return readerToolsHtml(turn, false);
+    var head = part === 'after' ? '' : readerToolsHtml(turn, true);
     var images = turn && Array.isArray(turn.outputImages) ? turn.outputImages.filter(function (x) {
       return x && /^ai_[a-f0-9]{64}$/.test(x.id || '') && (x.state === 'available' || x.state === 'unavailable');
     }).map(function (x) { return { id: x.id, label: String(x.label || 'Output image').slice(0, 180), state: x.state, reason: x.reason }; }) : [];
-    return images.length ? '<div data-reader-images="' + esc(JSON.stringify(images)) + '"><p class="rm-status" role="status">Loading image previews…</p></div>' : '';
+    return head + (images.length ? '<div data-reader-images="' + esc(JSON.stringify(images)) + '"><p class="rm-status" role="status">Loading image previews…</p></div>' : '') + readerFilesHtml(turn) + readerToolsHtml(turn, false);
+  }
+  // 11/08: images the session looked at (a Read of a PNG, a screenshot) and a prompt's attached images, as the Claude
+  // app shows them under a step: "Read", "1 of 2". Only the checked DTO fields travel; the viewer loads them lazily by
+  // opaque id. `before`: the step came before the turn's words. The count of more rides on the last strip shown.
+  var READER_TOOLS = ['Read', 'Screenshot', 'Image', 'Attached'];
+  function readerToolsHtml(turn, before) {
+    var all = turn && Array.isArray(turn.toolImages) ? turn.toolImages.filter(function (x) {
+      return x && /^ti_[a-f0-9]{64}$/.test(x.id || '') && (x.state === 'available' || x.state === 'unavailable');
+    }).slice(0, 12) : [];
+    var mine = all.filter(function (x) { return (x.before === true) === before; }).map(function (x) {
+      return { id: x.id, tool: READER_TOOLS.indexOf(x.tool) >= 0 ? x.tool : 'Image', index: Math.floor(Number(x.index)) || 1, total: Math.floor(Number(x.total)) || 1, state: x.state,
+        reason: ['outside_workspace', 'unavailable', 'too_large', 'missing', 'secret_file'].indexOf(x.reason) >= 0 ? x.reason : undefined };
+    });
+    var hasAfter = all.some(function (x) { return x.before !== true; });
+    var more = Math.max(0, Math.min(9999, Math.floor(Number(turn && turn.toolImagesMore)) || 0));
+    var hasBefore = all.some(function (x) { return x.before === true; });
+    var mineMore = more && (before ? hasBefore && !hasAfter : !(hasBefore && !hasAfter)) ? more : 0;
+    if (!mine.length && !mineMore) return '';
+    return '<div data-reader-tools="' + esc(JSON.stringify({ items: mine, more: mineMore, before: before })) + '"><p class="rm-status" role="status">Loading images…</p></div>';
+  }
+  // 6.99.35: files a Claude session sent with SendUserFile that are not images. Names, types and sizes only; the
+  // lazy viewer opens them through the authenticated output-files route by opaque id.
+  var READER_FILE_KINDS = ['pdf', 'text', 'html', 'image', 'file'];
+  function readerFilesHtml(turn) {
+    var files = turn && Array.isArray(turn.outputFiles) ? turn.outputFiles.filter(function (x) {
+      return x && /^af_[a-f0-9]{64}$/.test(x.id || '') && (x.state === 'available' || x.state === 'unavailable');
+    }).map(function (x) {
+      return { id: x.id, name: String(x.name || 'File').slice(0, 120), kind: READER_FILE_KINDS.indexOf(x.kind) >= 0 ? x.kind : 'file',
+        type: String(x.type || 'File').slice(0, 40), size: typeof x.size === 'number' && x.size >= 0 ? x.size : null, state: x.state, reason: x.reason };
+    }) : [];
+    return files.length ? '<div data-reader-files="' + esc(JSON.stringify(files)) + '"><p class="rm-status" role="status">Loading files…</p></div>' : '';
   }
   function readerImagesStop(host) {
     if (!host) return;
@@ -2635,15 +4461,17 @@
   }
   function readerImagesMount(host, r) {
     if (!host || !r) return;
-    if (!host.querySelectorAll('[data-reader-images]').length) { readerImagesStop(host); return; }
+    if (!host.querySelectorAll('[data-reader-images]').length && !host.querySelectorAll('[data-reader-files]').length && !host.querySelectorAll('[data-reader-tools]').length && !host.querySelectorAll('[data-reader-links]').length) { readerImagesStop(host); return; }
     var owner = host.__cosImageOwner = {};
-    ensurePane('readerMedia', 4000).then(function (kit) {
+    // Preview engine phase 1: the shared viewer loads first, so link cards and sent files open in it. If it cannot load,
+    // links stay their words and sent files keep the 6.99.35 viewer.
+    ensurePane('preview', 4000).catch(function () { return null; }).then(function () { return ensurePane('readerMedia', 4000); }).then(function (kit) {
       if (host.__cosImageOwner !== owner || host.isConnected === false) return;
       if (!kit) throw new Error('Image previews could not load.');
       kit.mount(host, r.provider, r.id);
     }).catch(function () {
       if (host.__cosImageOwner !== owner || host.isConnected === false) return;
-      host.querySelectorAll('[data-reader-images]').forEach(function (slot) {
+      Array.prototype.slice.call(host.querySelectorAll('[data-reader-images]')).concat(Array.prototype.slice.call(host.querySelectorAll('[data-reader-files]')), Array.prototype.slice.call(host.querySelectorAll('[data-reader-tools]'))).forEach(function (slot) {
         slot.textContent = 'Image previews could not load. ';
         var retry = document.createElement('button'); retry.type = 'button'; retry.className = 'link-btn'; retry.textContent = 'Retry images';
         retry.addEventListener('click', function () { readerImagesMount(host, r); }); slot.appendChild(retry);
@@ -2669,7 +4497,7 @@
     out += original ? '## Original request\n\n' + original + '\n\n## Conversation\n\n' : '## Conversation\n\n';
     if (r.more) out += '[Older turns omitted. COS serves the newest ' + turns.length + '. Original request kept.]\n\n';
     turns.forEach(function (t) {
-      var text = String(t.text).trim();
+      var text = String(t.text).trim().replace(/\[([^\]\n]*)\]\(cos-file:\d{1,2}\)/g, '$1');
       if (original && t.role === 'user' && text === original) return;
       out += '**' + (t.role === 'user' ? 'You' : 'Assistant') + '**\n\n' + text + '\n\n';
     });
@@ -2687,9 +4515,16 @@
   // Markdown for an assistant turn (Control renders replies with COSMarkdownView): headings, lists,
   // code, quotes, tables, rules, links. Everything is escaped first, so a reply can never add
   // markup of its own; a link keeps only an http(s) address.
+  // Preview engine phase 1: the server turns a reply's local link into `[words](cos-file:N)`, N its card in the turn's
+  // outputLinks. While a turn with cards renders (sxInline.links), that becomes a slot panes/reader-media.js fills with the
+  // card; anywhere else (a file shown in the viewer, previews off, an older turn) it is just the words.
   function sxInline(s) {
+    var links = sxInline.links;
     var codes = [];
     s = s.replace(/`([^`\n]+)`/g, function (_m, c) { codes.push(c); return '\u0000' + (codes.length - 1) + '\u0000'; });
+    s = s.replace(/\[([^\]\n]*)\]\(cos-file:(\d{1,2})\)/g, function (_m, words, n) {
+      return links && Number(n) < links ? '<span class="rm-link-slot" data-reader-link="' + Number(n) + '">' + words + '</span>' : words;
+    });
     s = s.replace(/\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');
     s = s.replace(/\*\*([^*\n]+)\*\*/g, '<strong>$1</strong>').replace(/__([^_\n]+)__/g, '<strong>$1</strong>');
     s = s.replace(/(^|[^*\w])\*([^*\s][^*\n]*?)\*(?!\w)/g, '$1<em>$2</em>');
@@ -2700,7 +4535,13 @@
   var SX_RULE = /^\s*([-*_])(\s*\1){2,}\s*$/;
   var SX_TABLE_SEP = /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/;
   function sxCells(row) { return row.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map(function (c) { return c.trim(); }); }
-  function sxMd(text) {
+  function sxMd(text, links) {
+    // links: the turn's card list. Only a real list turns markers into slots (the count bounds the indexes).
+    var held = sxInline.links;
+    sxInline.links = Array.isArray(links) && links.length ? Math.min(20, links.length) : null;
+    try { return sxMdBody(text); } finally { sxInline.links = held; }
+  }
+  function sxMdBody(text) {
     var lines = esc(String(text || '')).replace(/\r\n?/g, '\n').split('\n');
     var out = [], para = [], i = 0;
     function flush() { if (para.length) { out.push('<p>' + para.map(sxInline).join('<br>') + '</p>'); para = []; } }
@@ -2722,12 +4563,16 @@
       if (line.indexOf('|') >= 0 && i + 1 < lines.length && SX_TABLE_SEP.test(lines[i + 1])) {
         flush();
         var head = sxCells(line), aligns = sxCells(lines[i + 1]).map(function (a) { return /^:-+:$/.test(a) ? 'center' : /-:$/.test(a) ? 'right' : ''; });
-        var cell = function (tag, c, k) { return '<' + tag + (aligns[k] ? ' style="text-align:' + aligns[k] + '"' : '') + '>' + sxInline(c) + '</' + tag + '>'; };
         i += 2;
         var body = [];
         while (i < lines.length && lines[i].indexOf('|') >= 0 && lines[i].trim()) { body.push(sxCells(lines[i])); i += 1; }
-        out.push('<div class="sx-table"><table><thead><tr>' + head.map(function (c, k) { return cell('th', c, k); }).join('') + '</tr></thead><tbody>' +
-          body.map(function (row) { return '<tr>' + head.map(function (_c, k) { return cell('td', row[k] || '', k); }).join('') + '</tr>'; }).join('') + '</tbody></table></div>');
+        var fit = tableFit([head].concat(body));
+        var cell = function (tag, c, k, first) {
+          var st = [aligns[k] ? 'text-align:' + aligns[k] : '', fit.width(k, first)].filter(Boolean).join(';');
+          return '<' + tag + (st ? ' style="' + st + '"' : '') + '>' + fit.cell(k, sxInline(c), first) + '</' + tag + '>';
+        };
+        out.push('<div class="sx-table tf-wrap"><table class="' + fit.tableClass + ' tf-grid"><thead><tr>' + head.map(function (c, k) { return cell('th', c, k, true); }).join('') + '</tr></thead><tbody>' +
+          body.map(function (row) { return '<tr>' + head.map(function (_c, k) { return cell('td', row[k] || '', k, false); }).join('') + '</tr>'; }).join('') + '</tbody></table></div>');
         continue;
       }
       if (/^\s*&gt;/.test(line)) {
@@ -2748,6 +4593,17 @@
   sxMd.unescaped = function (lines) {
     return lines.join('\n').split(/\n\s*\n/).map(function (p) { return '<p>' + p.split('\n').map(sxInline).join('<br>') + '</p>'; }).join('');
   };
+  // The card list a turn's Markdown box carries for panes/reader-media.js, checked here: ids and words only.
+  sxMd.linksAttr = function (turn) {
+    var list = turn && Array.isArray(turn.outputLinks) ? turn.outputLinks.slice(0, 20).map(function (x) {
+      return x && /^al_[a-f0-9]{64}$/.test(x.id || '') && (x.state === 'available' || x.state === 'unavailable') ? {
+        id: x.id, name: String(x.name || 'File').slice(0, 120), label: String(x.label || '').slice(0, 120), kind: String(x.kind || 'file').slice(0, 20),
+        type: String(x.type || 'File').slice(0, 40), size: typeof x.size === 'number' && x.size >= 0 ? x.size : undefined,
+        line: typeof x.line === 'number' && x.line > 0 ? Math.floor(x.line) : undefined, state: x.state, reason: typeof x.reason === 'string' ? x.reason.slice(0, 30) : undefined
+      } : { id: '', state: 'invalid' };
+    }) : [];
+    return list.length ? ' data-reader-links="' + esc(JSON.stringify(list)) + '"' : '';
+  };
   // Nested lists by indent: a deeper item opens a list inside the open item, a shallower one closes back.
   function sxListBlock(lines, i) {
     var html = '', stack = [];
@@ -2783,7 +4639,7 @@
   // One turn's identity, for telling which turns a refresh brought that the page already shows.
   function sxTurnSig(t) {
     var text = String(t.text || t.content || '').trim();
-    return (String(t.role || '').toLowerCase() === 'user' ? 'u' : 'a') + '|' + (t.at || '') + '|' + text.length + '|' + text.slice(0, 48) + '|' + readerImagesHtml(t);
+    return (String(t.role || '').toLowerCase() === 'user' ? 'u' : 'a') + '|' + (t.at || '') + '|' + text.length + '|' + text.slice(0, 48) + '|' + readerImagesHtml(t) + (sxMd.linksAttr ? sxMd.linksAttr(t) : '');
   }
   function sxTurnHtml(t) {
     var role = String(t.role || '').toLowerCase() === 'user' ? 'user' : 'assistant';
@@ -2792,7 +4648,9 @@
     var when = at ? (Date.now() - at.getTime() < 86400000 ? clock(at) : sxShortDate(at)) : '';
     return '<div class="turn ' + role + ' sx-turn" data-sig="' + esc(sxTurnSig(t)) + '"><span class="who"><span>' + (role === 'user' ? 'YOU' : 'ASSISTANT') + '</span>' +
       (when ? '<span class="sx-turn-when">' + esc(when) + '</span>' : '') + '</span>' +
-      (role === 'user' ? '<div class="sx-plain">' + esc(text) + '</div>' : '<div class="sx-md">' + sxMd(text) + '</div>' + readerImagesHtml(t)) + '</div>';
+      // A YOU turn shows only its attached images (and the previews-off mark); never a reply's outputs.
+      (role === 'user' ? '<div class="sx-plain">' + esc(text) + '</div>' + readerImagesHtml(t, { part: 'user' })
+        : readerImagesHtml(t, { part: 'before' }) + '<div class="sx-md"' + (sxMd.linksAttr ? sxMd.linksAttr(t) : '') + '>' + sxMd(text, t.outputLinks) + '</div>' + readerImagesHtml(t, { part: 'after' })) + '</div>';
   }
   // A refresh never rebuilds what you are reading (Miles, /qa: "start to scroll and then it reloads
   // the section"). The server's window slides as a session grows, so the turns the page already
@@ -4665,11 +6523,12 @@
 
   // ── events (one delegated listener) ─────────────────────
   document.addEventListener('click', function (e) {
-    var t = e.target.closest('[data-today-next],[data-today-needs],[data-today],[data-goto],[data-pane],[data-session],[data-meeting],[data-speakers],[data-action],[data-open-ask],[data-theme-choice],#topbar-back,#section-btn,#sign-out,#copy-link,#ask-close,#auth-switch,#auth-token-show,#device-code-btn');
+    var t = e.target.closest('[data-today-next],[data-next-prep],[data-next-prep-cancel],[data-next-prep-remove],[data-today-needs],[data-today],[data-goto],[data-pane],[data-session],[data-meeting],[data-speakers],[data-action],[data-open-ask],[data-theme-choice],#topbar-back,#section-btn,#sign-out,#copy-link,#ask-close,#auth-switch,#auth-token-show,#auth-retry,#device-code-btn');
     if (!t) { if (e.target.id === 'ask-sheet') closeAsk(); if (e.target.id === 'section-menu') closeMenu(); return; }
     var inSheet = !!t.closest('#ask-sheet');
     if (t.id === 'topbar-back') return goBack();
     if (t.id === 'section-btn') return openMenu();
+    if (t.id === 'auth-retry') { t.disabled = true; t.textContent = 'Checking'; bootStatus().then(function () { t.disabled = false; t.textContent = 'Try again'; }); return; }
     if (t.id === 'auth-switch') {
       var toToken = $('auth-token-block').classList.contains('hidden');
       $('auth-token-block').classList.toggle('hidden', !toToken);
@@ -4698,6 +6557,9 @@
     if (t.hasAttribute('data-open-ask')) return openAsk();
     if (t.hasAttribute('data-today')) return t.getAttribute('data-today') === 'pet' ? petTap(t) : openTodayAction(t);
     if (t.hasAttribute('data-today-next')) return prepNext();
+    if (t.hasAttribute('data-next-prep')) return toggleNextPrep(t.getAttribute('data-next-prep'));
+    if (t.hasAttribute('data-next-prep-cancel')) return closeNextPrep(true);
+    if (t.hasAttribute('data-next-prep-remove')) return removeNextPrepFile(t.getAttribute('data-next-prep-remove'));
     if (t.hasAttribute('data-today-needs')) {
       var which = t.getAttribute('data-today-needs');
       if (which === 'all') TODAY.showAllNeeds = true;
@@ -4717,6 +6579,9 @@
     if (t.hasAttribute('data-speakers')) return go('speakers', [t.getAttribute('data-speakers')]);
     var action = t.getAttribute('data-action');
     if (action === 'fork-session') return sendSessionTurn(true);
+    if (action === 'conn-retry') return connRetry(true);
+    if (action === 'conn-hide-signin') { CONN.hideFor = signinEndsAt(); return connPaint(); }
+    if (action === 'approve-on-phone') return approveOnPhone();
     if (action === 'send-anyway') { var rev = state.reading && state.reading.sendAnyway; if (state.reading) state.reading.sendAnyway = null; return sendSessionTurn(false, { acknowledgedRevision: rev }); }
     if (action === 'stop-session') return stopSession();
     if (action === 'drop-after') return dropHeld();
@@ -4742,6 +6607,7 @@
     if (action === 'ask-cos' && q) return askSheetSend(q);
     if (action === 'ask-file' && q) return fileToInbox(q);
     if (action === 'ask-meaning' && q) { $('ask-hits').innerHTML = skeletonRows(3); findByMeaning(q).then(function (html) { var el = $('ask-hits'); if (el) el.innerHTML = html; }); return; }
+    if (action === 'meaning-consent') { meaningChoose(t.getAttribute('data-provider'), t.getAttribute('data-choice')); if (q) { $('ask-hits').innerHTML = skeletonRows(3); findByMeaning(q).then(function (html) { var el = $('ask-hits'); if (el) el.innerHTML = html; }); } return; }
     if (action === 'ask-work' && q) {
       closeAsk(); go('work');
       // The Work pane (panes/work.js) owns its search box; hand it the query.
@@ -4764,6 +6630,8 @@
           showAuth(err && err.status ? err.message : UNREACHABLE_COPY);
         });
     } else if (f.id === 'session-form') sendSessionTurn(false);
+    else if (f.id === 'today-ask') sendTodayAsk();
+    else if (f.hasAttribute && f.hasAttribute('data-next-prep-form')) startNextPrep();
     else if (f.id === 'sessions-search-form') { $('sessions-q').blur(); searchSessions(); }
     else if (f.id === 'ask-form') {
       var hits = $('ask-hits'); if (hits && $('ask-q').value.trim().length >= 2) renderAsk();
@@ -4774,6 +6642,7 @@
   document.addEventListener('change', function (e) {
     if (e.target && e.target.hasAttribute && e.target.hasAttribute('data-ask-file')) { addAskFiles(e.target.files); e.target.value = ''; }
     if (e.target && e.target.hasAttribute && e.target.hasAttribute('data-sx-file')) { addReaderFiles(e.target.files); e.target.value = ''; }
+    if (e.target && e.target.hasAttribute && e.target.hasAttribute('data-next-prep-file')) { addNextPrepFiles(e.target.files); e.target.value = ''; }
   });
   // The Sessions reader's box: a pasted screenshot, and files dropped on it.
   document.addEventListener('paste', function (e) {
@@ -4803,6 +6672,7 @@
   document.addEventListener('input', function (e) {
     if (e.target.tagName === 'TEXTAREA') autoGrow(e.target);
     if (e.target.id === 'ask-q') renderAsk();
+    if (e.target.hasAttribute && e.target.hasAttribute('data-next-prep-steer')) nextPrepInput(e.target);
     if (e.target.id === 'sessions-q' && !e.target.value.trim()) renderSessionGroups(state.sessions);
   });
   document.addEventListener('keydown', function (e) {
@@ -4810,6 +6680,7 @@
     if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === 'k') { e.preventDefault(); openAsk(); return; }
     if (e.key === 'Escape' && !$('ask-sheet').classList.contains('hidden')) { closeAsk(); return; }
     if (e.key === 'Escape' && !$('section-menu').classList.contains('hidden')) { closeMenu(); $('section-btn').focus(); return; }
+    if (e.key === 'Escape' && NEXT_PREP.open && closeNextPrep(false)) { e.preventDefault(); return; }
     if (returnSends(e)) { e.preventDefault(); var form = e.target.closest('form'); if (form) form.requestSubmit(); }
   });
   document.querySelectorAll('[data-mode]').forEach(function (b) {
@@ -4825,6 +6696,7 @@
   // is closed and the page's last reading is however old the visit was. Open the stream again and read the turns.
   window.addEventListener('pageshow', function (e) {
     if (!e || !e.persisted) return;
+    liveResume();   // 7.0.1: re-read the list now, then resume the live stream from its last id
     var r = state.reading;
     if (r && r.provider && r.id) {
       if (state.stream) { try { state.stream.close(); } catch (_e) {} state.stream = null; }
@@ -4833,13 +6705,24 @@
     if (state.pane === 'today' && !$('app-shell').classList.contains('hidden')) loadToday();
   });
   document.addEventListener('visibilitychange', function () {
-    if (document.hidden || $('app-shell').classList.contains('hidden')) return;
+    if (document.hidden) { liveHide(); return; }
+    if ($('app-shell').classList.contains('hidden')) return;
+    liveResume();   // 7.0.1: re-read the list now, then resume the live stream from its last id
     // Coming back to the page refreshes Today in place. Other panes keep what is on screen:
     // rebuilding them here moved the page under Miles's finger ("it reloads the section").
     if (state.pane === 'today' && Date.now() - (state.lastLoad.today || 0) > 60000) { state.lastLoad.today = Date.now(); loadToday(); }
     // Back within the minute: Today keeps its data, but the pet's loop stopped while hidden, so restart it.
     else if (state.pane === 'today' && PET.pose && !PET.timer) renderPet(state.sessions || []);
   });
+  // 7.0.1: back on the network, the same as coming back to the page.
+  window.addEventListener('online', function () { if (!document.hidden) liveResume(); });
+  // 7.0.1: Today's Refresh (todayRefresh).
+  document.addEventListener('click', function (e) {
+    var b = e.target && e.target.closest && e.target.closest('[data-today-refresh]');
+    if (!b) return;
+    e.preventDefault();
+    todayRefresh();
+  });
   window.addEventListener('message', function (e) {
     if (e.origin !== location.origin) return;
     var d = e.data;
@@ -4886,20 +6769,64 @@
   //            inset, so a pinch zoom magnifies the sheet instead of shrinking its layout into the zoomed window.
   //   below    what of the layout viewport lies under that box: the backdrop alone reaches down over it.
   // No visualViewport (old browsers): the whole layout viewport, nothing covered.
+  // 7.0.2 (A3, the Duo audit): some web views shrink innerHeight itself while the keyboard is up (WKWebView in Comet or
+  // Chrome on iOS may), and re-reading it then measured a covered area of 0, so no keyboard was ever seen. So on a touch
+  // screen, while a field that types has focus, layoutH is the tallest unzoomed innerHeight seen at this width (so this
+  // orientation): the keyboard is the same inset whether the browser shrinks visualViewport only or the whole web view.
+  //   - It never goes past the last height read with no field focused (free) plus VP_SLACK_PX, so a browser bar that
+  //     comes back while typing is never an 80 px keyboard (QA W1). It never goes under innerHeight itself.
+  //   - It starts, on focus, from free: the full height, never a height read while a keyboard was still closing. For
+  //     VP_SETTLE_MS after a blur, free only grows (QA W2).
+  //   - With no field focused, or on a fine pointer (a Mac window resized or DevTools docked while typing, QA N3), it
+  //     follows innerHeight exactly as before 7.0.2. A select is not typing: its picker never counts as a keyboard.
+  //   - A new width (a turn) starts over. Pinch zoom keeps the height read before the zoom.
+  //   dock     the CURRENT layout viewport under the visible box (innerHeight less top and height): what a sticky or
+  //            fixed composer clears to sit above the keyboard. 0 when the web view itself shrank.
   var VP = { layoutH: 0 };
+  VP.maxH = 0; VP.w = -1; VP.free = 0; VP.typing = false; VP.blurAt = 0;
+  var VP_SLACK_PX = 20, VP_SETTLE_MS = 1000;
+  function vpTyping() {
+    var a = document.activeElement;
+    if (!a || !a.tagName) return false;
+    var tag = String(a.tagName).toUpperCase();
+    if (tag === 'TEXTAREA') return true;
+    if (tag === 'INPUT') return !/^(checkbox|radio|button|submit|reset|range|color|file|image|hidden)$/i.test(String(a.type || 'text'));
+    return !!a.isContentEditable;
+  }
   function viewportFit() {
     var vv = window.visualViewport, de = document.documentElement;
     var inner = window.innerHeight || (de && de.clientHeight) || 0;
     var scale = vv && vv.scale > 0 ? vv.scale : 1, zoomed = scale > 1.01;
-    if (!zoomed || !VP.layoutH) VP.layoutH = zoomed ? Math.max(inner, (de && de.clientHeight) || 0) : inner;
+    // A turn always changes the width. The orientation type is not read: an engine that derives it from the viewport's
+    // aspect flips it when the keyboard shrinks a web view wider than it is then tall (WebKit, 382x266), which would
+    // throw away the very height the keyboard is measured against.
+    var w = window.innerWidth || 0;
+    if (w !== VP.w) { VP.w = w; VP.maxH = 0; VP.free = 0; }
+    if (!zoomed) {
+      var coarse = !window.matchMedia || !!window.matchMedia('(any-pointer: coarse)').matches;
+      var typing = coarse && vpTyping(), now = Date.now();
+      if (!typing) {
+        if (VP.typing) VP.blurAt = now;
+        VP.free = VP.free && now - VP.blurAt < VP_SETTLE_MS ? Math.max(VP.free, inner) : inner;
+        VP.maxH = inner;
+        VP.layoutH = inner;
+      } else {
+        if (!VP.free) VP.free = inner;
+        VP.maxH = Math.max(VP.typing ? VP.maxH : VP.free, inner);
+        VP.layoutH = Math.max(inner, Math.min(VP.maxH, VP.free + VP_SLACK_PX));
+      }
+      VP.typing = typing;
+    }
+    else if (!VP.layoutH) VP.layoutH = Math.max(inner, (de && de.clientHeight) || 0);
     var H = VP.layoutH;
-    if (!vv || !(vv.height > 0)) return { layoutH: H, top: 0, height: H, inset: 0, below: 0, scale: 1, zoomed: false, vv: false };
+    if (!vv || !(vv.height > 0)) return { layoutH: H, top: 0, height: H, inset: 0, below: 0, dock: 0, scale: 1, zoomed: false, vv: false };
     var inset = Math.max(0, Math.round(H - vv.height * scale));
     var top, height;
     if (!zoomed) { top = Math.max(0, Math.round(vv.offsetTop || 0)); height = Math.min(Math.round(vv.height), H); }
     else { height = H - inset; top = Math.min(Math.max(0, Math.round(vv.offsetTop || 0)), inset); }
     if (top + height > H) top = Math.max(0, H - height);
-    return { layoutH: H, top: top, height: height, inset: inset, below: Math.max(0, H - top - height), scale: scale, zoomed: zoomed, vv: true };
+    var below = Math.max(0, H - top - height);
+    return { layoutH: H, top: top, height: height, inset: inset, below: below, dock: zoomed ? below : Math.max(0, Math.round(inner) - top - height), scale: scale, zoomed: zoomed, vv: true };
   }
 
   // ── layout breadcrumbs (6.99.30) ──────────────────────
@@ -4908,8 +6835,12 @@
   // rotation, 30 lines per 10 s per client) when an overlay opens and each time its keyboard state changes. Numbers and
   // a browser family only: no address, no text, no ids, never the user agent string itself. At most one identical
   // line per 2 s and LAYOUT_CRUMB_MAX a page load, fire and forget.
-  var LAYOUT_CRUMB_MAX = 40, LAYOUT_CRUMB_GAP_MS = 2000;
-  var crumbs = { sent: 0, last: '', lastAt: 0 };
+  // 7.0.2 (A1): every pane reports now (focus, keyboard open and close, the gap after it closes), so the cap is 80 a
+  // page load, in two budgets: focus lines have LAYOUT_FOCUS_MAX of them, everything else the rest, so a page of typing
+  // never starves the keyboard reports (QA W3). At most LAYOUT_CRUMB_RATE leave in any 10 s, under the server's 30
+  // (routes/diag.ts), and a focus line only while that window is under half full.
+  var LAYOUT_CRUMB_MAX = 80, LAYOUT_FOCUS_MAX = 20, LAYOUT_CRUMB_GAP_MS = 2000, LAYOUT_CRUMB_RATE = 20, LAYOUT_CRUMB_WINDOW_MS = 10000;
+  var crumbs = { sent: 0, focus: 0, last: '', lastAt: 0, recent: [] };
   /** The browser family, from the UA string, for the breadcrumb. Comet first: it says Chrome or Safari too. */
   function uaClass(ua) {
     ua = String(ua == null ? (navigator && navigator.userAgent) || '' : ua);
@@ -4935,8 +6866,13 @@
       var x = extra || {};
       Object.keys(x).forEach(function (k) { var v = x[k]; if (/^[a-z][a-zA-Z0-9]{0,15}$/.test(k) && (typeof v === 'number' || typeof v === 'boolean' || (typeof v === 'string' && v.length <= 24))) data[k] = typeof v === 'number' ? r(v) : v; });
       var key = JSON.stringify(data), now = Date.now();
-      if (crumbs.sent >= LAYOUT_CRUMB_MAX || (key === crumbs.last && now - crumbs.lastAt < LAYOUT_CRUMB_GAP_MS)) return false;
-      crumbs.sent++; crumbs.last = key; crumbs.lastAt = now;
+      var focusLine = data.what === 'focus';
+      if (focusLine ? crumbs.focus >= LAYOUT_FOCUS_MAX : crumbs.sent - crumbs.focus >= LAYOUT_CRUMB_MAX - LAYOUT_FOCUS_MAX) return false;
+      if (key === crumbs.last && now - crumbs.lastAt < LAYOUT_CRUMB_GAP_MS) return false;
+      crumbs.recent = crumbs.recent.filter(function (t) { return now - t < LAYOUT_CRUMB_WINDOW_MS; });
+      if (crumbs.recent.length >= (focusLine ? LAYOUT_CRUMB_RATE / 2 : LAYOUT_CRUMB_RATE)) return false;
+      crumbs.sent++; if (focusLine) crumbs.focus++;
+      crumbs.last = key; crumbs.lastAt = now; crumbs.recent.push(now);
       api('/api/diag/client', { method: 'POST', body: { ts: now, level: 'info', event: 'web.layout', data: data }, timeoutMs: 5000 }).catch(function () {});
       return true;
     } catch (_e) { return false; }
@@ -4944,7 +6880,7 @@
 
   // ── the shared kit for pane modules (panes/*.js) ───────
   window.COSWeb = {
-    $: $, esc: esc, md: md, plain: plain, api: api, toast: toast, ago: ago, clock: clock, toDate: toDate,
+    $: $, esc: esc, md: md, plain: plain, structureLensAnswer: structureLensAnswer, tableFit: tableFit, api: api, toast: toast, ago: ago, clock: clock, toDate: toDate,
     plural: plural, countWord: countWord, dayWord: dayWord, plainDay: plainDay, providerLabel: providerLabel, domainLabel: domainLabel,
     skeletonRows: skeletonRows, emptyBox: emptyBox, setStatus: setStatus, autoGrow: autoGrow,
     readStore: readStore, writeStore: writeStore, copyText: copyText, isPhone: isPhone,
@@ -4971,7 +6907,25 @@
     serverUp: function () { return SERVER.up; },
     // Panes with their own fetch (the questions poll) say whether the Mac answered, so a "down" mark never outlives it.
     noteServer: function (up) { noteServer(up); },
-    onServer: function (fn) { SERVER.hooks.push(fn); }
+    onServer: function (fn) { SERVER.hooks.push(fn); },
+    // Duo tables: the resizable divider between a list and its reader (splitKit above), for panes/*.js.
+    splitKit: { mount: mountSplit, handle: splitHandleHtml, fullButton: splitFullButton },
+    // 7.0.1: the one live stream (docs/live-events-contract.md). mode(): idle, connecting, live, reconnecting, busy or
+    // absent. on(fn) hears each applied frame ({ kind, key, session, previous }). session(provider, id): the live
+    // record, or null. age(): "As of 2 min ago" when the counts are not live, else ''.
+    live: {
+      mode: function () { return LIVE.mode; },
+      on: function (fn) { if (typeof fn === 'function') LIVE.hooks.push(fn); },
+      session: function (provider, id) {
+        if (!liveCanOverlay()) return null;   // outside live the list is the truth (review W1)
+        var byKey = {};
+        Object.keys(LIVE.sessions).forEach(function (k) { var ls = LIVE.sessions[k]; byKey[liveKey(ls.provider, ls.sessionId)] = ls; });
+        var j = liveMatch(liveKey(provider, id), Object.keys(byKey));
+        return j ? byKey[j] : null;
+      },
+      age: function () { return liveAge(); },
+      clock: liveClock
+    }
   };
   // Today as a place to act (panes/today-actions.js, Miles 11/06): what the Today cards show, a repaint after a
   // decision, and the Sessions reader's own pieces, so the overlay sends and reads through the reader's code.
@@ -5000,6 +6954,7 @@
     questionsChanged: function () { if (TODAY.at) { paintNeeds(); if (state.pane === 'today' && !TODAY.offline) renderPet(state.sessions || []); } }
   };
   window.COSWeb.sessionKit = {
+    phoneOffer: paintWebKeyOffer, approvePhone: approveOnPhone,
     // A session object for continueSession, with the overlay's own view (READER_VIEW's methods).
     session: function (provider, id, view) {
       return { provider: provider, id: id, draft: null, held: [], view: view, verdict: null, refusal: null, cautionAck: false, feed: newFeed(), live: null, queued: 0 };
@@ -5008,14 +6963,153 @@
     newKey: newTurnKey,
     probe: function (r) { return sxProbeAttach(r); },
     path: sessionPath, answer: apiAnswer,
-    notSent: { rows: notSentRows, line: notSentLine, note: noteNotSent, get: notSentFor },
-    imageHtml: readerImagesHtml, imagesMount: readerImagesMount, imagesStop: readerImagesStop,
+    notSent: { rows: notSentRows, line: notSentLine, label: notSentLabel, note: noteNotSent, get: notSentFor },
+    imageHtml: readerImagesHtml, imagesMount: readerImagesMount, imagesStop: readerImagesStop, linksAttr: function (t) { return sxMd.linksAttr(t); },
     feed: { fresh: newFeed, apply: applyFeed, word: sxFeedWord, detail: sxFeedDetail, tool: sxToolLine, elapsed: sxElapsed, fallback: sxFallbackLine,
       truth: sxTruth, settle: sxSettle, noteList: sxNoteList, noteGate: sxNoteGate, gateStale: sxGateStale, promptLine: sxPromptLine, parkNoteShows: sxParkNoteShows },
     title: sxTitle, stateOf: sxState, stateLabel: function (s) { return sxStateLabel(s, sxState(s)); },
-    parkCopy: function (p) { return SX_PARK[sxProvider(p)]; }, providerLabel: sxProviderLabel, markdown: sxMd
+    parkCopy: function (p, r, hasFiles) { return r ? sxParkLine(r, hasFiles) : SX_PARK[sxProvider(p)]; }, providerLabel: sxProviderLabel, markdown: sxMd
   };
 
+  // ── layout reports and the visible box, every pane (7.0.2) ──
+  // The Duo audit (11/07): only Today's session sheet ever sent a layout report, and only when its classes flipped, so
+  // the COS chat composer, the front screen Miles types on most, never sent one, and a keyboard the code failed to see
+  // sent nothing at all. Now, through layoutCrumb (numbers and fixed labels only, never text or ids):
+  //   device     once per page load, after sign-in: the screen, the pixel ratio, safe areas, pointer kind
+  //   focus      a field that types gets focus, on any pane, on a touch screen: its computed font size, the scroll
+  //              position and range, and innerWidth against scrollWidth, as scw (zoom vs pan vs a wider page)
+  //   kb-open, kb-close  EVERY keyboard open and close, numbered, so a repeat is never dropped as a duplicate; with
+  //              innerHeight against the layout height (shrank: the web view itself got shorter)
+  //   kb-after   KB_AFTER_MS after a close: the gap below the composer that had the keyboard, scrollY against its
+  //              range, and 100dvh, 100svh and 100lvh in px; measured before and after the panes settle
+  // The same pass publishes the visible box for CSS on <html>: --vv-top, --vv-h, --vv-below (the layout viewport under
+  // the visible box, viewportFit's dock) and html.kb-up while an on-screen keyboard is up (KB_UP_PX or more covered
+  // with a typing field focused). Panes hear open, close, move (the visible box changed while it is up) and after
+  // through COSWeb.onKeyboard; COSWeb.keyboardUp says whether it is up now. Which composer the keyboard is for is the
+  // pane's to mark (panes/cos-chat.js sets html.kb-chat and .cc-kb).
+  var KB_UP_PX = 120, KB_AFTER_MS = 300;
+  var LR = { up: false, frame: 0, after: 0, cycle: 0, focusN: 0, device: false, field: null, hooks: [], box: '', zoomed: false, touchAt: 0 };
+  function lrPane() { var r = parseRoute(); return String(r.pane + (r.args[0] === 'cos' ? '.cos' : '')).slice(0, 24); }
+  function lrKind(a) {
+    var tag = String((a && a.tagName) || '').toLowerCase();
+    return (tag === 'input' ? 'input.' + String(a.type || 'text').toLowerCase() : tag || 'other').slice(0, 24);
+  }
+  function lrScroll() {
+    var se = document.scrollingElement || document.documentElement;
+    var sy = Math.round(window.scrollY || window.pageYOffset || 0);
+    var smax = se ? Math.max(0, Math.round((se.scrollHeight || 0) - (window.innerHeight || se.clientHeight || 0))) : 0;
+    return { sy: sy, smax: smax, sw: se ? Math.round(se.scrollWidth || 0) : 0 };
+  }
+  // One hidden element, measured and removed: its height (h) or a computed padding in px. Null where it cannot be read.
+  function lrProbe(css, prop) {
+    var b = document.body;
+    if (!b || !document.createElement) return null;
+    var el = document.createElement('div'), v = null;
+    el.setAttribute('aria-hidden', 'true');
+    el.style.cssText = 'position:fixed;left:0;top:0;width:1px;visibility:hidden;pointer-events:none;' + css;
+    b.appendChild(el);
+    try { v = prop === 'h' ? el.offsetHeight : parseFloat(getComputedStyle(el)[prop]); } catch (_e) { v = null; }
+    b.removeChild(el);
+    return typeof v === 'number' && isFinite(v) ? v : null;
+  }
+  function lrMatch(q) { try { return !!window.matchMedia(q).matches; } catch (_e) { return false; } }
+  function lrDevice() {
+    if (LR.device) return;
+    LR.device = true;
+    var sc = window.screen || {};
+    layoutCrumb('device', { sw: sc.width, sh: sc.height, sah: sc.availHeight, oh: window.outerHeight, ow: window.outerWidth, dpr: window.devicePixelRatio,
+      sat: lrProbe('padding-top:env(safe-area-inset-top)', 'paddingTop'), sab: lrProbe('padding-bottom:env(safe-area-inset-bottom)', 'paddingBottom'),
+      anyCoarse: lrMatch('(any-pointer: coarse)'), shortTouch: lrMatch(SHORT_TOUCH_MQ), phone: isPhone() });
+  }
+  // The focus line is for touch screens only (QA W3): on a Mac it would only spend the budget.
+  function lrFocus() {
+    if (!vpTyping()) return;
+    var a = document.activeElement, fs = null;
+    LR.field = a;
+    if (!lrMatch('(pointer: coarse)')) return;
+    try { fs = parseFloat(getComputedStyle(a).fontSize); } catch (_e) { fs = null; }
+    var s = lrScroll();
+    layoutCrumb('focus', { pane: lrPane(), field: lrKind(a), fs: fs, sy: s.sy, smax: s.smax, scw: s.sw, kb: LR.up, n: ++LR.focusN });
+  }
+  function lrHooks(what, v) { LR.hooks.forEach(function (fn) { try { fn(what, v); } catch (err) { console.error(err); } }); }
+  function lrGap(v) {
+    var f = LR.field, box = f && f.closest ? (f.closest('form') || f) : f;
+    if (!box || box.isConnected === false || !box.getBoundingClientRect) return null;
+    return Math.round(v.top + v.height - box.getBoundingClientRect().bottom);
+  }
+  function lrAfter() {
+    LR.after = 0;
+    if (LR.up) return;
+    var v = viewportFit(), s = lrScroll(), gap = lrGap(v);
+    lrHooks('after', v);
+    var s2 = lrScroll();
+    layoutCrumb('kb-after', { pane: lrPane(), n: LR.cycle, gap: gap, sy: s.sy, smax: s.smax, over: s.sy > s.smax, gapNow: lrGap(viewportFit()), syNow: s2.sy,
+      dvh: lrProbe('height:100dvh', 'h'), svh: lrProbe('height:100svh', 'h'), lvh: lrProbe('height:100lvh', 'h'), lh: v.layoutH });
+  }
+  // 7.0.17: when the page's zoom crosses 1.01 either way, one breadcrumb (inside layoutCrumb's caps): the scale, the
+  // pane, the focused element's tag (never its text or value) and how long since the last touch. A double-tap zoom
+  // reads as a few hundred ms after a touch with no field focused; a focus zoom as an INPUT or TEXTAREA. Read only:
+  // nothing here changes the zoom.
+  function zoomCrumb(v) {
+    var zoomed = !!(v && v.zoomed);
+    if (zoomed === LR.zoomed) return false;
+    LR.zoomed = zoomed;
+    var a = document.activeElement, tag = a && a !== document.body && a.tagName ? String(a.tagName).toLowerCase().slice(0, 24) : 'none';
+    return layoutCrumb(zoomed ? 'zoom-in' : 'zoom-out', { pane: lrPane(), scale: v.scale, tag: tag, sinceTouch: LR.touchAt ? Date.now() - LR.touchAt : -1 });
+  }
+  function lrApply() {
+    LR.frame = 0;
+    var v = viewportFit(), de = document.documentElement;
+    zoomCrumb(v);
+    // Written only when they change: a pinch or pan fires this every frame, and each write restyles the page.
+    var box = v.top + '|' + v.height + '|' + v.dock, moved = box !== LR.box;
+    if (moved && de && de.style && de.style.setProperty) {
+      LR.box = box;
+      de.style.setProperty('--vv-top', v.top + 'px'); de.style.setProperty('--vv-h', v.height + 'px'); de.style.setProperty('--vv-below', v.dock + 'px');
+    }
+    var up = !!(v.vv && v.inset >= KB_UP_PX && vpTyping());
+    if (de && de.classList) de.classList.toggle('kb-up', up);
+    if (up === LR.up) { if (up && moved) lrHooks('move', v); return v; }
+    LR.up = up; LR.cycle++;
+    layoutCrumb(up ? 'kb-open' : 'kb-close', { pane: lrPane(), n: LR.cycle, inset: v.inset, below: v.below, dock: v.dock, lh: v.layoutH, top: v.top, h: v.height,
+      zoomed: v.zoomed, shrank: Math.round(window.innerHeight || 0) < v.layoutH });
+    if (LR.after) { clearTimeout(LR.after); LR.after = 0; }
+    if (!up) LR.after = setTimeout(lrAfter, KB_AFTER_MS);
+    lrHooks(up ? 'open' : 'close', v);
+    return v;
+  }
+  function lrFit() {
+    if (LR.frame) return;
+    if (!window.requestAnimationFrame) { lrApply(); return; }
+    LR.frame = window.requestAnimationFrame(lrApply);
+  }
+  (function lrListen() {
+    var vv = window.visualViewport;
+    if (vv && vv.addEventListener) { vv.addEventListener('resize', lrFit); vv.addEventListener('scroll', lrFit); }
+    window.addEventListener('resize', lrFit); window.addEventListener('orientationchange', lrFit); window.addEventListener('pageshow', lrFit);
+    document.addEventListener('focusin', function () { lrFocus(); lrFit(); });
+    // 7.0.17: when the last touch landed, for the zoom breadcrumb only. Passive: it never blocks a gesture.
+    document.addEventListener('touchstart', function () { LR.touchAt = Date.now(); }, { capture: true, passive: true });
+    document.addEventListener('focusout', function () { setTimeout(lrFit, 0); });
+    shellHooks.push(function () { lrDevice(); lrFit(); });
+  })();
+  // 7.0.17 (Miles 2026-11-10, the Duo web app zooming in and out around the keyboard): on iOS only, the viewport is
+  // capped at maximum-scale=1, once, as the page loads. Other platforms keep the viewport exactly as it is. Never while
+  // the page is already zoomed (a reload mid-zoom), so the zoom is never changed under the person's fingers; nothing
+  // calls this again after load.
+  function viewportCap(meta, ua, vv) {
+    if (!meta || ua.os !== 'ios') return false;
+    if (vv && vv.scale > 1.01) return false;
+    var content = String(meta.getAttribute('content') || '');
+    if (/maximum-scale\s*=/.test(content)) return false;
+    meta.setAttribute('content', content + (content ? ', ' : '') + 'maximum-scale=1');
+    return true;
+  }
+  try { viewportCap(document.querySelector('meta[name="viewport"]'), uaClass(), window.visualViewport); } catch (_e) { /* the viewport stays as it is */ }
+  window.COSWeb.keyboardUp = function () { return LR.up; };
+  window.COSWeb.onKeyboard = function (fn) { if (typeof fn === 'function') LR.hooks.push(fn); };
+  // ── end layout reports
+
   // Every pane module is a plain script after this one; boot waits for all of them.
   function boot() {
     var params = new URLSearchParams(location.search);
@@ -5024,8 +7118,8 @@
       history.replaceState({}, document.title, location.pathname + location.hash);
       api('/api/web-session/login', { method: 'POST', body: { code: linkCode } }).then(showShell)
         .catch(function (err) {
-          showAuth(err && err.status ? err.message : UNREACHABLE_COPY);
-          var box = $('auth-code'); if (box) box.value = linkCode;
+          if (!(err && err.status)) { showAuth(UNREACHABLE_COPY); var box0 = $('auth-code'); if (box0) box0.value = linkCode; return; }
+          return linkFailed(err.message, function () { var box = $('auth-code'); if (box) box.value = linkCode; });
         });
       return;
     }
@@ -5033,10 +7127,65 @@
     if (handoff) {
       history.replaceState({}, document.title, location.pathname + location.hash);
       api('/api/web-session/login', { method: 'POST', body: { handoff: handoff } }).then(showShell)
-        .catch(function (err) { showAuth(err && err.status ? err.message : 'That sign-in link did not work. Get a new one from COS Control on your Mac or the COS Glasses app, or use a code or the token.'); });
+        .catch(function (err) {
+          if (!(err && err.status)) return showAuth('That sign-in link did not work. Get a new one from COS Control on your Mac or the COS Glasses app, or use a code or the token.');
+          return linkFailed(err.message);
+        });
       return;
     }
-    api('/api/web-session/status').then(function (st) { if (st && st.authenticated) showShell(st); else showAuth(); }).catch(function () { showAuth(UNREACHABLE_COPY); });
+    // The status read stays here in boot() itself (routes/web-phone-link.test.ts runs boot alone and pins it).
+    api('/api/web-session/status').then(function (st) { return bootAnswer(st); }, function (err) { return bootFail(err); });
+  }
+  // S1 item 7 (lead go, 20:11): a link or code the server refused may be old while this browser is still signed in (an
+  // old QR, a reopened tab). Ask status first: signed in opens the app and says the link was old; signed out shows the
+  // refusal as before, with nothing else changed. A status read that fails also shows the refusal.
+  var OLD_LINK_COPY = 'That sign-in link was old or already used. This browser is still signed in.';
+  function linkFailed(message, after) {
+    return api('/api/web-session/status').then(function (st) {
+      if (st && st.authenticated) { showShell(st); toast(OLD_LINK_COPY); return; }
+      showAuth(message); if (after) after();
+    }, function () { showAuth(message); if (after) after(); });
+  }
+  // The same read on every retry of the not-answering card.
+  function bootStatus() {
+    return api('/api/web-session/status').then(function (st) { return bootAnswer(st); }, function (err) { return bootFail(err); });
+  }
+  function bootAnswer(st) {
+    if (st && st.authenticated) return showShell(st);
+    // Q1 S2: a browser that was signed in before learns why it is not now (the 30 days, no use in its last 2 days, a sign-out).
+    showAuth(typeof signinKnown === 'function' && signinKnown() ? signinLapsedCopy() : undefined);
+  }
+  function bootFail(err) {
+    // F23: a Mac that did not answer is not a sign-in problem. Say so, offer Try again, keep the form out of the way.
+    if (err && err.status) showAuth(err.message); else { showAuth(); authOffline(true); }
+  }
+  // Q1 M2: the not-answering card checks again every 30 s while the page is in front, and stops while it is hidden.
+  var AUTH_RETRY = { timer: null, ms: 30000 };
+  function authRetrySchedule(on) {
+    if (AUTH_RETRY.timer) { clearTimeout(AUTH_RETRY.timer); AUTH_RETRY.timer = null; }
+    if (!on || document.hidden) return;
+    AUTH_RETRY.timer = setTimeout(function () { AUTH_RETRY.timer = null; if (!document.hidden) bootStatus(); }, AUTH_RETRY.ms);
+  }
+  document.addEventListener('visibilitychange', function () {
+    var box = $('auth-offline');
+    var showing = !!(box && !box.classList.contains('hidden'));
+    if (!showing) return;
+    if (document.hidden) authRetrySchedule(false); else bootStatus();
+  });
+  // The sign-in card's "Your Mac is not answering" state (boot only): the form hides until the Mac answers.
+  function authOffline(on) {
+    var box = $('auth-offline'), form = $('auth-form');
+    if (!box || !form) return;
+    box.classList.toggle('hidden', !on); form.classList.toggle('hidden', !!on);
+    var title = $('auth-title'), intro = $('auth-intro');
+    var offline = typeof connOffline === 'function' && connOffline();
+    if (title) title.textContent = on ? (offline ? 'This device is offline' : 'COS on your Mac is not answering') : 'Connect this browser';
+    if (intro) intro.classList.toggle('hidden', !!on);
+    var text = $('auth-offline-text');
+    if (text && on) text.textContent = offline ? 'Connect to the internet and Tailscale. This page checks again every 30 seconds.'
+      : 'Your Mac may be asleep, or this device may be offline or off Tailscale. This page checks again every 30 seconds.';
+    authRetrySchedule(!!on);
+    if (on) { var err = $('auth-error'); if (err) { setStatus(err, '', true); err.classList.add('hidden'); } }
   }
   if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', boot); else boot();
 })();