@gotcos/glasses-server 6.99.20 → 6.99.29

package/server/web-control/app.js

@@ -101,8 +101,10 @@
     var ctrl = limit && window.AbortController ? new AbortController() : null;
     var timer = ctrl ? setTimeout(function () { ctrl.abort(); }, limit) : null;
     return fetch(path, { method: method, headers: headers, credentials: 'same-origin', body: body, signal: ctrl ? ctrl.signal : undefined }).then(function (res) {
-      if (timer) clearTimeout(timer);
+      // Blob bodies keep their deadline after headers: a stalled download must release its queue slot.
+      if (timer && o.responseType !== 'blob') clearTimeout(timer);
       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; }
+      if (o.responseType === 'blob' && res.ok) return res.blob();
       return res.text().then(function (text) {
         var data = {};
         try { data = text ? JSON.parse(text) : {}; } catch (_e) { data = {}; }
@@ -118,6 +120,9 @@
         }
         return data;
       });
+    }).then(function (value) {
+      if (timer) clearTimeout(timer);
+      return value;
     }, function (err) {
       if (timer) clearTimeout(timer);
       if (err && err.name === 'AbortError' && ctrl && ctrl.signal.aborted) {
@@ -133,7 +138,7 @@
   var state = {
     pane: 'today', serverName: '', tailnetUrl: '',
     sessions: [], sessionsMode: 'words', workTasks: [], workOpenStages: { complete: false },
-    stream: null, memoriesLoaded: false, lastLoad: {}, livePoll: null
+    stream: null, lastLoad: {}, livePoll: null
   };
   // 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.
@@ -142,6 +147,53 @@
   // Pane modules (panes/*.js) register here: { load(args, ctx), leave(), up(args) }. A registered
   // pane owns its section; route() only shows it and hands it the hash arguments.
   var PANES = {};
+  // Heavy panes load when first opened, then the rest load quietly once the page is idle.
+  // index.html lists them in #lazy-panes so the server can version each URL (?v=<hash>).
+  // Read on first use, not at parse time: #lazy-panes sits after this script in index.html.
+  var lazyList = null;
+  function LAZY() {
+    if (lazyList) return lazyList;
+    var el = document.getElementById('lazy-panes');
+    if (!el) return {};
+    try { lazyList = JSON.parse(el.textContent || '{}'); } catch (_e) { lazyList = {}; }
+    return lazyList;
+  }
+  var lazyLoads = {};
+  // ensurePane(name, waitMs): the pane's script, loaded once. With waitMs, this caller stops waiting after that
+  // long (the load itself carries on, and a later call reuses it), so a stalled download can never hang a tap.
+  function ensurePane(name, waitMs) {
+    var load = loadPane(name);
+    if (!waitMs) return load;
+    return new Promise(function (resolve, reject) {
+      var timer = setTimeout(function () {
+        var late = new Error('The ' + (TITLES[name] || name) + ' section is taking too long to load. Check the connection to your Mac.');
+        late.code = 'pane_timeout'; reject(late);
+      }, waitMs);
+      load.then(function (v) { clearTimeout(timer); resolve(v); }, function (e) { clearTimeout(timer); reject(e); });
+    });
+  }
+  function loadPane(name) {
+    if (PANES[name] || !LAZY()[name]) return Promise.resolve(PANES[name] || null);
+    if (lazyLoads[name]) return lazyLoads[name];
+    lazyLoads[name] = new Promise(function (resolve, reject) {
+      var s = document.createElement('script');
+      s.src = LAZY()[name];
+      s.async = true;
+      s.onload = function () { if (PANES[name]) resolve(PANES[name]); else { delete lazyLoads[name]; reject(new Error('The ' + (TITLES[name] || name) + ' section did not start.')); } };
+      s.onerror = function () { delete lazyLoads[name]; s.remove(); reject(new Error('Could not load the ' + (TITLES[name] || name) + ' section. Check the connection to your Mac.')); };
+      document.body.appendChild(s);
+    });
+    return lazyLoads[name];
+  }
+  function prefetchPanes() {
+    var names = Object.keys(LAZY()).filter(function (n) { return !PANES[n]; });
+    var idle = window.requestIdleCallback || function (fn) { return setTimeout(fn, 200); };
+    (function next() {
+      var n = names.shift();
+      if (!n) return;
+      idle(function () { ensurePane(n).then(next, next); });
+    })();
+  }
   var routeHooks = [];
   var shellHooks = [];
   var crumbDetail = '';
@@ -157,9 +209,9 @@
     if (location.hash === hash) route(); else location.hash = hash;
   }
   function isPhone() { return !window.matchMedia('(min-width: 600px)').matches; }
-  function route() {
+  function route(forceChanged) {
     var r = parseRoute();
-    var changedPane = r.pane !== state.pane || !document.querySelector('#pane-' + r.pane + ':not(.hidden)');
+    var changedPane = forceChanged === true || r.pane !== state.pane || !document.querySelector('#pane-' + r.pane + ':not(.hidden)');
     if (state.pane !== r.pane && PANES[state.pane] && PANES[state.pane].leave) { try { PANES[state.pane].leave(); } catch (err) { console.error(err); } }
     state.pane = r.pane;
     crumbDetail = '';
@@ -168,10 +220,10 @@
     var railPane = r.pane === 'usage' ? 'sessions' : r.pane;
     document.querySelectorAll('.rail-btn,.rail-settings').forEach(function (b) { if (b.getAttribute('data-pane') === railPane) b.setAttribute('aria-current', 'page'); else b.removeAttribute('aria-current'); });
     if (state.stream && !(r.pane === 'sessions' && r.args.length === 2)) { state.stream.close(); state.stream = null; }
-    if (!(r.pane === 'sessions' && r.args.length === 2)) { clearInterval(state.turnPoll); if (state.reading) clearInterval(state.reading.heldTimer); state.reading = null; }
+    if (!(r.pane === 'sessions' && r.args.length === 2)) { readerImagesStop($('session-turns')); clearInterval(state.turnPoll); if (state.reading) clearInterval(state.reading.heldTimer); state.reading = null; }
     if (r.pane !== 'meetings' && state.livePoll) { clearInterval(state.livePoll); state.livePoll = null; }
 
-    var reading = r.args.length > 0;
+    var reading = r.args.length > 0 && !isTabRoute(r.args);
     var paneEl = $('pane-' + r.pane);
     if (paneEl) paneEl.classList.toggle('reading', reading);
     var split = paneEl && paneEl.querySelector('.split');
@@ -187,10 +239,31 @@
     $('topbar').classList.remove('tucked');
     onScroll();
 
+    if (!PANES[r.pane] && LAZY()[r.pane]) {
+      var lazyPane = r.pane, lazyEl = $('pane-' + lazyPane), wasEmpty = lazyEl && !lazyEl.getAttribute('data-lazy-ready');
+      if (wasEmpty && lazyEl && !lazyEl.querySelector('.lazy-wait')) lazyEl.insertAdjacentHTML('afterbegin', '<div class="lazy-wait">' + skeletonRows(4) + '</div>');
+      ensurePane(lazyPane, 15000).then(function () {
+        if (lazyEl) { lazyEl.setAttribute('data-lazy-ready', '1'); lazyEl.querySelectorAll('.lazy-wait').forEach(function (n) { n.remove(); }); }
+        // Pass changed=true, the value this pane got on its first open when it loaded at boot. Headless Chrome
+        // probes on 11/06 rendered Work, Meetings, Settings and Speakers with either value; this keeps the old contract.
+        if (state.pane === lazyPane) route(true);
+      }, function (err) {
+        if (!lazyEl) return;
+        lazyEl.querySelectorAll('.lazy-wait').forEach(function (n) { n.remove(); });
+        lazyEl.insertAdjacentHTML('afterbegin', '<div class="lazy-wait"><div class="list"><p class="empty"><strong>' + esc(err.message) + '</strong></p><button type="button" class="btn" data-lazy-retry="' + esc(lazyPane) + '">Try again</button></div></div>');
+        // Only the wait ran out: if the load still finishes, the card clears itself and the pane shows.
+        if (err && err.code === 'pane_timeout') loadPane(lazyPane).then(function () {
+          lazyEl.querySelectorAll('.lazy-wait').forEach(function (n) { n.remove(); });
+          lazyEl.setAttribute('data-lazy-ready', '1');
+          if (state.pane === lazyPane) route(true);
+        }, function () {});
+      });
+      runHooks(routeHooks, r);
+      return;
+    }
     if (PANES[r.pane]) { try { PANES[r.pane].load(r.args, { changed: changedPane }); } catch (err) { console.error(err); } }
     else if (r.pane === 'today') loadToday();
     else if (r.pane === 'sessions') { if (!reading || !state.sessions.length || changedPane) loadSessions(); if (reading) openSession(r.args[0], r.args[1]); }
-    else if (r.pane === 'memories') loadMemories();
     else if (r.pane === 'usage') loadUsage(false);
     state.lastLoad[r.pane] = Date.now();
     runHooks(routeHooks, r);
@@ -202,9 +275,12 @@
     var r = parseRoute();
     var up = PANES[r.pane] && PANES[r.pane].up ? PANES[r.pane].up(r.args) : null;
     if (up) go(r.pane, up);
-    else if (r.args.length) go(r.pane);
+    else if (r.args.length && !isTabRoute(r.args)) go(r.pane);
     else go('today');
   }
+  // '#/<pane>/t/<tab>' is the pane's list on one of its tabs, not a reader: the phone keeps the section switcher and Back
+  // leaves the pane. Memories keeps its tab in the address this way, so a reload or a new browser lands on the same tab.
+  function isTabRoute(args) { return args.length === 2 && args[0] === 't'; }
   // On the closed Duo every vertical pixel counts: the top bar slides away while you scroll
   // down and comes back the moment you scroll up.
   var lastY = 0;
@@ -221,6 +297,7 @@
 
   // ── auth ────────────────────────────────────────────────
   function showAuth(message) {
+    readerImagesStop($('session-turns')); readerImagesStop($('ta-last'));
     var alreadyOpen = !$('auth-gate').classList.contains('hidden');
     $('app-shell').classList.add('hidden');
     $('auth-gate').classList.remove('hidden');
@@ -238,18 +315,299 @@
     loadTailnetUrl();
     runHooks(shellHooks, info);
     route();
+    // 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;
+    if (held && held.cosTodayOverlay) {
+      ensurePane('todayActions', 4000).then(function (m) { if (m && m.restore) m.restore(held); },
+        function () { try { history.replaceState(null, ''); } catch (_e) {} });
+    }
+    setTimeout(prefetchPanes, 1500);
+  }
+  document.addEventListener('click', function (e) {
+    var b = e.target && e.target.closest && e.target.closest('[data-lazy-retry]');
+    if (!b) return;
+    var el = $('pane-' + b.getAttribute('data-lazy-retry'));
+    if (el) el.querySelectorAll('.lazy-wait').forEach(function (n) { n.remove(); });
+    route(true);
+  });
+
+  // ── one session list for every pane ────────────────────
+  // /api/agent-sessions walks every session folder and runs a 2-3 s lock probe on the Mac (measured
+  // 11/06 in the browser: 5.1 s on Sessions, 2.1 s on Work). Today, Sessions, Work and the section
+  // 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 };
+  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) {
+      SL.data = d; SL.at = Date.now(); SL.inflight = null;
+      noteWaiting(d);
+      return d;
+    }, function (err) { SL.inflight = null; throw err; });
+    return SL.inflight;
+  }
+  function sessionListCached() { return SL.data ? { data: SL.data, at: SL.at } : null; }
+  // 6.99.27 (Miles 11/07 09:29, "a big delay to see the questions"): a session that has just gone to waiting may have
+  // parked a question for this page. The question poll (panes/questions.js) reads at once rather than at its next turn.
+  function questionsNudge() {
+    var q = window.COSWeb && window.COSWeb.sessionQuestions;
+    if (q && typeof q.nudge === 'function') { try { q.nudge(); } catch (_e) {} }
+  }
+  function noteWaiting(d) {
+    var now = {}, fresh = false;
+    ((d && d.sessions) || []).forEach(function (s) {
+      if (!s || sxState(s) !== 'waiting') return;
+      var k = splitSessionId(s.provider, s.session_id || s.id), key = k.provider + '|' + String(k.id).toLowerCase();
+      now[key] = 1;
+      if (!SL.waiting || !SL.waiting[key]) fresh = true;
+    });
+    SL.waiting = now;
+    if (fresh) questionsNudge();
+  }
+
+  // ── 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
+  // quiet session is "patrol", none is "idle". Strips come from /api/web-pet, resized and cut for a phone.
+  var PET = { manifest: null, fetchedAt: 0, pose: null, timer: null, frame: 0, token: 0 };
+  // This browser's pet settings (Settings > Pet): which pet, and whether Today shows it. Per browser, like the theme.
+  var PET_KEY = 'cos-web-pet';
+  function petPrefs() {
+    var p = readStore(PET_KEY);
+    var pet = typeof p.pet === 'string' && /^(mac|(shipped|gallery):[a-z0-9][a-z0-9-]{0,80})$/.test(p.pet) ? p.pet : 'mac';
+    return { pet: pet, show: p.show !== false };
+  }
+  function setPetPrefs(next) {
+    var cur = petPrefs();
+    var merged = { pet: next.pet != null ? next.pet : cur.pet, show: next.show != null ? !!next.show : cur.show };
+    writeStore(PET_KEY, merged);
+    // Forget the old pet's manifest and loop; Today repaints with the new choice next time it shows.
+    PET.manifest = null; PET.fetchedAt = 0; PET.pose = null; PET.token++; petStop();
+    var box = $('today-pet');
+    if (box) { box.innerHTML = ''; box.classList.add('hidden'); }
+    if (state.pane === 'today' && state.sessions) renderPet(state.sessions);
+    return merged;
+  }
+  var PET_HEIGHT = 140;
+  // 6.99.27 (Miles 11/07 09:29, "there wasn't an option for the pet to interact with the questions"): the questions
+  // this page holds (panes/questions.js), the ones that can be answered here. One key per session, as Needs you keys
+  // them.
+  function petQuestions() {
+    var q = window.COSWeb && window.COSWeb.sessionQuestions;
+    var items = q && typeof q.itemsFor === 'function' ? q.itemsFor('') : [];
+    return (items || []).filter(function (it) { return it && it.sessionId; });
+  }
+  function petQKey(it) { var k = splitSessionId(it.provider, it.sessionId); return k.provider + '|' + k.id; }
+  function petPose(sessions, questions) {
+    var working = 0, waiting = 0, alive = 0, asked = {};
+    var qs = questions || [];
+    qs.forEach(function (it) { asked[petQKey(it).toLowerCase()] = 1; });
+    sessions.forEach(function (s) {
+      var st = sxState(s);
+      // Working is the Running card's own test (running_active), so the caption under the pet never
+      // disagrees with the Running count beside it (11/06: the pet said 3 while the card said 2).
+      if (s.running_active) working++;
+      // A session whose question the caption already leads with is not counted again as waiting on you.
+      else if (st === 'waiting' && !asked[petKey(s).toLowerCase()]) waiting++;
+      if (s.running || s.running_active) alive++;
+    });
+    var pose;
+    // COS Control's rule (PetSpritePose.resolve): attention outranks every count pose. A question waiting here is the
+    // web's attention: it needs you, and this page can answer it.
+    if (qs.length) pose = 'attention';
+    else if (waiting > 0 && working === 0) pose = 'waiting';
+    else if (working + waiting >= 4) pose = 'swarm';
+    else if (working + waiting === 3) pose = 'trio';
+    else if (working + waiting === 2) pose = 'duel';
+    else if (working + waiting === 1) pose = 'working';
+    else pose = alive > 0 ? 'patrol' : 'idle';
+    // QA 6.99.27 (User 6): a permission request is an approval, counted apart from the questions.
+    var approvals = qs.filter(function (it) { return it.kind === 'approval'; }).length;
+    return { pose: pose, working: working, waiting: waiting, questions: qs.length - approvals, approvals: approvals };
+  }
+  // COS Control's fallbacks (PetSpritePose.fallbackPoses) for a pet that has no strip for the pose.
+  var PET_FALLBACK = { attention: ['error', 'waiting', 'idle'], patrol: ['idle'], duel: ['swarm', 'working', 'idle'], trio: ['swarm', 'duel', 'working', 'idle'],
+    swarm: ['duel', 'trio', 'working', 'idle'], working: ['idle'], waiting: ['idle'] };
+  function petPoseIn(poses, want) {
+    if (poses[want]) return want;
+    var chain = PET_FALLBACK[want] || [];
+    for (var i = 0; i < chain.length; i++) if (poses[chain[i]]) return chain[i];
+    return poses.idle ? 'idle' : Object.keys(poses)[0];
+  }
+  // 6.99.26 (Miles 11/07, "Open what matters"): the sessions behind the pet's caption, by the same test petPose
+  // counts with, so a tap opens what the caption says. In play: waiting on you, then running. Done today rides along in
+  // the list, never in the count.
+  function petPlay(sessions) {
+    var waiting = [], running = [], done = [], today = new Date().toDateString();
+    (sessions || []).forEach(function (s) {
+      var st = sxState(s);
+      if (s.running_active) running.push(s);
+      else if (st === 'waiting') waiting.push(s);
+      else if ((st === 'recent' || st === 'stale') && !sxKeepWarm(s)) {
+        var d = toDate(s.last_activity_at || s.state_since);
+        if (d && d.toDateString() === today) done.push(s);
+      }
+    });
+    return { waiting: waiting, running: running, done: done };
+  }
+  function petKey(s) { var k = splitSessionId(s.provider, s.session_id || s.id); return k.provider + '|' + k.id; }
+  // One session in play opens its own sheet (waiting: the question card or reply box; else the Running peek); several
+  // open the short list; none does nothing.
+  function petTap(t) {
+    // A question waiting here comes first: one session's question opens its card in the overlay; questions from
+    // several sessions open the list, question rows first.
+    var qs = petQuestions(), qkeys = {};
+    qs.forEach(function (it) { qkeys[petQKey(it)] = 1; });
+    var qk = Object.keys(qkeys);
+    if (qk.length === 1) return openTodayAction(t, 'wait', qk[0]);
+    if (qk.length > 1) return openTodayAction(t, 'pet', '');
+    var p = petPlay(state.sessions || []), n = p.waiting.length + p.running.length;
+    if (!n) return;
+    if (n > 1) return openTodayAction(t, 'pet', '');
+    var s = p.waiting[0] || p.running[0];
+    openTodayAction(t, sxState(s) === 'waiting' ? 'wait' : 'run', petKey(s));
+  }
+  function petButtonState(box, c, label) {
+    var btn = box.querySelector('.pet-btn');
+    if (!btn) return;
+    var any = c.working + c.waiting + (c.questions || 0) + (c.approvals || 0) > 0;
+    btn.setAttribute('aria-label', any ? label + '. Open' : label);
+    btn.setAttribute('aria-disabled', any ? 'false' : 'true');
+  }
+  function petCaption(c) {
+    var parts = [];
+    // A question or an approval waiting here leads (6.99.27): "1 question for you", "1 approval for you", or
+    // "1 question and 1 approval for you" (QA 6.99.27, User 6: approvals were counted as questions).
+    var asks = [];
+    if (c.questions) asks.push(c.questions === 1 ? '1 question' : c.questions + ' questions');
+    if (c.approvals) asks.push(c.approvals === 1 ? '1 approval' : c.approvals + ' approvals');
+    if (asks.length) parts.push(asks.join(' and ') + ' for you');
+    if (c.working) parts.push(c.working + ' running');
+    if (c.waiting) parts.push(c.waiting + ' waiting on you');
+    return parts.length ? parts.join(', ') : 'Nothing running';
+  }
+  function petStop() { clearTimeout(PET.timer); PET.timer = null; }
+  function petPaint(el, spec, frame, scale) {
+    var chunk = Math.floor(frame / spec.perChunk), inChunk = frame % spec.perChunk;
+    var count = Math.min(spec.perChunk, spec.frames - chunk * spec.perChunk);
+    el.style.backgroundImage = 'url("' + spec.chunks[chunk] + '")';
+    el.style.backgroundSize = Math.round(count * spec.frameWidth * scale) + 'px ' + PET_HEIGHT + 'px';
+    el.style.backgroundPosition = '-' + Math.round(inChunk * spec.frameWidth * scale) + 'px 0';
+  }
+  function petLoadImages(spec) {
+    return Promise.all(spec.chunks.map(function (url) {
+      return new Promise(function (resolve, reject) { var im = new Image(); im.onload = function () { resolve(im); }; im.onerror = reject; im.src = url; });
+    }));
+  }
+  // Folded (one column) the pet sits above the story. Unfolded (two columns, the same 760px line as
+  // .today-cols in app.css) it moves to the top of the right-hand column, above Needs you (Miles 11/06).
+  var PET_WIDE = window.matchMedia ? window.matchMedia('(min-width: 760px)') : null;
+  function placePet() {
+    var box = $('today-pet'), side = document.querySelector('#pane-today .today-side'), rec = $('today-rec');
+    if (!box || !side || !rec) return;
+    if (PET_WIDE && PET_WIDE.matches) { if (side.firstElementChild !== box) side.insertBefore(box, side.firstElementChild); }
+    else if (rec.previousElementSibling !== box) rec.parentNode.insertBefore(box, rec);
+  }
+  if (PET_WIDE) { if (PET_WIDE.addEventListener) PET_WIDE.addEventListener('change', placePet); else if (PET_WIDE.addListener) PET_WIDE.addListener(placePet); }
+  var PET_CHANGE = '<button type="button" class="pet-change" data-goto="settings/pet">Change pet</button>';
+  // A still pet (a gallery pick, Cloud Puff, or a single image on the Mac): one picture for every state.
+  function renderPetStill(box, m, sessions) {
+    var c = petPose(sessions, petQuestions()), label = petCaption(c);
+    petStop(); PET.pose = 'still:' + m.still;
+    var img = box.querySelector('.pet-still');
+    if (!img || img.getAttribute('src') !== m.still) {
+      box.innerHTML = '<button type="button" class="pet-btn" data-today="pet"><img class="pet-still" alt="" src="' + esc(m.still) + '"><span class="pet-caption"></span></button>' + PET_CHANGE;
+      img = box.querySelector('.pet-still');
+      img.addEventListener('error', function () { box.classList.add('hidden'); });
+      img.addEventListener('load', function () { img.classList.toggle('pixel', img.naturalHeight > 0 && img.naturalHeight < 140); });
+    }
+    box.querySelector('.pet-caption').textContent = label;
+    petButtonState(box, c, label);
+    box.classList.remove('hidden');
+  }
+  function renderPet(sessions) {
+    var box = $('today-pet');
+    if (!box) return;
+    placePet();
+    var prefs = petPrefs();
+    if (!prefs.show) { box.classList.add('hidden'); box.innerHTML = ''; petStop(); PET.pose = null; return; }
+    // The session list could not be read: the pet would say "Nothing running" about sessions nobody saw. Hide it.
+    if (state.sessionsUnread) { box.classList.add('hidden'); petStop(); PET.pose = null; return; }
+    var fresh = PET.manifest && PET.manifest.pet === prefs.pet && Date.now() - PET.fetchedAt < 10 * 60000;
+    (fresh ? Promise.resolve(PET.manifest) : api('/api/web-pet?pet=' + encodeURIComponent(prefs.pet)).then(function (m) { PET.manifest = m; PET.fetchedAt = Date.now(); return m; }))
+      .catch(function () { return PET.manifest && PET.manifest.pet === prefs.pet ? PET.manifest : null; })
+      .then(function (m) {
+        // A slow answer for a pet that is no longer chosen (or a pet now switched off) paints nothing.
+        var now = petPrefs();
+        if (!now.show || now.pet !== prefs.pet) return;
+        if (!m || !m.available) { box.classList.add('hidden'); petStop(); return; }
+        if (m.kind === 'still') { renderPetStill(box, m, sessions); return; }
+        var c = petPose(sessions, petQuestions());
+        var pose = petPoseIn(m.poses, c.pose);
+        var spec = m.poses[pose];
+        var label = petCaption(c);
+        box.classList.remove('hidden');
+        var cap = box.querySelector('.pet-caption');
+        if (cap) cap.textContent = label;
+        petButtonState(box, c, label);
+        if (PET.pose === pose && PET.timer) return;
+        var token = ++PET.token;
+        petLoadImages(spec).then(function () {
+          if (token !== PET.token) return;
+          petStop();
+          PET.pose = pose; PET.frame = 0;
+          if (!box.querySelector('.pet-sprite')) {
+            box.innerHTML = '<button type="button" class="pet-btn" data-today="pet"><span class="pet-sprite" aria-hidden="true"></span><span class="pet-caption"></span></button>' + PET_CHANGE;
+          }
+          box.querySelector('.pet-caption').textContent = label;
+          petButtonState(box, c, label);
+          var el = box.querySelector('.pet-sprite'), scale = PET_HEIGHT / spec.height;
+          el.style.width = Math.round(spec.frameWidth * scale) + 'px';
+          petPaint(el, spec, 0, scale);
+          var still = window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+          if (still || spec.frames < 2) return;
+          var step = function () {
+            // Runs only while Today is on screen: leaving the pane or hiding the page stops the loop.
+            if (token !== PET.token || document.hidden || state.pane !== 'today') { PET.timer = null; return; }
+            PET.frame = (PET.frame + 1) % spec.frames;
+            petPaint(el, spec, PET.frame, scale);
+            PET.timer = setTimeout(step, Math.max(20, spec.interval * 1000));
+          };
+          PET.timer = setTimeout(step, Math.max(20, spec.interval * 1000));
+        }, function () {
+          if (token === PET.token && !box.querySelector('.pet-sprite')) box.classList.add('hidden');
+        });
+      });
   }
 
   // ── Today ───────────────────────────────────────────────
   function loadToday() {
     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') {
+      TODAY.extraAt = Date.now();
+      TODAY.voices = { state: 'pending', groups: [] }; TODAY.memories = { state: 'pending', n: 0 };
+      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) {
+        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(); });
+    }
     Promise.all([
-      api('/api/agent-sessions?limit=40&sort=updated').catch(function () { return null; }),
+      sessionList(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; })
     ]).then(function (res) {
+      if (gen !== TODAY.gen) return;
       var sessions = (res[0] && res[0].sessions) || [];
       state.sessions = sessions;
       var needs = (res[1] && res[1].items) || [];
@@ -259,18 +617,24 @@
       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];
+      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';
+      state.sessionsUnread = !res[0];   // the pet reads this (renderPet)
+      TODAY.workState = res[1] && res[1].available !== false ? 'answered' : 'failed';
+      TODAY.recording = false;
 
-      renderStory(needs.length, working.length, open.length, welcome.nextEvent, false, offline);
       renderRunning(working, open);
-      renderNeeds(needs);
+      if (!offline) renderPet(sessions);
+      paintNeeds();
       renderNext(welcome);
       loadTodayIntake();
-      setBadge('today', needs.length > 0);
       setBadge('sessions', working.length > 0);
       liveSession(recent).then(function (rec) {
+        if (gen !== TODAY.gen) return;
         renderRecording(rec);
         setBadge('meetings', !!rec);
-        if (rec) renderStory(needs.length, working.length, open.length, welcome.nextEvent, true, offline);
+        if (rec) { TODAY.recording = true; paintNeeds(); }
       });
     });
   }
@@ -295,37 +659,127 @@
       '<span class="rec-copy"><strong>Recording now</strong><span>' + esc(rec.source + (rec.startTime ? ', ' + span(rec.startTime) + ' so far' : '')) + '</span></span>' +
       '<span class="btn small">Live view</span></button>';
   }
-  function renderStory(needs, working, open, next, recording, offline) {
+  // ── 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 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 };
+  // 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;
+  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 = [];
+    (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;   // only what Today counts: waiting, working and open
+      var k = splitSessionId(s.provider, s.session_id || s.id);
+      sessions.push({ title: sessionTitle(s), provider: k.provider, state: kind,
+        minutes: briefMinutes(kind === 'open' ? (s.last_activity_at || s.state_since) : (s.state_since || s.last_activity_at)),
+        line: String(s.discussion_summary || '').slice(0, 400), waiting: kind === 'waiting' ? askedWhy(s) : '',
+        // Only so the server can read this session's sub-agents (names, tasks, status); it never reaches the model.
+        key: k.provider + '|' + k.id,
+        agents: s.subagent_activity ? { active: s.subagent_activity.active, completed: s.subagent_activity.completed, total: s.subagent_activity.total } : undefined });
+    });
+    var needs = m.rows.filter(function (r) { return r.kind !== 'session'; }).slice(0, 12).map(function (r) {
+      if (r.kind === 'work') return { title: r.item.sessionTitle || r.item.title || 'Handoff', why: needWhy(r.item) };
+      return { title: r.title, why: r.why || '' };
+    });
+    // Today folds all but waiting sessions under "can wait until tomorrow" in quiet hours; the summary says the same.
+    var later = m.later.filter(function (r) { return r.kind !== 'session'; }).length;
+    return { sessions: sessions.slice(0, 40), needs: needs, later: Math.min(later, needs.length), sessionsRead: TODAY.sessionsState === 'answered', needsComplete: !!m.settled,
+      unread: m.failed.slice(), recording: !!TODAY.recording };
+  }
+  // Asked once every source answered or failed: at once when what Today read changed, else at most every five minutes
+  // (the server gates the spend; this only saves requests). When the switch is off, every five minutes.
+  function requestBrief(m) {
+    if (BRIEF.inflight || state.pane !== 'today') return;   // renderStory already answered an offline Today
+    if (Object.keys(m.states).some(function (k) { return m.states[k] === 'pending'; })) return;
+    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;
+    BRIEF.inflight = true; BRIEF.sentKey = key; BRIEF.sentAt = Date.now();
+    api('/api/today/brief', { method: 'POST', body: body, timeoutMs: 45000 }).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. */
+  function briefShown() {
+    var v = BRIEF.view;
+    if (!v || !v.text || (v.state !== 'fresh' && v.state !== 'stale') || TODAY.sessionsState !== 'answered') 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; }
+  // 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 () {
+    if (document.hidden || state.pane !== 'today' || !TODAY.model || TODAY.offline) return;
+    requestBrief(TODAY.model);
+    var v = briefShown(), when = document.querySelector('#today-story .story-when');
+    if (v && when) when.textContent = briefWhen(v, TODAY.model);
+  }, BRIEF_TICK_MS);
+  function briefWhen(v, m) {
+    var mins = briefMinutes(v.at);
+    var out = 'Updated ' + (mins < 1 ? 'just now' : span(v.at) + ' ago');
+    // Stale says so once it is five minutes old: a summary from a minute ago over one new reply is still the picture.
+    if (v.state === 'stale' && mins >= 5) out += '. Things have moved since';
+    if (m.failed.length) out += '. Couldn’t read ' + listWords(m.failed) + ', so this may not be everything';
+    return out + '.';
+  }
+
+  // The headline: COS Control's brief (Models.swift TodayHome.brief) over the same rows Needs you lists.
+  function renderStory(m) {
     var el = $('today-story');
     el.className = 'story';
-    if (offline) { el.textContent = 'COS on ' + state.serverName + ' is not answering right now. Today fills in when it does.'; return; }
-    // Quiet hours (Control 0.5.361, and the rail's line): after 6 PM and at weekends what is
-    // waiting can wait until tomorrow, so Today says so instead of "waiting on you".
-    var nowD = new Date(), quiet = nowD.getDay() === 0 || nowD.getDay() === 6 || nowD.getHours() >= 18;
-    var first = needs > 0
-      ? (quiet ? countWord(needs) + ' ' + plural(needs, 'handoff', 'handoffs') + ' can wait until tomorrow'
-        : countWord(needs) + ' ' + plural(needs, 'handoff is', 'handoffs are') + ' waiting on you')
-      : 'Nothing is waiting on you';
-    var nextBit = '';
-    var nd = next && toDate(next.time);
+    if (TODAY.offline) { el.textContent = '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.
+    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; }
+    }
+    var first = '';
+    if (m.sessionsWaiting > 0) first = countWord(m.sessionsWaiting) + ' ' + plural(m.sessionsWaiting, 'session is', 'sessions are') + ' waiting on you';
+    else if (m.now.length > 0) first = countWord(m.now.length) + ' ' + plural(m.now.length, 'thing needs', 'things need') + ' you' + (m.settled ? '' : ' so far');
+    else if (m.later.length > 0) first = countWord(m.later.length) + ' ' + plural(m.later.length, 'thing', 'things') + ' can wait until tomorrow' + (m.settled ? '' : ' so far');
+    else if (m.settled) first = 'Nothing is waiting on you';
+    var next = TODAY.welcome && TODAY.welcome.nextEvent, nd = next && toDate(next.time);
     if (nd && next.title && (nd.getTime() - Date.now()) < 18 * 3600000 && nd.getTime() > Date.now() - 600000) {
-      var dw = dayWord(nd);
-      nextBit = ', and ' + next.title + ' is at ' + clock(nd) + (dw === 'today' ? '' : ' ' + dw);
+      var dw = dayWord(nd), words = next.title + ' is at ' + clock(nd) + (dw === 'today' ? '' : ' ' + dw);
+      first = first ? first + ', and ' + words : words.charAt(0).toUpperCase() + words.slice(1);
     }
-    var second;
-    if (working > 0) second = countWord(working) + ' ' + plural(working, 'agent is', 'agents are') + ' working' + (open > 0 ? ', with ' + countWord(open, true) + ' more ' + plural(open, 'session', 'sessions') + ' open' : '');
+    var working = TODAY.working.length, open = TODAY.open.length, second;
+    var unread = TODAY.sessionsState === 'failed';
+    // The sessions sentence speaks only about a list that was read (W3-r2: "No agents are running" while two worked).
+    if (unread) second = 'Couldn\u2019t read your sessions';
+    else if (working > 0) second = countWord(working) + ' ' + plural(working, 'agent is', 'agents are') + ' working' + (open > 0 ? ', with ' + countWord(open, true) + ' more ' + plural(open, 'session', 'sessions') + ' open' : '');
     else if (open > 0) second = countWord(open) + ' ' + plural(open, 'session is', 'sessions are') + ' open and quiet';
     else second = 'No agents are running';
-    if (recording) second += (working > 0 || open > 0 ? ', and ' : '. ') + 'COS is recording a meeting';
-    el.textContent = first + nextBit + '. ' + second + '.';
-  }
+    if (TODAY.recording) second += (unread || working > 0 || open > 0 ? ', and ' : '. ') + 'COS is recording a meeting';
+    var out = (first ? first + '. ' : '') + second + '.';
+    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;
+  }
+  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);
     var meta = activeNow
       ? 'Working for ' + 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-[^-]+-/, '');
-    return '<button type="button" class="run-row" data-session="' + esc(key.provider) + '|' + esc(key.id) + '">' +
+    // 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>';
@@ -333,6 +787,8 @@
   function renderRunning(working, open) {
     $('run-count').textContent = working.length ? String(working.length) : '';
     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; }
     var shown = working.slice(0, 3);
     var html = shown.map(function (s) { return runRow(s, true); }).join('');
     if (!shown.length) {
@@ -350,21 +806,158 @@
     if (item.status === 'delivered') return 'Handed to you';
     return 'Needs a look';
   }
-  function renderNeeds(items) {
-    $('needs-count').textContent = items.length ? String(items.length) : '';
-    var list = $('needs-list');
-    if (!items.length) { list.innerHTML = '<p class="card-empty">You are clear. New handoffs from your agents land here.</p>'; return; }
-    // One primary action, on the item that has waited longest for a reply; the rest stay quiet.
-    list.innerHTML = items.slice(0, 6).map(function (it, i) {
-      var key = splitSessionId(it.provider, it.sessionId);
-      var title = it.sessionTitle || it.title || 'Handoff';
+  // ── Needs you (COS Control's TodayHome.things, sourceStates and fold; Models.swift 14291, 14512, 14474) ──
+  // Every source Control's Today reads that the web can: sessions waiting on you (the session list), Work handoffs
+  // (your-move), voices to name (/api/voice/held-groups) and memories to review (the memories bridge's status). One row
+  // per thing. The card's count, the headline and the rail say the same number, from the same rows. "Nothing is
+  // waiting on you" only once every source answered; a source that failed is named instead. Under quiet hours (after
+  // 6 PM, before 6 AM, weekends) everything but a waiting session folds under "can wait until tomorrow".
+  var NEEDS_SHOWN = 6;
+  var NEED_NAMES = { sessions: 'sessions', work: 'Work', voices: 'voices', memories: 'memories' };
+  function quietNowToday(d) { var h = d.getHours(), day = d.getDay(); return day === 0 || day === 6 || h >= 18 || h < 6; }
+  // 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.
+  function askedTitle(s) {
+    var t = plain(s.display_label || s.custom_title || '').replace(/\s+/g, ' ').trim() || 'A session';
+    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';
+    if (s.waiting_kind === 'mcp_input') return t + ' needs your input';
+    return t + ' asked you a question';
+  }
+  // Control never shows a bare tool name (TodayHome.toolNames): "AskUserQuestion" says nothing to a person.
+  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) {
+    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);
+    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.' : '');
+  }
+  // 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
+  // only the Mac can answer, in person or through Screens. 'answered': answered on some screen in the last two minutes,
+  // the list not caught up yet. '': a reply answers it (a Codex or Cursor session).
+  function sessionQs() { var q = window.COSWeb && window.COSWeb.sessionQuestions; return q && q.itemsFor ? q : null; }
+  function askedHere(items) {
+    var it = items[0];
+    if (!it) return '';
+    if (it.kind === 'approval') return it.approval && it.approval.summary ? 'Wants to run ' + clipWords(it.approval.summary, 80) : '';
+    var q = (it.questions || [])[0];
+    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) {
+    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) };
+    if (q && q.answeredFor && q.answeredFor(id)) return { where: 'answered', ask: '' };
+    var words = mac.length && q.wordsOf ? q.wordsOf(mac[0].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 };
+    return { where: '', ask: '' };
+  }
+  function needsModel() {
+    var states = { sessions: TODAY.sessionsState, work: TODAY.workState, voices: TODAY.voices.state, memories: TODAY.memories.state };
+    var rows = [], seen = {};
+    (state.sessions || []).forEach(function (s) {
+      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 });
+    });
+    // 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).
+    var qs = sessionQs();
+    (qs ? qs.itemsFor('') : []).forEach(function (it) {
+      var k = splitSessionId(it.provider, it.sessionId), sk = k.provider + '|' + String(k.id).toLowerCase();
+      if (!k.id || seen[sk]) return;
+      seen[sk] = 1;
+      var s = (state.sessions || []).filter(function (x) { var xk = splitSessionId(x.provider, x.session_id || x.id); return xk.provider === k.provider && String(xk.id).toLowerCase() === String(k.id).toLowerCase(); })[0];
+      var title = s ? askedTitle(s) : it.kind === 'approval' ? 'A session wants your permission' : 'A session asked you a question';
+      rows.push({ kind: 'session', tier: 1, title: title, why: 'Waiting for you. Paused until you answer.', since: it.createdAt, key: k.provider + '|' + k.id, where: 'here', ask: askedHere([it]) });
+    });
+    (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
+      rows.push({ kind: 'work', tier: 3, item: it, key: k.id ? k.provider + '|' + k.id : '' });
+    });
+    var groups = TODAY.voices.groups || [];
+    if (groups.length) {
+      var named = groups.filter(function (g) { return g && g.suggestion && g.suggestion.name; })[0];
+      rows.push({ kind: 'voices', tier: 2, title: groups.length === 1 ? 'Name a held voice' : 'Name ' + groups.length + ' held voices',
+        why: named ? 'One sounds like ' + named.suggestion.name + '.' : 'Held from your recordings until they have a name.' });
+    }
+    if (TODAY.memories.n > 0) {
+      var n = TODAY.memories.n;
+      rows.push({ kind: 'memories', tier: 4, title: n === 1 ? 'Review a memory' : 'Review ' + n + ' memories', why: 'Learned from your meetings and sessions, waiting for a yes or no.' });
+    }
+    var quiet = quietNowToday(new Date());
+    var nowRows = rows.filter(function (r) { return !quiet || r.tier === 1; }), later = rows.filter(function (r) { return quiet && r.tier !== 1; });
+    var failed = Object.keys(states).filter(function (k) { return states[k] === 'failed'; }).map(function (k) { return NEED_NAMES[k]; });
+    var settled = Object.keys(states).every(function (k) { return states[k] === 'answered'; });
+    return { rows: rows, now: nowRows, later: later, failed: failed, settled: settled, states: states,
+      sessionsWaiting: rows.filter(function (r) { return r.kind === 'session'; }).length };
+  }
+  function paintNeeds() {
+    if (!TODAY.at) return;
+    var m = TODAY.model = needsModel();
+    renderStory(m);
+    renderNeeds(m);
+    setBadge('today', m.now.length > 0);
+    if (window.COSWeb && window.COSWeb.setStory) window.COSWeb.setStory('today', todayRailLine(m), m.now.length > 0);
+  }
+  // The rail's Today line, from the same rows (shell.js keeps its own count off Today).
+  function todayRailLine(m) {
+    var n = m.now.length, bits = [];
+    if (n > 0) bits.push(n === 1 ? '1 needs you' : n + ' need you');
+    else if (m.later.length) bits.push(m.later.length + ' can wait until tomorrow');
+    else if (m.settled) bits.push('Nothing needs you');
+    else if (m.failed.length) bits.push('Couldn’t read ' + listWords(m.failed));
+    else bits.push('Reading');
+    if (TODAY.working.length) bits.push(TODAY.working.length + ' running');
+    return bits.join(', ');
+  }
+  function needRowHtml(r, i) {
+    var age = r.since ? ago(r.since) : r.item ? ago(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);
       var why = needWhy(it) + (it.domain ? ' in ' + domainLabel(it.domain) : '');
+      // The row opens it in an overlay on Today (panes/today-actions.js); Open session still goes to the reader.
       return '<div class="need-row">' +
-        '<div class="need-top"><span class="need-title">' + esc(title) + '</span><span class="need-age">' + esc(ago(it.updatedAt || it.createdAt)) + '</span></div>' +
-        '<div class="need-foot">' + esc(why) + '</div>' +
-        (key.id ? '<div class="need-actions"><button type="button" class="btn small' + (i === 0 ? ' primary' : '') + '" data-session="' + esc(key.provider) + '|' + esc(key.id) + '">Open session</button></div>' : '') +
-      '</div>';
-    }).join('');
+        '<button type="button" class="need-open" data-today="need" data-key="' + esc(it.id) + '"' + (k.id ? ' data-session-key="' + esc(k.provider) + '|' + esc(k.id) + '"' : '') + '>' +
+        top(it.sessionTitle || it.title || 'Handoff') + '<span class="need-foot">' + esc(why) + '</span></button>' +
+        (k.id ? '<div class="need-actions"><button type="button" class="btn small' + (i === 0 ? ' primary' : '') + '" data-session="' + esc(k.provider) + '|' + esc(k.id) + '">Open session</button></div>' : '') + '</div>';
+    }
+    if (r.kind === 'session') {
+      // 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>' +
+        (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>';
+    }
+    var go2 = r.kind === 'voices' ? 'speakers' : 'memories/view/review', label = r.kind === 'voices' ? 'Name' : 'Review';
+    return '<div class="need-row">' +
+      '<button type="button" class="need-open" data-goto="' + go2 + '">' + top(r.title) + '<span class="need-foot">' + esc(r.why) + '</span></button>' +
+      '<div class="need-actions"><button type="button" class="btn small' + (i === 0 ? ' primary' : '') + '" data-goto="' + go2 + '">' + label + '</button></div></div>';
+  }
+  function renderNeeds(m) {
+    var shown = TODAY.showLater ? m.now.concat(m.later) : m.now;
+    $('needs-count').textContent = m.now.length ? String(m.now.length) : '';
+    var list = $('needs-list');
+    var visible = TODAY.showAllNeeds ? shown : shown.slice(0, NEEDS_SHOWN);
+    var html = visible.map(needRowHtml).join('');
+    if (shown.length > visible.length) html += '<button type="button" class="need-more" data-today-needs="all">Show ' + (shown.length - visible.length) + ' more</button>';
+    if (m.later.length && !TODAY.showLater) html += '<button type="button" class="need-more" data-today-needs="later">' + esc(m.later.length + (m.later.length === 1 ? ' thing can' : ' things can') + ' wait until tomorrow. Show') + '</button>';
+    if (!m.rows.length) html = '<p class="card-empty">' + esc(m.settled ? 'Nothing is waiting on you.' : m.failed.length ? '' : 'Reading sessions, Work, voices and memories.') + '</p>';
+    m.failed.forEach(function (name) { html += '<button type="button" class="need-more need-failed" data-today-needs="retry">' + esc('Couldn’t read ' + name + '. Try again') + '</button>'; });
+    list.innerHTML = html;
   }
   function renderNext(w) {
     var card = $('next-card');
@@ -374,30 +967,73 @@
     var dw = dayWord(d);
     $('next-body').innerHTML = '<span class="when">' + esc(clock(d)) + '</span><span><span class="what">' + esc(n.title) + '</span>' +
       '<span class="sub" style="display:block">' + esc((dw.charAt(0).toUpperCase() + dw.slice(1)) + (weather ? '. Now ' + weather : '')) + '</span></span>';
+    // 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;
+    $('next-actions').innerHTML = (prep ? '<button type="button" class="btn small primary" data-today-next="prep">Prep me</button>' : '') +
+      '<button type="button" class="link-btn" data-goto="meetings">Open meeting</button>';
     card.classList.remove('hidden');
   }
+  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.'); });
+  }
   // 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'); }
   function loadTodayIntake() {
-    var card = $('intake-card'); if (!card) return;
-    api('/api/work-intake').then(function (d) {
+    var card = $('intake-card'); if (!card) return Promise.resolve();
+    return api('/api/work-intake').then(function (d) {
       var today = localDay(new Date());
       var items = ((d && d.items) || []).filter(function (it) {
         if (['suggested', 'review', 'ask'].indexOf(it.status) < 0) return false;
         var day = String((it.meeting && (it.meeting.filename || it.meeting.date)) || '').match(/\d{4}-\d{2}-\d{2}/);
         return day && day[0] === today;
       });
-      if (!items.length) { card.classList.add('hidden'); return; }
-      var meetings = {};
-      items.forEach(function (it) { var t = (it.meeting && it.meeting.title) || 'A meeting'; meetings[t] = (meetings[t] || 0) + 1; });
-      $('intake-count').textContent = String(items.length);
-      $('intake-body').innerHTML = Object.keys(meetings).slice(0, 4).map(function (t) {
-        return '<div class="intake-row"><span class="intake-meeting">' + esc(t) + '</span><span class="intake-n">' + meetings[t] + '</span></div>';
-      }).join('') + '<p class="intake-foot">Moves to Work at midnight.</p>';
-      card.classList.remove('hidden');
+      TODAY.intake = items; TODAY.intakeCaps = (d && d.capabilities) || {};
+      // A decision made on Today hides its row at once; a read that no longer lists it ends the hiding.
+      Object.keys(TODAY.gone).forEach(function (id) { if (!items.some(function (it) { return it.id === id; })) delete TODAY.gone[id]; });
+      paintTodayIntake();
     }, function () { card.classList.add('hidden'); });
   }
+  // Today's overlay (panes/today-actions.js) reads what the cards show from here and repaints the intake card after a
+  // decision, so the counts move the moment Work takes it.
+  var TODAY = { needs: [], working: [], open: [], welcome: {}, offline: false, at: 0, intake: null, intakeCaps: {}, gone: {},
+    gen: 0, sessionsState: 'pending', workState: 'pending', voices: { state: 'pending', groups: [] }, memories: { state: 'pending', n: 0 }, extraAt: 0,
+    recording: false, model: null, showAllNeeds: false, showLater: false };
+  function todayIntakeOpen() { return (TODAY.intake || []).filter(function (it) { return !TODAY.gone[it.id]; }); }
+  function paintTodayIntake() {
+    var card = $('intake-card'); if (!card) return;
+    var items = todayIntakeOpen();
+    if (!items.length) { card.classList.add('hidden'); return; }
+    var meetings = {};
+    items.forEach(function (it) { var t = (it.meeting && it.meeting.title) || 'A meeting'; meetings[t] = (meetings[t] || 0) + 1; });
+    $('intake-count').textContent = String(items.length);
+    $('intake-body').innerHTML = Object.keys(meetings).slice(0, 4).map(function (t) {
+      return '<button type="button" class="intake-row" data-today="meeting" data-key="' + esc(t) + '"><span class="intake-meeting">' + esc(t) + '</span><span class="intake-n">' + meetings[t] + '</span></button>';
+    }).join('') + '<p class="intake-foot">Moves to Work at midnight.</p>';
+    card.classList.remove('hidden');
+  }
+  function openTodayAction(t, kindIn, keyIn) {
+    var kind = kindIn || t.getAttribute('data-today'), key = keyIn != null ? keyIn : t.getAttribute('data-key') || '';
+    ensurePane('todayActions', 4000).then(function (m) {
+      if (!m || !m.open) throw new Error('The Today overlay did not start.');
+      m.open(kind, key, t);
+    }).catch(function (err) {
+      // Without the overlay, the tap goes where it went before: the session reader, or Sort in Work. Web has no client
+      // log route, so the failure is said on screen and in the console first. An overlay that half opened leaves its
+      // history entry, which the fallback replaces, so Back from there still lands on Today.
+      var s = String(kind === 'run' || kind === 'wait' ? key : t.getAttribute('data-session-key') || '').split('|');
+      var session = (kind === 'run' || kind === 'wait' || kind === 'need') && !!s[1];
+      var dest = session ? ['sessions', s[0], s.slice(1).join('|')] : kind === 'pet' ? ['sessions'] : ['work'].concat(kind === 'need' ? [] : ['sort']);
+      console.error('[today] the overlay did not open (' + kind + '); opening ' + dest.join('/') + ' instead.', err);
+      toast(session ? 'Could not open that here. Opening the session.' : kind === 'pet' ? 'Could not open that here. Opening Sessions.' : 'Could not open that here. Opening it in Work.');
+      if (history.state && history.state.cosTodayOverlay) location.replace('#/' + dest.map(encodeURIComponent).join('/'));
+      else go(dest[0], dest.slice(1));
+    });
+  }
   function setBadge(name, on) { document.querySelectorAll('[data-badge="' + name + '"]').forEach(function (b) { b.classList.toggle('hidden', !on); }); }
 
   // ── Sessions ────────────────────────────────────────────
@@ -583,9 +1219,21 @@
     if (SX.view !== 'sessions') { renderUsageView(force === true); return Promise.resolve(); }
     loadSessionHooks();
     if (force !== true && SX.rows && Date.now() - SX.loadedAt < 15000) { renderSessionGroups(); return Promise.resolve(); }
-    SX.loading = true;
-    renderSessionGroups();
-    return api('/api/agent-sessions?limit=80&sort=updated').then(function (d) {
+    // Paint the shared copy at once (Today usually fetched it) and refresh in place behind it.
+    var cached = !SX.rows && sessionListCached();
+    if (cached && cached.data && Array.isArray(cached.data.sessions)) {
+      SX.rows = cached.data.sessions; SX.dropped = cached.data.dropped || null; SX.enabled = cached.data.enabled !== false;
+      SX.loadedAt = cached.at;
+      if (sxQueryActive()) SX.instant = sxInstant(SX.q);
+      var fresh = force !== true && Date.now() - cached.at < 15000;
+      SX.loading = !fresh;   // rows stay on screen; the header reads "Refreshing…" until the new list lands
+      renderSessionGroups();
+      if (fresh) return Promise.resolve();
+    } else {
+      SX.loading = true;
+      renderSessionGroups();
+    }
+    return sessionList(force === true ? 0 : 15000).then(function (d) {
       SX.rows = (d && d.sessions) || [];
       SX.dropped = (d && d.dropped) || null;
       SX.enabled = !(d && d.enabled === false);
@@ -926,7 +1574,11 @@
   function writeStore(key, v) { try { localStorage.setItem(key, JSON.stringify(v)); } catch (_e) {} }
   function saveHeld(r) {
     var all = readStore(HELD_KEY), k = r.provider + '|' + r.id;
-    var keep = r.held.filter(function (h) { return !h.cancelled; }).map(function (h) { return { text: h.text, key: h.key, since: h.since }; });
+    var keep = r.held.filter(function (h) { return !h.cancelled; }).map(function (h) {
+      var o = { text: h.text, key: h.key, since: h.since };
+      if (h.ids && h.ids.length) { o.ids = h.ids; if (h.files && h.files.length) o.files = h.files; }
+      return o;
+    });
     if (keep.length) all[k] = keep; else delete all[k];
     writeStore(HELD_KEY, all);
   }
@@ -961,6 +1613,7 @@
   function openSession(provider, id) {
     var reader = $('session-reader');
     if (!provider || !id) return;
+    readerImagesStop($('session-turns'));
     if (state.stream) { state.stream.close(); state.stream = null; }
     clearInterval(state.turnPoll);
     if (state.reading) { clearInterval(state.reading.heldTimer); clearInterval(state.reading.feedTimer); }
@@ -990,15 +1643,21 @@
         '<p class="sx-copy-note hidden" id="session-copy-note" role="status"></p>' +
         '<div class="sx-chat">' +
           '<div id="session-verdict"></div>' +
-          '<form class="composer" id="session-form" data-provider="' + esc(provider) + '" data-id="' + esc(id) + '">' +
+          '<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>' +
             '<textarea id="session-input" rows="1" placeholder="Continue this session…" enterkeyhint="send" aria-label="Continue this session"></textarea>' +
-            '<div class="composer-actions"><button type="button" class="btn small" data-action="fork-session" title="Copy this session and send the message to the copy">Fork</button>' +
-            '<button type="submit" class="btn primary small">Send</button></div>' +
+            '<div class="composer-actions"><span id="session-clip" class="att-clip"></span><button type="button" class="btn small" data-action="fork-session" title="Copy this session and send the message to the copy">Fork</button>' +
+            '<button type="submit" class="btn primary small" id="session-send">Send</button></div>' +
           '</form><div class="status-line" id="session-status"></div>' +
           '<p class="sx-caution hidden" id="session-caution"></p>' +
           '<div id="session-queue"></div>' +
         '</div>';
-      setLive({ working: !!d.running_active });
+      readerImagesMount($('session-turns'), r);
+      sxNoteList(r, d);
+      setLive({});
+      paintReaderFiles();
+      // 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 () {});
       renderHeld(state.reading);
       loadQueue(provider, id);
       sxProbeAttach(r);
@@ -1017,20 +1676,30 @@
   // ACTIVITY (ActivityWindow.swift SessionActivityFeed 6800-6890, SessionLiveFeed.swift): the state
   // word with its clock, the current prompt, the last eight tool lines, and the honest counters.
   // The reducer follows SessionLiveFeed.applying: a reseed (seq 1 after anything) starts over.
-  function newFeed() { return { transport: 'idle', agentState: null, stateSince: null, waitingKind: null, waitingDetail: null, failure: null, lastReply: null, prompt: '', tools: [], lastSeq: 0, lastEventAt: null, missed: 0, connected: false, fallback: null }; }
+  function newFeed() { return { transport: 'idle', transportSeenAt: null, agentState: null, stateSince: null, stateSeenAt: null, seenMemo: null, statusAt: null, waitingKind: null, waitingDetail: null, failure: null, lastReply: null, prompt: '', tools: [], lastSeq: 0, lastEventAt: null, missed: 0, connected: false, fallback: null }; }
   function applyFeed(r, e) {
     if (typeof e.seq !== 'number') return;
     var f = r.feed;
-    if (e.seq === 1 && f.lastSeq > 0) { var keep = f.connected; f = r.feed = newFeed(); f.connected = keep; }
+    if (e.seq === 1 && f.lastSeq > 0) { var keep = f.connected, seenMemo = f.seenMemo; f = r.feed = newFeed(); f.connected = keep; f.seenMemo = seenMemo; }
     else if (f.lastSeq > 0 && e.seq > f.lastSeq + 1) f.missed += e.seq - f.lastSeq - 1;
     f.lastSeq = e.seq;
     f.lastEventAt = typeof e.at === 'number' ? new Date(e.at) : new Date();
     f.connected = true;
     if (f.fallback === 'reconnecting') f.fallback = null;
     if (e.kind === 'status') {
-      if (e.state) f.transport = e.state;
+      f.statusAt = f.lastEventAt;
+      // When this page first saw each state (its own clock): the Stop's echo window is measured by it. The
+      // memo outlives a reseed, so a reconnect that repeats a state seen before a Stop is not news.
+      var memo = f.seenMemo || (f.seenMemo = {});
+      if (e.state) {
+        if (!memo.stream || memo.stream.key !== e.state) memo.stream = { key: e.state, seen: Date.now() };
+        f.transport = e.state; f.transportSeenAt = memo.stream.seen;
+      }
       if (e.agent_state) {
-        f.agentState = e.agent_state; f.stateSince = toDate(e.state_since);
+        var since = toDate(e.state_since), hookKey = e.agent_state + '|' + sxMs(since);
+        if (!memo.hook || memo.hook.key !== hookKey) memo.hook = { key: hookKey, seen: Date.now() };
+        f.stateSeenAt = memo.hook.seen;
+        f.agentState = e.agent_state; f.stateSince = since;
         f.waitingKind = e.waiting_kind || null; f.waitingDetail = e.waiting_detail || null; f.failure = e.failure || null;
         if (e.last_reply) f.lastReply = e.last_reply;
       }
@@ -1041,18 +1710,108 @@
       if (f.tools.length > 8) f.tools.splice(0, f.tools.length - 8);
     }
   }
-  var SX_VERBS = { read: 'Read', edit: 'Edited', write: 'Edited', bash: 'Ran', run: 'Ran', search: 'Searched', grep: 'Searched', glob: 'Searched', fetch: 'Fetched', web: 'Fetched', agent: 'Delegated', task: 'Delegated' };
+  // `other` is the stream's verb for every tool it has no verb for; its target names the tool ("Used SendMessage").
+  var SX_VERBS = { read: 'Read', edit: 'Edited', write: 'Edited', bash: 'Ran', run: 'Ran', search: 'Searched', grep: 'Searched', glob: 'Searched', fetch: 'Fetched', web: 'Fetched', agent: 'Delegated', task: 'Delegated', other: 'Used' };
   function sxToolLine(t) { var v = String(t.verb || 'tool'); var w = SX_VERBS[v] || v.charAt(0).toUpperCase() + v.slice(1); return t.target ? w + ' ' + t.target : w; }
-  // The word follows the page's own working flag, which a Stop or a finished turn settles before
-  // the stream's status catches up; otherwise the server's derived state, as Control reads it.
+  // ONE STATE FOR THE SESSION CARD (6.99.29). Miles, 11/07 11:01: Today's session overlay showed
+  // "Idle 40s" over "Working on: Yes install and proceed", beside "Working right now" and "The
+  // session is busy" while the session ran its turn. Each piece read its own source: the badge the
+  // hooks' derived state (which a turn delivered through the peer inbox does not move), the composer
+  // the server's write gate, the send note the park answer, and a delivered live turn was read as a
+  // finished one. Now every piece of the card (the badge word and clock, the prompt line's label,
+  // Stop, the composer's park note and the reader's state line) reads sxTruth, and each signal says
+  // what it saw and WHEN that became true; the freshest wins:
+  //   hook   the stream's derived agent_state, since its state_since
+  //   stream the stream's own state, when no derived state rides it, as of that status line
+  //   list   the session row or detail: running_active as of its last activity, else since state_since
+  //   gate   the server's write gate: native_thread_working on the attachability probe, a refused
+  //          turn or a parked send, or a turn delivered live into the open session, as of the answer;
+  //          a later free answer, or a COS child's turn that finished, clears it
+  //   stop   this page's Stop (and a finished COS child turn): idle as of then, and no working signal
+  //          that ARRIVED in the next SX_STOP_ECHO_MS counts (the stream's status trails a Stop). The
+  //          window is the page's own clock (`seen`, when this page observed each signal), never the
+  //          signal's server time, and a turn this page sends ends it (continueSession clears stoppedAt).
+  // Waiting, failed and ended, from the hook or the session row, are the session's own words and stay:
+  // a gate or stream that sees a busy file does not unseat a question (QA 6.99.29: the row and the
+  // hook carry the same state_since, so the row's Waiting must hold as the hook's does). Signals with
+  // the same time are ordered gate, stream, list, hook, stop: the hook's word wins a tie. Idle yields
+  // only to working seen more than SX_IDLE_GRACE_MS after it, the server's rule for the flush that
+  // trails a Stop (TRANSCRIPT_AFTER_IDLE_GRACE_MS).
+  var SX_IDLE_GRACE_MS = 5000, SX_STOP_ECHO_MS = 8000, SX_GATE_RECHECK_MS = 20000;
+  var SX_TIE_RANK = { gate: 0, stream: 1, list: 2, hook: 3, stop: 4 };
+  function sxMs(v) {
+    var t = v instanceof Date ? v.getTime() : typeof v === 'number' ? v : typeof v === 'string' && v ? Date.parse(v) : NaN;
+    return isFinite(t) ? t : null;
+  }
+  var SX_HOOK_WORD = { running: 'Working', waiting: 'Waiting', failed: 'Failed', ended: 'Done', idle: 'Idle' };
+  function sxSignals(r) {
+    var f = r.feed || {}, out = [];
+    // `seen`: when this page observed the signal (its own clock), for the Stop's echo window.
+    if (f.agentState && SX_HOOK_WORD[f.agentState]) out.push({ word: SX_HOOK_WORD[f.agentState], at: sxMs(f.stateSince) || sxMs(f.statusAt) || 0, src: 'hook', seen: sxMs(f.stateSeenAt) });
+    else if (f.statusAt) out.push({ word: f.transport === 'working' ? 'Working' : f.transport === 'done' ? 'Done' : 'Idle', at: sxMs(f.statusAt), src: 'stream', seen: sxMs(f.transportSeenAt) });
+    if (r.list && r.list.at != null) out.push({ word: r.list.word, at: r.list.at, src: 'list', seen: sxMs(r.list.seen) });
+    if (r.gate && r.gate.busy && r.gate.at != null) out.push({ word: 'Working', at: r.gate.at, src: 'gate', seen: r.gate.at });
+    var stop = sxMs(r.stoppedAt);
+    if (stop !== null) out.push({ word: 'Idle', at: stop, src: 'stop', seen: stop });
+    return out;
+  }
+  /** { word, at, src }: the one state the whole card shows. Null before any signal. */
+  function sxTruth(r) {
+    var stop = sxMs(r.stoppedAt);
+    var all = sxSignals(r).sort(function (a, b) { return a.at - b.at || SX_TIE_RANK[a.src] - SX_TIE_RANK[b.src]; });
+    var best = null;
+    all.forEach(function (c) {
+      if (!best) { best = c; return; }
+      if (c.word === 'Working') {
+        // The Stop's echo, judged by when this page saw the signal (a signal with no arrival time: by its own).
+        var seen = c.seen != null ? c.seen : c.at;
+        if (stop !== null && seen >= stop && seen - stop < SX_STOP_ECHO_MS) return;
+        if (stop !== null && seen < stop) return;
+        if ((best.src === 'hook' || best.src === 'list') && (c.src === 'gate' || c.src === 'stream') && /^(Waiting|Failed|Done)$/.test(best.word)) return;
+        if (best.word === 'Idle' && best.src !== 'stop' && c.src !== best.src && c.at <= best.at + SX_IDLE_GRACE_MS) return;
+      }
+      best = c;
+    });
+    return best;
+  }
+  /** Settle the page's working flag from the one state; true when it changed. */
+  function sxSettle(r) {
+    var t = sxTruth(r), working = !!(t && t.word === 'Working');
+    r.live = r.live || {};
+    var was = !!r.live.working;
+    r.live.working = working;
+    r.live.waiting = !!(t && t.word === 'Waiting');
+    if (!working) { r.live.step = null; r.live.prose = null; }
+    return was !== working;
+  }
+  /** What the server's write gate said, and when. A free answer clears an earlier busy one. */
+  function sxNoteGate(r, busy) { r.gate = { busy: !!busy, at: Date.now() }; }
+  /** The list or detail row's view, timed by its own evidence. */
+  function sxNoteList(r, row) {
+    if (!row) return;
+    var waiting = sxState(row) === 'waiting', working = !!row.running_active && !waiting;
+    var at = working ? (sxMs(row.last_activity_at) || sxMs(row.state_since)) : (sxMs(row.state_since) || sxMs(row.last_activity_at));
+    // A row with no time of its own is the oldest word: the live feed outranks it the moment it speaks.
+    var word = working ? 'Working' : waiting ? 'Waiting' : 'Idle', was = r.list;
+    // Arrival is the first time this page saw THIS word at THIS time: a re-read of the same row is not news.
+    r.list = { word: word, at: at != null ? at : 0, seen: was && was.word === word && was.at === (at != null ? at : 0) && was.seen != null ? was.seen : Date.now() };
+  }
+  /** A gate busy answer that decides the card is re-asked after a while, so it cannot stand forever. Every
+   *  attempt is stamped (gate.triedAt), and each failed one doubles the wait, up to 16 times (QA 6.99.29: a failing
+   *  probe was re-asked every second). `at` stays the time of the last ANSWER: a failure is no evidence of busy. */
+  function sxGateStale(r) {
+    var t = sxTruth(r);
+    if (!(t && t.src === 'gate' && r.gate) || r.probing) return false;
+    var last = Math.max(r.gate.at || 0, r.gate.triedAt || 0), fails = r.gate.failures || 0;
+    return Date.now() - last > SX_GATE_RECHECK_MS * Math.min(Math.pow(2, fails), 16);
+  }
   function sxFeedWord(r) {
-    var f = r.feed;
-    if (r.live && r.live.working) return 'Working';
-    var s = f.agentState || f.transport;
-    if (s === 'waiting') return 'Waiting';
-    if (s === 'failed') return 'Failed';
-    if (s === 'ended' || s === 'done') return 'Done';
-    return 'Idle';
+    var t = sxTruth(r);
+    return t ? t.word : 'Idle';
+  }
+  /** The prompt line: what the session works on, or what it was last asked. */
+  function sxPromptLine(r, text) {
+    return (sxFeedWord(r) === 'Working' ? 'Working on: ' : 'Last asked: ') + text;
   }
   function sxFeedDetail(f, word) {
     if (word === 'Waiting' && f.agentState === 'waiting') {
@@ -1067,8 +1826,9 @@
     if (word === 'Idle' && f.agentState === 'idle') { var reply = String(f.lastReply || '').trim(); return reply ? 'last reply: ' + reply : ''; }
     return '';
   }
-  function sxElapsed(f) {
-    var since = f.stateSince || f.lastEventAt;
+  function sxElapsed(f, r) {
+    var t = r ? sxTruth(r) : null;
+    var since = t && t.at ? new Date(t.at) : f.stateSince || f.lastEventAt;
     if (!since) return '';
     var s = Math.max(0, Math.floor((Date.now() - since.getTime()) / 1000));
     if (s < 60) return s + 's';
@@ -1100,7 +1860,7 @@
       var word = sxFeedWord(r), detail = sxFeedDetail(f, word);
       html += '<div class="sx-act-state"><span class="sx-dot ' + word.toLowerCase() + '" aria-hidden="true"></span><strong>' + word + '</strong>' +
         '<span class="sx-act-detail">' + esc(detail) + '</span>' +
-        '<span class="sx-act-clock" id="session-elapsed">' + esc(sxElapsed(f)) + '</span>' +
+        '<span class="sx-act-clock" id="session-elapsed">' + esc(sxElapsed(f, r)) + '</span>' +
         (live.working ? '<button type="button" class="cx-btn quiet sx-act-stop" data-action="stop-session">Stop</button>' : '') + '</div>' +
         '<p class="sx-act-prompt">' + esc(f.prompt) + '</p>' +
         '<div class="sx-act-tail">' + f.tools.map(function (t) { return '<div class="sx-act-tool">' + esc(sxToolLine(t)) + '</div>'; }).join('') +
@@ -1109,13 +1869,15 @@
       html += '<p class="sx-act-fallback">' + esc(f.fallback ? sxFallbackLine(f.fallback) : 'Connecting to the live feed…') + '</p>';
     }
     box.innerHTML = html;
-    // The clock ticks only while the session works or waits (Control 0.5.337).
+    // The clock ticks only while the session works or waits (Control 0.5.337). A Working that only the write gate
+    // says is re-asked even with no live feed (QA 6.99.29), so it cannot stand forever once the feed is lost.
     clearInterval(r.feedTimer); r.feedTimer = null;
-    var w = sxFeedWord(r);
-    if ((f.connected || f.lastSeq > 0) && (w === 'Working' || w === 'Waiting')) {
+    var t = sxTruth(r), w = t ? t.word : 'Idle';
+    if (((f.connected || f.lastSeq > 0) && (w === 'Working' || w === 'Waiting')) || (t && t.src === 'gate' && w === 'Working')) {
       r.feedTimer = setInterval(function () {
         if (state.reading !== r) { clearInterval(r.feedTimer); return; }
-        var el = $('session-elapsed'); if (el) el.textContent = sxElapsed(r.feed);
+        var el = $('session-elapsed'); if (el) el.textContent = sxElapsed(r.feed, r);
+        if (sxGateStale(r)) sxProbeAttach(r);
       }, 1000);
     }
   }
@@ -1138,7 +1900,7 @@
     var es;
     try { es = new EventSource(sessionPath(provider, id, '/stream?seed=turn')); } catch (_e) { if (r0) { r0.feed.fallback = 'unsupported'; paintActivity(r0); } return; }
     state.stream = es;
-    var wasWorking = false;
+    var wasWorking = false, wasWaiting = false;
     es.onerror = function () {
       var r = state.reading;
       if (!r || r.id !== id || state.stream !== es) return;
@@ -1153,15 +1915,17 @@
       if (!r || r.id !== id) return;
       applyFeed(r, e);
       if (e.kind === 'status') {
-        var working = e.state === 'working' || e.agent_state === 'running';
-        // The stream's status trails a Stop by a few seconds; do not let that echo reopen it.
-        if (working && r.stoppedAt && Date.now() - r.stoppedAt < 8000) working = false;
-        var waiting = e.state === 'waiting' || e.state === 'needs_input' || e.agent_state === 'waiting';
+        // 6.99.29: the one state (sxTruth), never this line's own reading of itself.
+        setLive({});
+        var working = !!(r.live && r.live.working);
+        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';
-        setLive({ working: working });
         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).
+        if (waiting && !working && !wasWaiting) questionsNudge();
+        wasWaiting = waiting && !working;
       } else if (e.kind === 'tool') {
         setLive({ step: [e.verb, e.target].filter(Boolean).join(' ') });
       } else if (e.kind === 'prose' && e.text) {
@@ -1173,16 +1937,20 @@
   }
   function setLive(patch) {
     var r = state.reading; if (!r) return;
-    r.live = Object.assign(r.live || {}, patch);
-    if (!r.live.working) { r.live.step = null; r.live.prose = null; }
+    // The working flag is never set here: it is the one state's (sxSettle).
+    var p = Object.assign({}, patch); delete p.working;
+    r.live = Object.assign(r.live || {}, p);
+    var moved = sxSettle(r);
     paintActivity(r);
+    if (moved) renderVerdict(r);
   }
   function refreshTurns(provider, id) {
+    var reading = state.reading;
     api(sessionPath(provider, id, '?turns=' + SX_TURNS)).then(function (d) {
       var r = state.reading;
-      if (!r || r.id !== id) return;
+      if (!r || r !== reading || r.id !== id || r.provider !== provider) return;
       var turns = Array.isArray(d && d.recent_turns) ? d.recent_turns : [];
-      var box = $('session-turns'); if (box) sxMergeTurns(box, r.turns || [], turns, d);
+      var box = $('session-turns'); if (box) { sxMergeTurns(box, r.turns || [], turns, d); readerImagesMount(box, r); }
       // The header keeps the subtitle it opened with: a rewrap above the turns would move them.
       r.detail = d; r.turns = turns; r.more = d.recent_turns_more === true;
       renderHeld(r);
@@ -1205,13 +1973,20 @@
       var box = $('session-queue'); if (!box || !r || r.id !== id) return;
       var rows = (q.status === 200 && q.body && q.body.turns) || [];
       var waiting = rows.filter(function (t) { return t.status === 'waiting' || t.status === 'queued' || t.status === 'pending'; });
+      // QA 6.99.29: a queued message the server refused (or let expire) stays in view with the server's reason,
+      // instead of vanishing from the line.
+      var notSent = rows.filter(function (t) { return t.status === 'refused' || t.status === 'expired'; });
       if (q.status === 200 && r.queued !== waiting.length) { r.queued = waiting.length; paintActivity(r); }
-      if (!waiting.length) { box.innerHTML = ''; return; }
-      box.innerHTML = '<div class="sx-queue"><p class="sx-queue-head">' + (waiting.length === 1 ? '1 follow-up queued. It sends when this session is available.' : waiting.length + ' follow-ups queued. They send in order when this session is available.') + '</p>' +
+      if (!waiting.length && !notSent.length) { box.innerHTML = ''; return; }
+      box.innerHTML = '<div class="sx-queue">' + (waiting.length ? '<p class="sx-queue-head">' + (waiting.length === 1 ? '1 follow-up queued. It sends when this session is available.' : waiting.length + ' follow-ups queued. They send in order when this session is available.') + '</p>' : '') +
         waiting.map(function (t) {
           var mine = t.owner !== 'codex' && parkedByMe(r, t.clientTurnId);
           return '<div class="sx-queue-row"><span class="sx-queue-state">' + esc(sxQueueLine(t)) + '</span><span class="sx-queue-text">' + esc(t.preview || t.prompt || 'Message') + '</span>' +
             (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') +
+            '<span class="sx-queue-reason">' + esc(t.reasonCopy || (t.status === 'expired' ? 'Not sent: the thread stayed busy too long.' : 'Not sent: the session refused it.')) + '</span></span></div>';
         }).join('') + '</div>';
     }).catch(function () {});
   }
@@ -1220,21 +1995,34 @@
   // probeChatAttachability): a busy thread parks a send, another app holding it idle asks first,
   // and anything else is the server's refusal, word for word.
   function sxProbeAttach(r) {
-    apiAnswer(sessionPath(r.provider, r.id, '/attachability')).then(function (a) {
-      if (state.reading !== r) return;
-      if (a.status === 404) { r.verdict = { attachable: false, reason: 'route_absent', reasonCopy: 'Update the COS server to continue a thread from here.', ownerCount: 0 }; renderVerdict(r); return; }
+    // Today's overlay probes its own session object (r.view): the same verdict, painted by its view.
+    r.probing = true;
+    // Every attempt is stamped; a failed one backs the next off (sxGateStale). A gate answer resets both.
+    if (r.gate) r.gate.triedAt = Date.now();
+    var failed = function () { if (r.gate) r.gate.failures = (r.gate.failures || 0) + 1; };
+    return apiAnswer(sessionPath(r.provider, r.id, '/attachability')).then(function (a) {
+      if (state.reading !== r && !r.view) return;
+      if (a.status === 404) { failed(); r.verdict = { attachable: false, reason: 'route_absent', reasonCopy: 'Update the COS server to continue a thread from here.', ownerCount: 0 }; viewOf(r).verdict(r); return; }
       var b = a.body || {};
-      if (a.status !== 200 || typeof b.attachable !== 'boolean') return;
+      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 };
-      renderVerdict(r);
-    }).catch(function () {});
+      // 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);
+    }).catch(failed).finally(function () { r.probing = false; });
   }
   var SX_PARK = {
     cursor: 'Working right now. A message you send goes into this Cursor chat when its turn ends.',
     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.'
   };
+  /** The composer's "Working right now" note: a busy gate verdict, and the one state agrees. */
+  function sxParkNoteShows(r) {
+    var v = r.verdict;
+    if (!v || v.attachable !== false || !/^(native_thread_working|native_target_busy)$/.test(v.reason)) return false;
+    return sxFeedWord(r) === 'Working' || v.reason === 'native_target_busy';
+  }
   function sxSupplement(reason) {
     if (reason === 'native_target_busy') return 'It frees itself within 30 minutes. Detaching is not available in Control yet.';
     if (reason === 'native_target_fenced') return 'Fences can be released from the Fences card in this panel.';
@@ -1260,7 +2048,8 @@
         (f.retry ? '<button type="button" class="cx-btn quiet" data-sx="retry">Retry</button>' : '') +
         (f.fork ? forkBtn : ''));
     } else if (v && v.attachable === false && /^(native_thread_working|native_target_busy)$/.test(v.reason)) {
-      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>';
+      // 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>';
     } else if (v && v.attachable === false && v.reasonCopy) {
       html = refusalBox(v.reasonCopy, sxSupplement(v.reason), /fork/i.test(v.reasonCopy) ? forkBtn : '');
     }
@@ -1273,14 +2062,23 @@
     }
   }
 
+  /** Repaint whichever card shows this session after its one state moved (the reader or a view). */
+  function sxRepaint(r) {
+    sxSettle(r);
+    if (r.view) { if (typeof r.view.stateChanged === 'function') r.view.stateChanged(r); else r.view.verdict(r); return; }
+    if (state.reading === r) { paintActivity(r); renderVerdict(r); }
+  }
   function sessionStatus(text, kind, actionHtml) {
     var el = $('session-status'); if (!el) return;
     el.className = 'status-line' + (kind === 'error' ? ' error' : '');
     el.innerHTML = esc(text || '') + (actionHtml || '');
   }
-  function draftFor(text) {
-    var r = state.reading;
-    if (!r.draft || r.draft.text !== text) r.draft = { text: text, key: newTurnKey() };
+  // 11/07: the files sent with the words (media ids) are part of the draft: other files are another message, with a
+  // key of its own, so the server never answers a new message with an old one's replay.
+  function draftFor(text, r, ids) {
+    r = r || state.reading;
+    var files = Array.isArray(ids) ? ids.slice() : [];
+    if (!r.draft || r.draft.text !== text || (r.draft.ids || []).join(',') !== files.join(',')) r.draft = { text: text, key: newTurnKey(), ids: files };
     return r.draft;
   }
   // The box is cleared only of the very words that were sent; anything typed since stays.
@@ -1289,11 +2087,12 @@
     if (input && input.value.trim() === String(text).trim()) { 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.
-  function returnToBox(text, why) {
+  // Words go back in the box only if the box is empty; otherwise the status line keeps them. `files` says what became
+  // of the message's files (heldFilesBack).
+  function returnToBox(text, why, files) {
     var input = $('session-input');
-    if (input && !input.value.trim()) { input.value = text; autoGrow(input); sessionStatus(why + ' Your message is back in the box.', 'error'); }
-    else sessionStatus(why + ' Not sent: “' + String(text).slice(0, 80) + (text.length > 80 ? '…' : '') + '”', 'error');
+    if (input && !input.value.trim()) { input.value = text; autoGrow(input); sessionStatus(why + ' Your message is back in the box.' + (files || ''), 'error'); }
+    else sessionStatus(why + ' Not sent: “' + String(text).slice(0, 80) + (text.length > 80 ? '…' : '') + '”' + (files || ''), 'error');
   }
   // Your words show in the conversation the moment the Mac accepts them; the next refresh of
   // the transcript replaces the bubble with the real turn.
@@ -1312,11 +2111,111 @@
     r.held.forEach(function (h) { if (!h.cancelled && !heldBubble(h.key)) showPendingTurn(h.text, 'sends after this reply', h.key); });
   }
 
+  // Where the send path below reports: the reader's own page by default. Today's overlay (panes/today-actions.js)
+  // hands continueSession a session object with its own view, so a reply or a steer from Today runs this same attach,
+  // turn and queue path (one binding store, one key per draft, the same refusals). The overlay keeps its own copies of
+  // the gates around it (sendSessionTurn), the turn watch (watchTurn) and the refusal box (renderVerdict).
+  var READER_VIEW = {
+    status: function (r, text, kind, actionHtml) { sessionStatus(text, kind, actionHtml); },
+    pending: function (r, text, note) { showPendingTurn(text, note); },
+    clear: function (r, text) { clearBoxOf(text); },
+    verdict: function (r) { renderVerdict(r); },
+    hold: function (r, draft) { holdUntilReplyEnds(r, draft); },
+    watch: function (r, bindingId, key) { watchTurn(bindingId, key, r.provider, r.id); },
+    queue: function (r) { loadQueue(r.provider, r.id); }
+  };
+  function viewOf(r) { return (r && r.view) || READER_VIEW; }
+
+  // ── files with a message to a session (6.99.27, Miles: "We still don't have the ability to take picture, or add photo
+  // or files from the web") ──
+  // The COS chat's attach kit (panes/cos-chat.js, W.cosChat.attach), as on Today's reply box: Take photo and the clip,
+  // any file the Mac takes on a turn (threadTurnFileBytes, 64 MB; a video 100 MB), up to 5, sent as it is. The ids go
+  // with the words; the server writes where each file is on the Mac under them. One box per session, kept in this tab.
+  var READER_FILES = {};
+  function readerKit() { var c = window.COSWeb && window.COSWeb.cosChat; return c && c.attach ? c.attach : null; }
+  function readerFilesOn() { var k = readerKit(); return !!(k && k.turnFiles() > 0 && state.reading); }
+  function readerBox(r) {
+    var kit = readerKit(); if (!kit || !r) return null;
+    var key = r.provider + '|' + r.id;
+    if (!READER_FILES[key]) READER_FILES[key] = kit.box({
+      changed: function (box) { if (state.reading && READER_FILES[state.reading.provider + '|' + state.reading.id] === box) paintReaderFiles(); },
+      removed: function () { sessionStatus(''); },
+      signedOut: function () { sessionStatus('This browser was signed out. Your message and files are kept. Sign in, then tap Retry on each file.', 'error'); }
+    }, { anyBytes: kit.turnFileBytes() });
+    if (!READER_FILES[key].anyBytes && !READER_FILES[key].atts.length && kit.turnFileBytes()) READER_FILES[key].anyBytes = kit.turnFileBytes();
+    return READER_FILES[key];
+  }
+  function readerFilesState(box) {
+    var kit = readerKit();
+    if (!kit || !box || !box.atts.length) return 'none';
+    return kit.pending(box) ? 'waiting' : kit.failed(box) ? 'failed' : 'ready';
+  }
+  function paintReaderFiles() {
+    var kit = readerKit(), r = state.reading, slot = $('session-clip'), list = $('session-files');
+    if (!slot || !list) return;
+    if (!readerFilesOn()) { slot.innerHTML = ''; list.innerHTML = ''; list.classList.add('hidden'); return; }
+    var box = readerBox(r), full = box.atts.length >= kit.max, mode = String(box.anyBytes || 0);
+    if (slot.getAttribute('data-mode') !== mode) { slot.innerHTML = kit.cameraHtml('data-sx-file') + kit.clipHtml('data-sx-file', { any: box.anyBytes }); slot.setAttribute('data-mode', mode); }
+    Array.prototype.forEach.call(slot.querySelectorAll('.cc-attach'), function (l) { l.classList.toggle('full', full); });
+    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);
+    // 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;
+    var send = $('session-send'), forkBtn = form.querySelector('[data-action="fork-session"]');
+    if (send) { send.disabled = st === 'waiting'; send.textContent = st === 'waiting' ? 'Uploading' : 'Send'; }
+    if (forkBtn) forkBtn.disabled = st === 'waiting';
+  }
+  function addReaderFiles(list) {
+    var kit = readerKit(), r = state.reading; if (!kit || !r || !readerFilesOn() || !list || !list.length) return;
+    var refusals = kit.add(readerBox(r), list);
+    if (refusals.length) sessionStatus(refusals.join(' '), 'error');
+    paintReaderFiles();
+  }
+  // The files that went with a message leave the box; any added since stay. Taken, not removed: the status line stays
+  // (a held message's Don't send is on it). Answers what went, for a held message to keep.
+  function readerFilesSent(box, ids) {
+    var kit = readerKit(); if (!kit || !box || !ids || !ids.length) return [];
+    return kit.take(box, ids);
+  }
+  // QA 6.99.27: a held message keeps what its files were, so if it does not go, it comes back whole (heldFilesBack).
+  function keepHeldFiles(r, text, ids, went) {
+    if (!went || !went.length) return;
+    r.held.forEach(function (h) { if (!h.files && h.text === text && (h.ids || []).join(',') === ids.join(',')) h.files = went; });
+    saveHeld(r);
+  }
+  // The Mac keeps a file no turn took for 4 hours (lib/turn-file-store.ts, and the media store's own rule); this
+  // trusts a file for 5 minutes less. Past that it says the file has gone rather than offer one the send would refuse.
+  var HELD_FILE_KEEP_MS = 4 * 60 * 60000 - 5 * 60000;
+  function heldFilesBack(r, h) {
+    var ids = h.ids || []; if (!ids.length) return '';
+    var kit = readerKit(), box = readerFilesOn() ? readerBox(r) : null, now = Date.now();
+    var known = (h.files || []).filter(function (f) { return f && ids.indexOf(f.mediaId) >= 0; });
+    var kept = known.filter(function (f) { return f.keptAt > 0 && now - f.keptAt < HELD_FILE_KEEP_MS; });
+    var back = box && kept.length ? kit.restore(box, kept) : 0;
+    var lost = ids.length - back, expired = known.length - kept.length;
+    var said = !back ? '' : back === ids.length ? (back === 1 ? ' Its file is attached again.' : ' Its ' + back + ' files are attached again.')
+      : ' ' + back + ' of its files ' + (back === 1 ? 'is' : 'are') + ' attached again.';
+    if (!lost) return said;
+    var gone = lost === expired
+      ? (lost === 1 ? ' The file it carried was kept for 4 hours and has gone.' : ' The ' + lost + ' files it carried were kept for 4 hours and have gone.')
+      : (lost === 1 ? ' A file it carried did not come back.' : ' ' + lost + ' files it carried did not come back.');
+    return said + gone + ' Attach ' + (lost === 1 ? 'it' : 'them') + ' again.';
+  }
+
   function sendSessionTurn(fork, opts) {
     var r = state.reading; var form = $('session-form');
     if (!r || !form) return;
     var input = $('session-input'), text = input.value.trim();
     if (!text) { sessionStatus(fork ? 'Write what the copy should do first.' : 'Write a message first.', 'error'); return; }
+    // 6.99.27: files. Never before every upload has finished, never with one that failed. A fork carries them too: its
+    // first turn is this message, so the copy gets the same files (the fork route writes their paths as a turn does).
+    var fb = readerFilesOn() ? readerBox(r) : null, fst = readerFilesState(fb);
+    if (fst === 'waiting') { sessionStatus('A file is still uploading. ' + (fork ? 'Fork' : 'Send') + ' when it finishes.'); return; }
+    if (fst === 'failed') { sessionStatus('A file did not upload. Retry it or remove it.', 'error'); return; }
+    var fileIds = fst === 'ready' ? readerKit().ids(fb) : [];
+    if (fileIds.length && !fork) opts = Object.assign({}, opts || {}, { attachmentIds: fileIds });
     // Control's caution (SessionChatVerdict.caution): another app holds this session and looks
     // idle, so the first send asks before it writes. A fork writes to a copy and never asks.
     if (!fork && r.verdict && r.verdict.caution && !r.cautionAck) { r.cautionAsk = true; renderVerdict(r); return; }
@@ -1326,8 +2225,12 @@
     if (r.refusal || r.cautionAsk) { r.refusal = null; r.cautionAsk = false; renderVerdict(r); }
     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; }); };
-    (fork ? forkSession(r, text) : continueSession(r, text, opts || {})).then(done, function (err) {
+    var done = function () { r.sending = false; btns.forEach(function (b) { b.disabled = false; }); paintReaderFiles(); };
+    (fork ? forkSession(r, text, fileIds) : continueSession(r, text, opts || {}).then(function (how) {
+      // The Mac took the message (sent, waiting in line, or held until the reply ends): its files went with it.
+      if (/^(sent|parked|held)$/.test(how)) { var went = readerFilesSent(fb, fileIds); if (how === 'held') keepHeldFiles(r, text, fileIds, went); }
+      return how;
+    })).then(done, function (err) {
       done();
       if (state.reading !== r) return;
       var why = err && err.name === 'AbortError'
@@ -1345,8 +2248,10 @@
   // Resolves to 'sent' | 'parked' | 'held' | 'refused' | 'changed'.
   function continueSession(r, text, opts) {
     var provider = r.provider, id = r.id;
-    var draft = opts.held ? { text: opts.held.text, key: opts.held.key } : draftFor(text);
-    if (!opts.held) sessionStatus('Sending');
+    var draft = opts.held ? { text: opts.held.text, key: opts.held.key, ids: opts.held.ids || [] } : draftFor(text, r, opts.attachmentIds), view = viewOf(r);
+    // Files go only to a server that said it takes them (threadTurnAttachments); the caller shows no clip otherwise.
+    var files = draft.ids && draft.ids.length ? { attachmentIds: draft.ids } : {};
+    if (!opts.held) view.status(r, 'Sending');
     var bound = bindingFor(provider, id);
     var attach = bound ? Promise.resolve({ ok: true, binding: bound }) : apiAnswer(sessionPath(provider, id, '/attach'), { method: 'POST', body: { cosSessionId: cosSessionId() }, timeoutMs: 20000 }).then(function (a) {
       // 201 Created on success; any 2xx that says attached counts.
@@ -1368,22 +2273,27 @@
         if (opts.held) settleHeld(r, opts.held, 'refused', copy);
         else {
           // Control's refusal box: the server's words, then Fork with this message.
-          sessionStatus('');
+          view.status(r, '');
           r.refusal = { copy: (at.refusal && at.refusal.reasonCopy) || 'COS cannot write to this session right now.', supplement: sxSupplement(why), fork: true };
-          renderVerdict(r);
+          view.verdict(r);
         }
         return 'refused';
       }
+      // QA 6.99.29: a turn this page sends starts new work, so the last Stop (or finished COS turn) no longer
+      // mutes the working signals that follow (a held follow-up goes 800 ms after the end, inside the echo window).
+      r.stoppedAt = null;
       return apiAnswer('/api/agent-sessions/bindings/' + encodeURIComponent(at.binding.bindingId) + '/turns', {
         method: 'POST', timeoutMs: 25000,
-        body: Object.assign({ prompt: draft.text, epoch: at.binding.epoch, targetKey: targetKey(provider, id), clientTurnId: draft.key }, opts.acknowledgedRevision ? { acknowledgedRevision: opts.acknowledgedRevision } : {}),
+        body: Object.assign({ prompt: draft.text, epoch: at.binding.epoch, targetKey: targetKey(provider, id), clientTurnId: draft.key }, files, opts.acknowledgedRevision ? { acknowledgedRevision: opts.acknowledgedRevision } : {}),
       }).then(function (t) {
         var b = t.body || {};
         if (t.status >= 200 && t.status < 300 && (b.outcome === 'queued' || b.outcome === 'completed')) {
           if (opts.held) settleHeld(r, opts.held, 'sent');
-          else { showPendingTurn(draft.text, b.replayed ? 'already sent' : 'sent'); clearBoxOf(draft.text); }
-          sessionStatus(b.replayed ? 'Already sent. Watching for the reply.' : 'Sent. Watching for the reply.');
-          watchTurn(at.binding.bindingId, draft.key, provider, id);
+          else { view.pending(r, draft.text, b.replayed ? 'already sent' : 'sent'); view.clear(r, draft.text); }
+          view.status(r, b.replayed ? 'Already sent. Watching for the reply.' : 'Sent. Watching for the reply.');
+          view.watch(r, at.binding.bindingId, draft.key);
+          // 6.99.29: a turn that went live is in the open session, which now works on it.
+          if (b.outcome === 'completed' && b.via === 'live') { sxNoteGate(r, true); try { sxRepaint(r); } catch (_e) {} }
           return 'sent';
         }
         var reason = b.reason || '';
@@ -1391,15 +2301,15 @@
         // COS's own reply is still running on this thread. The server's queue counts that
         // thread as free (the running child is COS's), so it cannot park this; the page holds
         // it under the same key and sends it the moment the reply ends.
-        if (reason === 'native_turn_in_progress') { if (!opts.held) holdUntilReplyEnds(r, draft); return 'held'; }
+        if (reason === 'native_turn_in_progress') { if (!opts.held) view.hold(r, draft); return 'held'; }
         if (reason === 'native_thread_changed' && b.revision) {
           if (opts.held) settleHeld(r, opts.held, 'refused', 'This session changed on your Mac while your message waited.');
           else {
             // Control's refusal box for a changed thread: Refresh, Continue anyway, Fork with this message.
             r.sendAnyway = b.revision;
-            sessionStatus('');
+            view.status(r, '');
             r.refusal = { copy: b.reasonCopy || 'This session changed on your Mac since you opened it.', changed: true, fork: true };
-            renderVerdict(r);
+            view.verdict(r);
           }
           return 'changed';
         }
@@ -1409,7 +2319,7 @@
         }
         var refusedCopy = b.reasonCopy || 'The session did not take that message.';
         if (opts.held) settleHeld(r, opts.held, 'refused', refusedCopy);
-        else sessionStatus(refusedCopy + ' It is still in the box.', 'error');
+        else view.status(r, refusedCopy + ' It is still in the box.', 'error');
         return 'refused';
       });
     });
@@ -1418,7 +2328,7 @@
   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; })) {
-      r.held.push({ text: draft.text, key: draft.key, since: Date.now() });
+      r.held.push({ text: draft.text, key: draft.key, since: Date.now(), ids: draft.ids || [] });
       showPendingTurn(draft.text, 'sends after this reply', draft.key);
       saveHeld(r);
     }
@@ -1454,8 +2364,8 @@
       if (bubble) { bubble.removeAttribute('data-held-key'); bubble.querySelector('.who').textContent = 'You, waiting in line'; }
     } else {
       if (bubble) bubble.remove();
-      if (how === 'cancelled') returnToBox(h.text, 'Not sent.');
-      else returnToBox(h.text, copy || 'Not sent.');
+      // The whole message comes back: its words, and its files where the Mac still keeps them.
+      returnToBox(h.text, how === 'cancelled' ? 'Not sent.' : copy || 'Not sent.', heldFilesBack(r, h));
     }
     if (!r.held.some(function (x) { return !x.cancelled; })) clearInterval(r.heldTimer);
   }
@@ -1469,22 +2379,27 @@
   }
 
   function parkTurn(r, draft, refusal, opts) {
+    var view = viewOf(r);
     return apiAnswer(sessionPath(r.provider, r.id, '/queued-turns'), {
       method: 'POST', timeoutMs: 15000,
-      body: { cosSessionId: cosSessionId(), clientTurnId: draft.key, prompt: draft.text },
+      body: Object.assign({ cosSessionId: cosSessionId(), clientTurnId: draft.key, prompt: draft.text }, draft.ids && draft.ids.length ? { attachmentIds: draft.ids } : {}),
     }).then(function (q) {
       var b = q.body || {};
       if (b.queued === true || b.error === 'duplicate_turn') {
         rememberParked(r, draft.key);
         if (opts.held) settleHeld(r, opts.held, 'parked');
-        else { showPendingTurn(draft.text, 'waiting in line'); clearBoxOf(draft.text); }
-        sessionStatus(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.'));
-        loadQueue(r.provider, r.id);
+        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.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.
+        if (b.queued === true && refusal && refusal.reason === 'native_thread_working') { sxNoteGate(r, true); try { sxRepaint(r); } catch (_e) {} }
         return 'parked';
       }
       if (b.error === 'thread_free' && !opts.freeRetry) return continueSession(r, draft.text, Object.assign({}, opts, { freeRetry: true }));
-      var copy = (refusal && refusal.reasonCopy) || (b.error === 'queue_full' ? 'That session already has a full line of waiting messages.' : 'COS could not send or queue that.');
-      if (opts.held) settleHeld(r, opts.held, 'refused', copy); else sessionStatus(copy + ' It is still in the box.', 'error');
+      // 11/07: a file that could not be kept refuses the park with its own words, which say which step to take.
+      var copy = (b.attachmentError && b.reasonCopy) || (refusal && refusal.reasonCopy) || (b.error === 'queue_full' ? 'That session already has a full line of waiting messages.' : 'COS could not send or queue that.');
+      if (opts.held) settleHeld(r, opts.held, 'refused', copy); else view.status(r, copy + ' It is still in the box.', 'error');
       return 'refused';
     });
   }
@@ -1499,10 +2414,13 @@
       apiAnswer('/api/agent-sessions/bindings/' + encodeURIComponent(bindingId) + '/turns/' + encodeURIComponent(key)).then(function (s) {
         var o = s.body && s.body.outcome;
         if (o === 'completed') {
-          clearInterval(state.turnPoll); sessionStatus('Done.'); refreshTurns(provider, id);
-          // The finished turn is the authority; the stream's idle status can trail it.
-          setLive({ working: false }); var st = $('session-state'); if (st) st.textContent = 'Open';
-          replyEnded(r);
+          clearInterval(state.turnPoll); refreshTurns(provider, id);
+          // 6.99.29: a turn delivered LIVE is in the open session, which is now working on it; only a
+          // COS child's finished turn is the end of the work. Either way the one state settles it.
+          if (s.body.via === 'live') { sxNoteGate(r, true); sessionStatus('Sent into the open session.'); }
+          else { r.stoppedAt = Date.now(); sessionStatus('Done.'); }
+          setLive({}); var st = $('session-state'); if (st) st.textContent = r.live && r.live.working ? 'Working now' : 'Open';
+          if (s.body.via !== 'live') replyEnded(r);
         } else if (o === 'refused') { clearInterval(state.turnPoll); sessionStatus(s.body.reasonCopy || 'The session refused that message.', 'error'); replyEnded(r); }
         else if (o === 'ambiguous') { clearInterval(state.turnPoll); sessionStatus(s.body.reasonCopy || 'COS cannot tell whether that landed. Look at the session before sending it again.', 'error'); }
       }).catch(function () {});
@@ -1511,13 +2429,15 @@
 
   // Fork copies the session and runs the message there. One key per draft, so a second tap or
   // a resend after a timeout finds the same job instead of making a second copy.
-  function forkSession(r, text) {
-    if (!r.forkDraft || r.forkDraft.text !== text) r.forkDraft = { text: text, key: 'fk' + newTurnKey().slice(2) };
+  function forkSession(r, text, ids) {
+    ids = Array.isArray(ids) ? ids : [];
+    // Other files are another fork, with its own key.
+    if (!r.forkDraft || r.forkDraft.text !== text || (r.forkDraft.ids || []).join(',') !== ids.join(',')) r.forkDraft = { text: text, key: 'fk' + newTurnKey().slice(2), ids: ids.slice() };
     var forkId = r.forkDraft.key;
     sessionStatus('Copying the session. This can take up to a minute.');
     var settle = function (b) {
       if (b.forked === true) {
-        r.forkDraft = null; clearBoxOf(text);
+        r.forkDraft = null; clearBoxOf(text); readerFilesSent(readerFilesOn() ? readerBox(r) : null, ids);
         sessionStatus('Forked. The copy has your message and shows in Sessions in a moment.');
         setTimeout(function () { if (state.pane === 'sessions') loadSessions(true); }, 4000);
         return true;
@@ -1525,7 +2445,7 @@
       if (b.forked === false || b.state === 'failed' || b.state === 'refused') { sessionStatus((b.reasonCopy || 'COS could not copy that session.'), 'error'); return true; }
       return false;
     };
-    return apiAnswer(sessionPath(r.provider, r.id, '/fork'), { method: 'POST', timeoutMs: 65000, body: { prompt: text, cosSessionId: cosSessionId(), clientForkId: forkId } }).then(function (f) {
+    return apiAnswer(sessionPath(r.provider, r.id, '/fork'), { method: 'POST', timeoutMs: 65000, body: Object.assign({ prompt: text, cosSessionId: cosSessionId(), clientForkId: forkId }, ids.length ? { attachmentIds: ids } : {}) }).then(function (f) {
       if (settle(f.body || {})) return;
       if (f.status !== 202) { sessionStatus('COS could not copy that session.', 'error'); return; }
       // 202: running in the background. Follow its job for up to three minutes.
@@ -1550,7 +2470,7 @@
       if (b.cancelled) {
         r.stoppedAt = Date.now();
         clearInterval(state.turnPoll);
-        setLive({ working: false }); var st = $('session-state'); if (st) st.textContent = 'Open';
+        setLive({}); var st = $('session-state'); if (st) st.textContent = 'Open';
         setTimeout(function () { if (state.reading === r) refreshTurns(r.provider, r.id); }, 1500);
       }
     }).catch(function (err) { sessionStatus(err.message, 'error'); });
@@ -1564,6 +2484,36 @@
     });
   }
 
+  // Output previews are separate from composer attachments. Only the DTO fields reach the lazy viewer.
+  function readerImagesHtml(turn) {
+    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>' : '';
+  }
+  function readerImagesStop(host) {
+    if (!host) return;
+    host.__cosImageOwner = null;
+    if (window.COSWeb.readerMedia) window.COSWeb.readerMedia.unmount(host);
+  }
+  function readerImagesMount(host, r) {
+    if (!host || !r) return;
+    if (!host.querySelectorAll('[data-reader-images]').length) { readerImagesStop(host); return; }
+    var owner = host.__cosImageOwner = {};
+    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) {
+        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);
+      });
+    });
+  }
+
   // Copy session (Control's Kickstart brief, HelperSources/main.swift claudeKickstartCopy). Control
   // builds it from the Mac's transcript; the web builds it from the turns the server serves and
   // the session's first prompt, so it keeps the original request and the newest context.
@@ -1696,7 +2646,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);
+    return (String(t.role || '').toLowerCase() === 'user' ? 'u' : 'a') + '|' + (t.at || '') + '|' + text.length + '|' + text.slice(0, 48) + '|' + readerImagesHtml(t);
   }
   function sxTurnHtml(t) {
     var role = String(t.role || '').toLowerCase() === 'user' ? 'user' : 'assistant';
@@ -1705,7 +2655,7 @@
     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>') + '</div>';
+      (role === 'user' ? '<div class="sx-plain">' + esc(text) + '</div>' : '<div class="sx-md">' + sxMd(text) + '</div>' + readerImagesHtml(t)) + '</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
@@ -1749,21 +2699,42 @@
     var h = Array.prototype.map.call(b, function (x) { return (x + 0x100).toString(16).slice(1); }).join('');
     return h.slice(0, 8) + '-' + h.slice(8, 12) + '-' + h.slice(12, 16) + '-' + h.slice(16, 20) + '-' + h.slice(20);
   }
-  function askCos(prompt, statusEl) {
+  var TODAY_REFERENCE = 'What Today in COS Control shows right now';
+  // files: { attachmentIds, atts } from the Ask sheet's clip (askSheetFiles), or nothing.
+  function askCos(prompt, statusEl, files) {
     // 6.99.12: "it shows Sent but never shows up" (Miles, 11/04). With Ask COS in Messages, the sheet hands its words to
     // that composer (panes/cos-chat.js submitAsk), so the answer streams on screen and lands as a numbered turn. The
     // request below is the fallback for a page without it; it resolves to the Messages route to open.
     var chat = window.COSWeb && window.COSWeb.cosChat;
+    // Asked from Today: COS gets a short summary of what Today shows (panes/today-actions.js summary), as the Ask's
+    // quoted reference, the query-jobs field for context. Asked from any other pane, nothing extra is sent.
+    var context = state.pane === 'today' ? ensurePane('todayActions', 1500).then(function (m) {
+      // A broken summary never costs the Ask: it goes without it, and the console says why.
+      var ctx;
+      try { ctx = m && m.summary ? m.summary() : ''; } catch (err) { console.error('[today] the Today summary failed; asking without it.', err); return ''; }
+      // The model's summary of the sessions leads it when there is one, inside the same cap; past the cap it is left out.
+      var b = typeof briefShown === 'function' ? briefShown() : null;
+      var lead = b ? 'Summary of the sessions, written by a model ' + (briefMinutes(b.at) < 1 ? 'just now' : span(b.at) + ' ago') + (b.state === 'stale' ? ' (things have moved since)' : '') + ': ' + b.text : '';
+      return ctx && lead && lead.length + 1 + ctx.length <= ((m && m.summaryMax) || 4000) ? lead + '\n' + ctx : ctx;
+    }, function () { return ''; }) : Promise.resolve('');
     if (chat && chat.askFromSheet) {
       setStatus(statusEl, 'Sending…');
-      return chat.askFromSheet(prompt).then(function (where) { setStatus(statusEl, ''); return where; }, function (err) {
+      return context.then(function (ctx) {
+        var extra = files ? { attachmentIds: files.attachmentIds, atts: files.atts } : {};
+        if (ctx) extra.context = ctx;
+        return chat.askFromSheet(prompt, ctx || files ? extra : undefined);
+      }).then(function (where) { setStatus(statusEl, ''); return where; }, function (err) {
         setStatus(statusEl, err.message, true);
         throw err;
       });
     }
     setStatus(statusEl, 'Sent. COS is answering.');
     var body = { clientJobId: webJobId(), generation: 1, query: prompt, source: 'web', activityToolMode: 'status' };
-    return api('/api/query-jobs', { method: 'POST', body: body, timeoutMs: 30000 }).then(function () {
+    if (files && files.attachmentIds && files.attachmentIds.length) body.attachmentIds = files.attachmentIds;
+    return context.then(function (ctx) {
+      if (ctx) body.reference = { query: TODAY_REFERENCE, response: ctx };
+      return api('/api/query-jobs', { method: 'POST', body: body, timeoutMs: 30000 });
+    }).then(function () {
       // The answer lands in Messages; refresh it there if it is open.
       var again = function () { if (state.pane === 'messages' && PANES.messages && PANES.messages.refresh) PANES.messages.refresh(); };
       setTimeout(again, 4000);
@@ -1774,27 +2745,6 @@
       throw err;
     });
   }
-  // ── Memories (the native page, hosted) ──────────────────
-  function syncFrameTheme() {
-    var frame = $('memories-frame'); if (!frame) return;
-    var mode = window.CosTheme ? window.CosTheme.mode() : 'light';
-    frame.style.colorScheme = mode;
-    try {
-      var root = frame.contentDocument && frame.contentDocument.documentElement;
-      if (root) {
-        root.setAttribute('data-theme', mode);
-        if (isPhone()) root.setAttribute('data-host', 'web-phone'); else root.removeAttribute('data-host');
-      }
-    } catch (_e) {}
-  }
-  function loadMemories() {
-    var frame = $('memories-frame');
-    if (state.memoriesLoaded) { syncFrameTheme(); return; }
-    state.memoriesLoaded = true;
-    frame.addEventListener('load', syncFrameTheme);
-    frame.src = '/control/memories/memories.html';
-  }
-
   // ── Usage ───────────────────────────────────────────────
   // Usage and COS cost are views inside Sessions, as on the Mac (ActivityWindow.swift 2306-2325);
   // an old #/usage link opens the Usage view there. Data: GET /api/usage/summary, the helper's
@@ -3392,7 +4342,7 @@
         var left = exp ? Math.round((exp.getTime() - Date.now()) / 1000) : 0;
         var el = $('device-code-left');
         if (!el) { clearInterval(codeTimer); return; }
-        if (left <= 0) { clearInterval(codeTimer); panel.innerHTML = '<p>That code expired. Choose Sign in another device for a new one.</p>'; return; }
+        if (left <= 0) { clearInterval(codeTimer); panel.innerHTML = '<p>That code expired. Choose Use COS on another phone or browser for a new one.</p>'; return; }
         el.textContent = 'Works once, for ' + (left >= 60 ? Math.ceil(left / 60) + ' more min' : left + ' more sec') + '.';
       };
       tick(); codeTimer = setInterval(tick, 1000);
@@ -3413,11 +4363,136 @@
     ['today', 'Today'], ['messages', 'Messages'], ['speakers', 'Speakers'], ['meetings', 'Meetings'], ['memories', 'Memories'],
     ['threads', 'Threads'], ['sessions', 'Sessions'], ['work', 'Work'], ['dictation', 'Dictation'], ['usage', 'Usage'], ['settings', 'Settings']
   ];
+  // ⌘K's File to Work inbox (Control's todaySubmitAsk, ActivityWindow.swift 8810): the words become a task in the Work
+  // inbox, in Control's taskDomain (quilt when the server has it, else the first domain it lists: reconcileTaskDomain),
+  // through POST /api/tasks/capture,
+  // the route Work's Add task uses. One captureId per text: a second tap, or a retry after a lost answer, files it once.
+  var ASK_FILE = { text: '', id: '', busy: false, domains: null, note: null };
+  // The result shows on the row itself, so it is in view wherever the sheet is (W5-r2: a status line under the sheet
+  // at 1000x703 hid a refusal), and a toast says it too.
+  function fileNoteHtml(q) {
+    var n = ASK_FILE.note && ASK_FILE.note.text === q ? ASK_FILE.note : null;
+    if (n) return '<span class="note' + (n.error ? ' file-error' : '') + '" role="' + (n.error ? 'alert' : 'status') + '">' + esc(n.line) + '</span>';
+    return '<span class="note">' + esc('As a task in ' + fileDomainLabel()) + '</span>';
+  }
+  function fileDomainEntry() {
+    var d = ASK_FILE.domains || [];
+    return d.filter(function (x) { return x && x.name === 'quilt'; })[0] || d.filter(function (x) { return x && x.name; })[0] || null;
+  }
+  function fileDomain() { var e = fileDomainEntry(); return e ? e.name : 'quilt'; }
+  function fileDomainLabel() { var e = fileDomainEntry(); return (e && e.label) || domainLabel(fileDomain()); }
+  function loadFileDomains() {
+    if (ASK_FILE.domains) return Promise.resolve();
+    return api('/api/domains').then(function (d) { ASK_FILE.domains = (d && Array.isArray(d.domains)) ? d.domains : []; }, function () { ASK_FILE.domains = null; });
+  }
+  function fileToInbox(text) {
+    if (ASK_FILE.busy || !text) return;
+    if (ASK_FILE.text !== text) { ASK_FILE.text = text; ASK_FILE.id = webJobId(); }
+    ASK_FILE.busy = true; ASK_FILE.note = null; renderAskFile();
+    loadFileDomains().then(function () {
+      return api('/api/tasks/capture', { method: 'POST', body: { domain: fileDomain(), text: text, section: 'inbox', captureId: ASK_FILE.id }, timeoutMs: 20000 });
+    }).then(function () {
+      ASK_FILE.busy = false; ASK_FILE.text = ''; ASK_FILE.note = null;
+      var box = $('ask-q'); if (box && box.value.trim() === text) { box.value = ''; renderAsk(); }
+      renderAskFile();
+      toast('Filed to the Work inbox.');
+      if (PANES.work && PANES.work.intakeChanged) PANES.work.intakeChanged();   // Work reads its board again when it opens
+    }, function (err) {
+      ASK_FILE.busy = false;
+      var line = 'Not filed: ' + ((err && err.message) || 'your Mac did not answer') + ' Filing again is safe.';
+      ASK_FILE.note = { text: text, line: line, error: true };
+      renderAskFile();
+      toast(line);
+    });
+  }
+  function renderAskFile() {
+    var b = document.querySelector('#ask-results [data-action="ask-file"]'); if (!b) return;
+    b.disabled = ASK_FILE.busy;
+    var g = b.querySelector('.grow'); if (!g) return;
+    var q = ($('ask-q') && $('ask-q').value.trim()) || '';
+    g.innerHTML = esc(ASK_FILE.busy ? 'Filing\u2026' : 'File to Work inbox') + fileNoteHtml(q);
+  }
+  // ── files with Ask COS (11/07, Miles: "Sometimes I need to pass context via a screenshot, photo or file") ──
+  // The COS chat's own clip, chips, limits and upload (panes/cos-chat.js, W.cosChat.attach): photos, PDF, TXT, MD, CSV,
+  // JSON, XLSX, MP4 and MOV, up to 5, pasted, dropped or picked. They go with Ask COS only; the sheet's other rows take
+  // words. Ask COS waits for every upload, and a file that failed has to be retried or removed first. Closing the sheet
+  // keeps them for the next Ask in this tab.
+  var ASK_FILES = null, ASK_SENDING = false;
+  function askKit() { var c = window.COSWeb && window.COSWeb.cosChat; return c && c.attach ? c.attach : null; }
+  function askFiles() {
+    var kit = askKit(); if (!kit) return null;
+    if (!ASK_FILES) ASK_FILES = kit.box({
+      changed: paintAskFiles,
+      removed: function () { setStatus($('ask-status'), ''); },
+      signedOut: function () { setStatus($('ask-status'), 'This browser was signed out. Your files are kept. Sign in, then tap Retry on each file.', true); }
+    });
+    return ASK_FILES;
+  }
+  function askFilesState() {
+    var kit = askKit(), b = ASK_FILES;
+    if (!kit || !b || !b.atts.length) return 'none';
+    return kit.pending(b) ? 'waiting' : kit.failed(b) ? 'failed' : 'ready';
+  }
+  function paintAskClip() {
+    var slot = $('ask-clip'), kit = askKit(); if (!slot) return;
+    var on = !!(kit && kit.askOn());
+    if (!on) { slot.innerHTML = ''; return; }
+    // 6.99.27: Take photo beside the clip (a phone or tablet only; kit.cameraHtml).
+    if (!slot.querySelector('[data-ask-file]')) slot.innerHTML = kit.cameraHtml('data-ask-file') + kit.clipHtml('data-ask-file');
+    var full = !!(ASK_FILES && ASK_FILES.atts.length >= kit.max);
+    Array.prototype.forEach.call(slot.querySelectorAll ? slot.querySelectorAll('.cc-attach') : [], function (l) { l.classList.toggle('full', full); });
+    Array.prototype.forEach.call(slot.querySelectorAll ? slot.querySelectorAll('[data-ask-file]') : [], function (i) { i.disabled = full || ASK_SENDING; });
+  }
+  function paintAskFiles() {
+    var kit = askKit(), box = $('ask-files'), b = ASK_FILES; if (!box || !kit) return;
+    var st = askFilesState();
+    box.innerHTML = st === 'none' ? '' : kit.chipsHtml(b, 'data-action') + '<p class="ask-files-note">' + esc(
+      st === 'waiting' ? 'Uploading. Ask COS waits for it.' : st === 'failed' ? 'A file did not upload. Retry it or remove it, then Ask COS.'
+        : (b.atts.length === 1 ? 'This file goes' : 'These files go') + ' with Ask COS. Write the question above.') + '</p>';
+    box.classList.toggle('hidden', st === 'none');
+    paintAskClip(); paintAskRow();
+  }
+  function addAskFiles(list) {
+    var kit = askKit(), b = askFiles(); if (!kit || !b || !list || !list.length) return;
+    var refusals = kit.add(b, list);
+    setStatus($('ask-status'), refusals.join(' '), !!refusals.length);
+    paintAskFiles();
+  }
+  // The Ask COS row says what it sends, and waits while a file uploads.
+  function askRowNote(q) {
+    var n = ASK_FILES ? ASK_FILES.atts.length : 0;
+    // The files first: on the folded phone the line is cut, and they are what changed.
+    return '“' + q + '”' + (n ? ' with ' + (n === 1 ? '1 file' : n + ' files') : '') + (state.pane === 'today' ? (n ? ' and' : ' with') + ' what Today shows' : '');
+  }
+  function paintAskRow() {
+    var row = document.querySelector('#ask-results [data-action="ask-cos"]'); if (!row) return;
+    var st = askFilesState();
+    row.disabled = ASK_SENDING || st === 'waiting' || st === 'failed';
+    var note = row.querySelector('.note'), q = ($('ask-q') && $('ask-q').value.trim()) || '';
+    if (note) note.textContent = ASK_SENDING ? 'Sending…' : st === 'waiting' ? 'Waiting for the upload' : askRowNote(q);
+  }
+  function askSheetSend(q) {
+    if (ASK_SENDING) return;
+    var kit = askKit(), b = ASK_FILES, st = askFilesState();
+    if (st === 'waiting') { setStatus($('ask-status'), 'A file is still uploading. Ask COS when it finishes.'); return; }
+    if (st === 'failed') { setStatus($('ask-status'), 'A file did not upload. Retry it or remove it, then Ask COS.', true); return; }
+    var files = st === 'ready' ? { attachmentIds: kit.ids(b), atts: kit.sent(b) } : null;
+    ASK_SENDING = true; paintAskRow(); paintAskClip();
+    var done = function () { ASK_SENDING = false; paintAskRow(); paintAskClip(); };
+    askCos(q, $('ask-status'), files).then(function (where) {
+      done();
+      // Sent: these files went with it. Anything added while it was sending stays for the next Ask.
+      if (files && b) b.atts.filter(function (t) { return files.attachmentIds.indexOf(t.mediaId) >= 0; }).forEach(function (t) { kit.remove(b, t.id); });
+      closeAsk(); go('messages', Array.isArray(where) ? where : []);
+    }).catch(done);
+  }
   function openAsk(prefill) {
+    loadFileDomains().then(function () { if (!$('ask-sheet').classList.contains('hidden') && $('ask-q').value.trim()) renderAsk(); });
     $('ask-sheet').classList.remove('hidden');
     document.body.style.overflow = 'hidden';
     var input = $('ask-q'); input.value = prefill || '';
-    renderAsk();
+    renderAsk(); paintAskFiles(); paintAskClip();
+    var kit = askKit(); if (kit && !kit.askOn()) kit.ensureCaps().then(paintAskClip, function () {});
     setTimeout(function () { input.focus(); }, 30);
   }
   function closeAsk() { $('ask-sheet').classList.add('hidden'); document.body.style.overflow = ''; }
@@ -3434,11 +4509,13 @@
     }
     var jumps = JUMPS.filter(function (j) { return j[1].toLowerCase().indexOf(q.toLowerCase()) === 0; });
     out.innerHTML = '<div class="list" style="margin-top:14px">' +
-      '<button type="button" class="nav-row" data-action="ask-cos"><svg class="icon"><use href="#i-ask"/></svg><span class="grow">Ask COS<span class="note">“' + esc(q) + '”</span></span></button>' +
+      '<button type="button" class="nav-row" data-action="ask-cos"><svg class="icon"><use href="#i-ask"/></svg><span class="grow">Ask COS<span class="note">' + esc(askRowNote(q)) + '</span></span></button>' +
+      '<button type="button" class="nav-row" data-action="ask-file"' + (ASK_FILE.busy ? ' disabled' : '') + '><svg class="icon"><use href="#i-work"/></svg><span class="grow">' + (ASK_FILE.busy ? 'Filing\u2026' : 'File to Work inbox') + fileNoteHtml(q) + '</span></button>' +
       '<button type="button" class="nav-row" data-action="ask-meaning"><svg class="icon"><use href="#i-sessions"/></svg><span class="grow">Find a session about this<span class="note">Ranks every session by meaning</span></span></button>' +
       '<button type="button" class="nav-row" data-action="ask-work"><svg class="icon"><use href="#i-work"/></svg><span class="grow">Find a task about this<span class="note">Searches Work by meaning</span></span></button>' +
       jumps.map(function (j) { return '<button type="button" class="nav-row" data-goto="' + j[0] + '"><svg class="icon"><use href="#i-' + j[0] + '"/></svg><span class="grow">Go to ' + esc(j[1]) + '</span><span class="chev"></span></button>'; }).join('') +
       '</div><div id="ask-hits"></div><p class="status-line" id="ask-status"></p>';
+    paintAskRow();
     clearTimeout(renderAsk.t);
     if (q.length >= 2) renderAsk.t = setTimeout(function () {
       api('/api/agent-sessions/search?q=' + encodeURIComponent(q) + '&limit=6').then(function (d) {
@@ -3451,7 +4528,7 @@
 
   // ── events (one delegated listener) ─────────────────────
   document.addEventListener('click', function (e) {
-    var t = e.target.closest('[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-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');
     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();
@@ -3482,7 +4559,16 @@
       return;
     }
     if (t.hasAttribute('data-open-ask')) return openAsk();
-    if (t.hasAttribute('data-theme-choice')) { window.CosTheme.set(t.getAttribute('data-theme-choice')); paintAppearance(); syncFrameTheme(); return; }
+    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-today-needs')) {
+      var which = t.getAttribute('data-today-needs');
+      if (which === 'all') TODAY.showAllNeeds = true;
+      else if (which === 'later') TODAY.showLater = true;
+      else { TODAY.extraAt = 0; return loadToday(); }
+      return paintNeeds();
+    }
+    if (t.hasAttribute('data-theme-choice')) { window.CosTheme.set(t.getAttribute('data-theme-choice')); paintAppearance(); return; }
     if (t.hasAttribute('data-goto') || t.hasAttribute('data-pane')) {
       if (inSheet) closeAsk(); closeMenu();
       // "work/sort" is a pane and its arguments, not one name.
@@ -3505,12 +4591,24 @@
     }
     if (action === 'expand-turn') { var tr = document.querySelector('.turn[data-turn="' + t.getAttribute('data-turn') + '"]'); if (tr) tr.classList.remove('clamped'); t.remove(); return; }
     var q = $('ask-q').value.trim();
-    if (action === 'ask-cos' && q) { askCos(q, $('ask-status')).then(function (where) { closeAsk(); go('messages', Array.isArray(where) ? where : []); }).catch(function () {}); return; }
+    if ((action === 'att-remove' || action === 'att-retry') && t.closest('#session-form') && state.reading) {
+      var kitR = readerKit(), boxR = kitR && readerBox(state.reading); if (!boxR) return;
+      sessionStatus('');
+      if (action === 'att-remove') kitR.remove(boxR, t.getAttribute('data-att')); else kitR.retry(boxR, t.getAttribute('data-att'));
+      return;
+    }
+    if (inSheet && (action === 'att-remove' || action === 'att-retry') && ASK_FILES) {
+      var kitA = askKit(); setStatus($('ask-status'), '');
+      if (action === 'att-remove') kitA.remove(ASK_FILES, t.getAttribute('data-att')); else kitA.retry(ASK_FILES, t.getAttribute('data-att'));
+      return;
+    }
+    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 === 'ask-work' && q) {
       closeAsk(); go('work');
       // The Work pane (panes/work.js) owns its search box; hand it the query.
-      if (PANES.work && PANES.work.search) PANES.work.search(q);
+      ensurePane('work').then(function () { if (PANES.work && PANES.work.search) PANES.work.search(q); }, function () {});
     }
   });
 
@@ -3535,12 +4633,43 @@
     }
   });
 
+  // The Ask sheet's clip, a pasted screenshot in its box, and files dropped on it (askFiles above).
+  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 = ''; }
+  });
+  // The Sessions reader's box: a pasted screenshot, and files dropped on it.
+  document.addEventListener('paste', function (e) {
+    if (!e.target || e.target.id !== 'session-input') return;
+    var kit = readerKit(), files = kit && readerFilesOn() ? kit.pasted(e) : null;
+    if (files) { e.preventDefault(); addReaderFiles(files); }
+  });
+  ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function (type) {
+    document.addEventListener(type, function (e) {
+      var form = e.target && e.target.closest ? e.target.closest('#session-form') : null, kit = readerKit();
+      if (!form || !kit || !readerFilesOn()) return;
+      var files = kit.dragged(e, form); if (files) addReaderFiles(files);
+    });
+  });
+  document.addEventListener('paste', function (e) {
+    if (!e.target || e.target.id !== 'ask-q') return;
+    var kit = askKit(), files = kit && kit.askOn() ? kit.pasted(e) : null;
+    if (files) { e.preventDefault(); addAskFiles(files); }
+  });
+  ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function (type) {
+    var sheet = $('ask-sheet'); if (!sheet) return;
+    sheet.addEventListener(type, function (e) {
+      var kit = askKit(), zone = sheet.querySelector('.sheet'); if (!kit || !zone || !kit.askOn()) return;
+      var files = kit.dragged(e, zone); if (files) addAskFiles(files);
+    });
+  });
   document.addEventListener('input', function (e) {
     if (e.target.tagName === 'TEXTAREA') autoGrow(e.target);
     if (e.target.id === 'ask-q') renderAsk();
     if (e.target.id === 'sessions-q' && !e.target.value.trim()) renderSessionGroups(state.sessions);
   });
   document.addEventListener('keydown', function (e) {
+    if (window.COSWeb.readerMedia && window.COSWeb.readerMedia.isOpen()) return;
     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; }
@@ -3554,14 +4683,14 @@
     });
   });
   window.addEventListener('hashchange', route);
-  // Folding or unfolding the Duo crosses the 600px line: keep the hosted Memories page in step.
-  window.matchMedia('(min-width: 600px)').addEventListener('change', syncFrameTheme);
   window.addEventListener('scroll', onScroll, { passive: true });
   document.addEventListener('visibilitychange', function () {
     if (document.hidden || $('app-shell').classList.contains('hidden')) return;
     // 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 || []);
   });
   window.addEventListener('message', function (e) {
     if (e.origin !== location.origin) return;
@@ -3603,6 +4732,10 @@
     readStore: readStore, writeStore: writeStore, copyText: copyText, isPhone: isPhone,
     state: state, titles: TITLES, go: go, parseRoute: parseRoute, goBack: goBack,
     registerPane: function (name, def) { PANES[name] = def; },
+    sessionList: sessionList,
+    petPrefs: petPrefs,
+    setPetPrefs: setPetPrefs,
+    resetTodayBrief: resetBrief,
     onRoute: function (fn) { routeHooks.push(fn); },
     onShell: function (fn) { shellHooks.push(fn); },
     // The detail title after "COS Control > Section" (Control's breadcrumb). Pane modules set it
@@ -3616,6 +4749,47 @@
     sessionState: function (s) { return sxState(s); },
     isKeepWarm: function (s) { return sxKeepWarm(s); }
   };
+  // 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.
+  window.COSWeb.pane = function (name) { return PANES[name] || null; };
+  // Tap, then tap again (Today's Dismiss, Stop and Send anyway; a question card's Allow, Deny and Send): the second tap
+  // counts only once the first has been on screen ARM_CONFIRM_MS, so a double tap or a finger bounce arms and never
+  // confirms (W2-r2). The one rule both panes/today-actions.js and panes/questions.js read.
+  var ARM_CONFIRM_MS = 400;
+  window.COSWeb.armConfirmMs = ARM_CONFIRM_MS;
+  window.COSWeb.confirmReady = function (armedAt) { return typeof armedAt === 'number' && Date.now() - armedAt >= ARM_CONFIRM_MS; };
+  window.COSWeb.today = {
+    data: function () {
+      return { needs: TODAY.needs, working: TODAY.working, open: TODAY.open, welcome: TODAY.welcome, offline: TODAY.offline, at: TODAY.at,
+        sessions: state.sessions || [], intake: todayIntakeOpen(), intakeCaps: TODAY.intakeCaps, intakeLoaded: TODAY.intake !== null };
+    },
+    needWhy: needWhy, sessionTitle: sessionTitle, badge: badge, span: span, splitSessionId: splitSessionId,
+    // Needs you as Today lists it (all four sources), for the overlay's summary and the rail.
+    needs: function () { return TODAY.model; },
+    railLine: function () { return TODAY.model ? { text: todayRailLine(TODAY.model), hot: TODAY.model.now.length > 0 } : null; },
+    markGone: function (id, gone) { if (gone) TODAY.gone[id] = 1; else delete TODAY.gone[id]; paintTodayIntake(); },
+    reloadIntake: function () { return loadTodayIntake(); },
+    refresh: function () { if (state.pane === 'today') loadToday(); },
+    // 6.99.26: the pet's sessions (petPlay), and a repaint of Needs you when the held questions change.
+    petPlay: function () { return petPlay(state.sessions || []); },
+    // 6.99.27: the pet's caption and pose follow the held questions too.
+    questionsChanged: function () { if (TODAY.at) { paintNeeds(); if (state.pane === 'today' && !TODAY.offline) renderPet(state.sessions || []); } }
+  };
+  window.COSWeb.sessionKit = {
+    // 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 };
+    },
+    send: function (r, text, opts) { return continueSession(r, text, opts || {}); },
+    newKey: newTurnKey,
+    probe: function (r) { return sxProbeAttach(r); },
+    path: sessionPath, answer: apiAnswer,
+    imageHtml: readerImagesHtml, imagesMount: readerImagesMount, imagesStop: readerImagesStop,
+    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
+  };
 
   // Every pane module is a plain script after this one; boot waits for all of them.
   function boot() {