codehere 0.7.1 → 1.0.1

package/dist/infrastructure/protocols/ui/app-script.js

@@ -0,0 +1,2998 @@
+import { PHASE_CLASSIFIER_SRC } from '../thread-phase.js';
+import { RENDER_HELPERS } from './app-script-render.js';
+import { CONVERSATION_TURN } from './app-script-conversation.js';
+import { SIDEBAR } from './app-script-sidebar.js';
+import { WPASS_MODAL } from './app-script-wpass.js';
+import { OVERLAY_RENDERER } from './app-script-overlay.js';
+import { CONTEXT_SOURCES } from './app-script-context-sources.js';
+import { RECOVERY_ACTIONS } from './app-script-recovery.js';
+import { SETTINGS_DRAWER } from './app-script-drawer.js';
+import { AUDIT_CHAIN_VERIFY } from './app-script-audit-verify.js';
+import { COMPOSER_COST } from './app-script-composer-cost.js';
+import { SHARE_MODAL } from './app-script-share.js';
+import { AUDIT_FOOTER } from './app-script-audit-footer.js';
+import { FAILOVER_BANNER } from './app-script-failover.js';
+import { GITHUB_INTEGRATION } from './app-script-github.js';
+import { ONBOARDING } from './app-script-onboarding.js';
+import { TOUR } from './app-script-tour.js';
+import { OBSERVER_RAIL } from './app-script-observer.js';
+import { ARTIFACTS } from './app-script-artifacts.js';
+export const APP_SCRIPT = `
+const _cached = {};
+// Expose the live cache so /verify coverage can drive the REAL state-dependent
+// updaters (upBud/upIdx/upWk) over a known state and observe the actual banner
+// render — a const is not auto-attached to window, so the harness can't reach it
+// otherwise. Read/written only by the coverage drives, which restore after.
+try{ window._cached = _cached; }catch(e){}
+let _filter = 'all', _detail = null, _room = null, _offline = false, _autoOpened = false;
+// Client-side memo of answered agent-questions (sessionId|toolUseId -> labels)
+// so the question card stays "answered" across the post-answer re-render (the
+// step itself isn't marked server-side in v1).
+var _answeredAsks = {};
+var _convOpenByTask = {};
+// The artifacts drawer is rendered INLINE in the detail HTML, so a poll-driven
+// render() rebuilds it closed — clicking "N artifacts" opened it for under one
+// poll interval, then it snapped shut (Ega: "i cant click", 2026-07-02). Persist
+// the open state across re-render, same pattern as _convOpenByTask; reset when a
+// different task detail opens (showD).
+var _artOpen = false;
+// Same render-wipe class for individual expanded step rows: expand a step to
+// read its output, the poll re-renders and collapses it (3rd instance found by
+// the systemic sweep). Keyed by task + step signature (startedAt+label), stable
+// across renders. Toggling updates it via __rememberStepOpen.
+var _stepOpen = {};
+// DESIGN.md §4.3 room→receipts: the step wall (activityBlock) collapses into a
+// one-line receipt inside the open conversation — evidence one click away, never
+// always-on. Open state persisted per session (render-wipe-safe), reset on task
+// switch. Toggling updates it via __rememberReceiptOpen.
+var _receiptOpen = {};
+var _glMoreOpen = {}; // glance turn's full-report <details> · same render-wipe guard as _receiptOpen
+// Cross-vendor verdict cache, per session id. undefined = not fetched (renderD
+// kicks the fetch); null = fetched, not a cross-vendor review; object = the
+// receipt. Cached so the panel lives in renderD's output and survives
+// writeDetail's morph-diff (a DOM-injected node would be culled).
+var _crossVendorByTask = {};
+// Project-memory state for the open room · null = unknown (fetch in flight),
+// false = agents forget this project (show the nudge), true = memory already
+// on (stay quiet), 'just-on' = turned on from the nudge this visit (confirm).
+let _roomMemory = null;
+// The FULL project thread (all clones, all-time) fetched from /api/projects/:slug when
+// a room opens — so the conversation shows every turn, not just the recent /api/tasks subset.
+let _roomThread = null;
+// S19 glyph language: never emoji-as-icon — blocked/queued/paused carry their
+// word on the surface; the glyph only accents it (see the token-block contract).
+const ICONS = { queued:'\\u25CB', running:'\\u25CF', paused:'\\u00B7', blocked:'\\u2298', done:'\\u2713', failed:'\\u2715', crashed:'!', killed:'\\u2298' };
+const STAT_ORDER = ['running','queued','paused','blocked','done','failed','crashed','killed'];
+const FILTERS = { all: s=>true, running: s=>['running','queued','paused','blocked'].includes(s.status), done: s=>['done','completed'].includes(s.status), failed: s=>['failed','crashed','killed','error'].includes(s.status) };
+
+function ms(t) { return t?'\\u2713':'\\u2715'; }
+function dur(ms) { if(!ms&&ms!==0)return''; const s=Math.floor(ms/1000); if(s<60)return s+'s'; return Math.floor(s/60)+'m '+(s%60)+'s'; }
+// S4 · a finished-or-dead task with no recorded end must not wear a live
+// wall-clock (a crashed orphan with durationMs=0 AND completedAt=0 read
+// "23,860m" — now−started). Live states still tick; unknown says so.
+function taskDur(t){
+  if(t.durationMs) return dur(t.durationMs);
+  if(t.completedAt && t.startedAt) return dur(t.completedAt - t.startedAt);
+  if(['running','queued','paused','blocked'].includes(t.status) && t.startedAt) return dur(Date.now()-t.startedAt);
+  return '\u2014';
+}
+// Strip internal context-injection prefixes from a prompt before showing it to
+// the user. Real spawns prepend "[graphify context: ...]\\n\\n" (and failover
+// adds "[Previous session context — ...]") — functional for the agent, noise
+// for the human. Found via real-execution dogfood #45: the prefix was becoming
+// the thread title. Display-only; the actual spawn prompt keeps the prefix.
+function displayPrompt(p) {
+  return String(p == null ? '' : p)
+    .replace(/^\\[graphify context:[\\s\\S]*?\\]\\s*\\n+/, '')
+    .replace(/^\\[Previous session context[\\s\\S]*?\\]\\s*\\n+/, '')
+    .replace(/^\\s+/, '');
+}
+function title(p) {
+  // Build a headline from whole CLAUSES (split on · — and sentence-enders),
+  // accumulating up to ~72 chars — so we never chop mid-phrase like the old
+  // "...200 rps · Lua INCR in". Trailing punctuation stripped per clause.
+  var s=(displayPrompt(p)||'Untitled').split('\\n')[0].trim();
+  var parts=s.split(/\\s*[\\u00B7\\u2014]\\s*|(?<=[.!?])\\s+/)
+    .map(function(x){return x.replace(/[.!?,;:\\s]+$/,'').trim();}).filter(Boolean);
+  var out='';
+  for(var i=0;i<parts.length;i++){
+    var nx=out?out+' \\u00B7 '+parts[i]:parts[i];
+    if(out && nx.length>72) break;
+    out=nx; if(out.length>=72) break;
+  }
+  out=(out||s).trim();
+  if(out.length>80) out=out.slice(0,80).replace(/\\s+\\S*$/,'')+'\\u2026';
+  return out||'Untitled';
+}
+// HTML-escaped title — use at any site that inserts a title into innerHTML, so a
+// prompt like "<img onerror=...>" can never execute (module-level so it's in
+// scope everywhere; the function-local escapers don't reach every render site).
+function titleH(p){ return String(title(p)).replace(/[&<>"]/g,function(ch){return ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'})[ch];}); }
+
+// Per-agent identity badge — primitive #1 from AGENTIC_UX_FRAMEWORK.
+// Returns a squircle with the agent's initials in its identity color.
+// Recognized: claude-code, codex, aider, gemini, opencode, conductor, auto.
+function agentKey(id) {
+  const s = String(id||'').toLowerCase();
+  if (s === 'claude-code' || s.startsWith('claude')) return 'claude';
+  if (s === 'codex' || s.startsWith('codex')) return 'codex';
+  if (s === 'aider' || s.startsWith('aider')) return 'aider';
+  if (s === 'gemini' || s.startsWith('gemini')) return 'gemini';
+  if (s === 'opencode' || s.startsWith('opencode')) return 'opencode';
+  if (s === 'cursor' || s.startsWith('cursor')) return 'cursor';
+  if (s === 'conductor') return 'conductor';
+  if (s === 'auto') return 'auto';
+  return 'auto';
+}
+function agentInitials(id) {
+  const k = agentKey(id);
+  if (k === 'claude') return 'CC';
+  if (k === 'codex') return 'CD';
+  if (k === 'aider') return 'AI';
+  if (k === 'gemini') return 'GM';
+  if (k === 'opencode') return 'OC';
+  if (k === 'cursor') return 'CU';
+  if (k === 'conductor') return 'CH';
+  return '?';
+}
+function ab(id, size) {
+  const k = agentKey(id);
+  const sz = size === 'sm' ? ' sm' : (size === 'lg' ? ' lg' : '');
+  return '<span class="ab ' + k + sz + '">' + agentInitials(id) + '</span>';
+}
+// Phase 3 · who's-involved. Overlapping avatars for the agents (and, when
+// collaboration lands, people) involved in a room/task. Dedup by agent key,
+// show up to 4, "+N" overflow, names in the tooltip. String-only (no regex:
+// this runs inside a template literal where backslashes get mangled).
+function partStack(agents) {
+  var list = (agents || []).filter(Boolean);
+  if (!list.length) return '';
+  var seen = {}, uniq = [];
+  for (var i = 0; i < list.length; i++) {
+    if (agentInitials(list[i]) === '?') continue; // skip unrecognized agents — no broken "?" chip
+    var k = agentKey(list[i]); if (!seen[k]) { seen[k] = 1; uniq.push(list[i]); }
+  }
+  if (!uniq.length) return '';
+  var show = uniq.slice(0, 4), more = uniq.length - show.length;
+  var names = show.map(function (a) { return agentLabel(a); }).join(', ') + (more > 0 ? ' +' + more + ' more' : '');
+  var h = '<span class="pstack" role="img" aria-label="involved: ' + names + '" title="' + names + '">';
+  // Distinct 2-char vendor codes (CC/CD/CH…) — single letters collapsed Claude,
+  // Codex and Conductor all to "C". Vendor-colored + lightly spaced (not crowded).
+  for (var j = 0; j < show.length; j++) { var _k = agentKey(show[j]); h += '<span class="ab stk ' + _k + '" title="' + agentLabel(show[j]) + '">' + agentInitials(show[j]) + '</span>'; }
+  if (more > 0) h += '<span class="ab stk more">+' + more + '</span>';
+  return h + '</span>';
+}
+function agentLabel(id) {
+  const k = agentKey(id);
+  if (k === 'claude') return 'Claude Code';
+  if (k === 'codex') return 'Codex';
+  if (k === 'aider') return 'Aider';
+  if (k === 'gemini') return 'Gemini';
+  if (k === 'opencode') return 'OpenCode';
+  if (k === 'cursor') return 'Cursor';
+  if (k === 'conductor') return 'Conductor';
+  if (k === 'auto') return 'Auto';
+  return id || '?';
+}
+// Cost signal pill — primitive #2.
+${RENDER_HELPERS}
+function allS(d) { const sp=d.spawned||d.sessions||[], pe=d.persisted||[], seen=new Set(sp.map(s=>s.sessionId)); return [...sp,...pe.filter(p=>!seen.has(p.sessionId))]; }
+function cardActions(s) {
+  // Only 'kill' is wired (POST /api/task/:id/kill). Pause/Resume/Restart had NO
+  // backend endpoint — they rendered as live buttons that silently no-op'd (R11
+  // honest-state lie, 2026-06-03). Removed until real process control lands; Kill
+  // and Cancel both map to the wired kill, so every rendered control here works.
+  const m={
+    running:'<button class="card-btn kill" onclick="event.stopPropagation();a(\\'kill\\',\\''+s+'\\')">Kill</button>',
+    paused:'<button class="card-btn kill" onclick="event.stopPropagation();a(\\'kill\\',\\''+s+'\\')">Kill</button>',
+    queued:'<button class="card-btn kill" onclick="event.stopPropagation();a(\\'kill\\',\\''+s+'\\')">Cancel</button>',
+    blocked:'<button class="card-btn kill" onclick="event.stopPropagation();a(\\'kill\\',\\''+s+'\\')">Cancel</button>',
+  };
+  return m[mapped(s)]||'';
+}
+function statIcon(s) { return '<span class="status-icon '+s+'"></span>'; }
+function verB(v) { return v&&v!=='unverified'?'<span class="verify-badge '+v+'">'+v+'</span>':''; }
+function tagHtml(t) { return t.map(x=>'<span style="font-size:10.5px;color:var(--fg-40);font-family:var(--mono)">'+x+'</span>').join(''); }
+
+function st(s) {
+  if(s==='completed')return'done'; if(s==='error'||s==='killed')return'failed'; if(s==='paused')return'paused'; return s;
+}
+function aStat(s) { return s==='blocked'?'paused':s==='killed'?'failed':s==='crashed'?'failed':st(s); }
+function mapped(s) { return s==='queued'?'running':s==='blocked'?'paused':aStat(s); }
+
+function findS(id) {
+  const s=allS(_cached.tasks||{});
+  let hit=s.find(x=>x.sessionId===id); if(hit) return hit;
+  if(_roomThread&&_roomThread.tasks){ hit=_roomThread.tasks.find(x=>x.sessionId===id); if(hit) return hit; }
+  for(var k in _sbThreads){ const t=(_sbThreads[k]||[]).find(x=>x.sessionId===id); if(t) return t; }
+  return null;
+}
+
+// Crafted agent picker (composer). Replaces the native <select>; the chosen
+// value lives in the hidden #agent-pick (unchanged read contract). Rows show the
+// vendor badge + REAL readiness (agentS over _cached.readiness) — honest, never faked.
+var AGENTS=['claude-code','codex','aider','gemini','opencode'];
+var _AP_SPARK='<svg class="ap-spark" viewBox="0 0 24 24" fill="currentColor"><path d="M12 2l1.7 6.3L20 10l-6.3 1.7L12 18l-1.7-6.3L4 10l6.3-1.7z"/></svg>';
+var _apInit=false;
+function agentReadyState(id){ var ags=(_cached.readiness&&_cached.readiness.agents)||[]; var a=ags.find(function(x){return x&&(x.id===id||x.agent===id);}); return a?agentS(a.state):null; }
+function _apTrigHtml(val){
+  if(!val||val==='auto'){ return _AP_SPARK+'<span class="ap-name">Auto</span>'; }
+  return '<span class="ab stk '+agentKey(val)+'">'+(String(agentInitials(val)).charAt(0)||'?')+'</span><span class="ap-name">'+String(agentLabel(val)).replace(/[<>&]/g,'')+'</span>';
+}
+function setAgentPick(val){
+  var inp=document.getElementById('agent-pick');
+  // Set the value AND fire 'change' so the existing updateCostEst listener (which
+  // the old <select> drove natively) recomputes the cost estimate on agent change.
+  if(inp){ inp.value=val; try{ inp.dispatchEvent(new Event('change',{bubbles:true})); }catch(e){} }
+  var cur=document.getElementById('agentpick-cur'); if(cur) cur.innerHTML=_apTrigHtml(val);
+  closeAgentMenu();
+}
+function renderAgentMenu(){
+  var m=document.getElementById('agentpick-menu'); if(!m) return;
+  var cur=(document.getElementById('agent-pick')||{}).value||'auto';
+  var html='<div class="ap-item'+(cur==='auto'?' sel':'')+'" role="option" tabindex="0" onclick="setAgentPick(\\'auto\\')" onkeydown="if(event.key===\\'Enter\\'){setAgentPick(\\'auto\\')}">'+_AP_SPARK+'<span class="ap-il"><span class="ap-in">Auto</span><span class="ap-isub">best agent for the task</span></span>'+(cur==='auto'?'<span class="ap-chk">\\u2713</span>':'')+'</div>';
+  AGENTS.forEach(function(id){
+    var st=agentReadyState(id);
+    var stw=st?'<span class="ap-st">'+st+'</span>':'';
+    var dot=st?'<span class="ap-dot '+st+'"></span>':'';
+    html+='<div class="ap-item'+(cur===id?' sel':'')+'" role="option" tabindex="0" onclick="setAgentPick(\\''+id+'\\')" onkeydown="if(event.key===\\'Enter\\'){setAgentPick(\\''+id+'\\')}"><span class="ab stk '+agentKey(id)+'">'+(String(agentInitials(id)).charAt(0)||'?')+'</span><span class="ap-il"><span class="ap-in">'+agentLabel(id)+'</span></span>'+stw+dot+(cur===id?'<span class="ap-chk">\\u2713</span>':'')+'</div>';
+  });
+  m.innerHTML=html;
+}
+function toggleAgentMenu(e){ if(e){e.stopPropagation();} var m=document.getElementById('agentpick-menu'),b=document.getElementById('agentpick-btn'); if(!m) return; if(m.hidden){ renderAgentMenu(); m.hidden=false; if(b)b.setAttribute('aria-expanded','true'); } else { closeAgentMenu(); } }
+function closeAgentMenu(){ var m=document.getElementById('agentpick-menu'),b=document.getElementById('agentpick-btn'); if(m&&!m.hidden){m.hidden=true; if(b)b.setAttribute('aria-expanded','false');} }
+function initAgentPick(){
+  if(_apInit) return; var cur=document.getElementById('agentpick-cur'); if(!cur) return; _apInit=true;
+  setAgentPick((document.getElementById('agent-pick')||{}).value||'auto');
+  document.addEventListener('click',function(e){ if(!(e.target&&e.target.closest&&e.target.closest('.agentpick-wrap'))) closeAgentMenu(); });
+  document.addEventListener('keydown',function(e){ if(e.key==='Escape') closeAgentMenu(); });
+}
+function render() {
+  if(_detail){ const t=findS(_detail); if(t){ const _sy=window.scrollY; renderD(t); if(_sy>0)window.scrollTo(0,_sy); } else{ _detail=null; if(_room)renderRoom(); else renderL(); } }
+  else if(_room) renderRoom();
+  else renderL();
+  upBud(); upWk(); upIdx(); upHero(); renderDecisions();
+  renderSidebar(); initAgentPick(); maybeStartOnboarding(); if(typeof initGhImport==='function') initGhImport();
+}
+// Cockpit shell · the persistent Projects sidebar, as a REAL tree.
+// The caret toggles expand/collapse (animated via CSS, state in _sbExpanded,
+// lazy-fetches a project's tasks on first expand); the name opens the project in
+// the main pane. The active project auto-expands. Leaves open the run in the pane.
+${SIDEBAR}
+// The goal room — one goal opened to its tasks as a chronological thread of
+// agent turns. Renders into #task-list (same surface as the goals list).
+function openRoom(enc){
+  _room=decodeURIComponent(enc||''); _detail=null;
+  try{ var _rh=_roomHash(); if(_rh && location.hash!==_rh) location.hash=_rh; }catch(e){} // room state → URL (not the reverse)
+  // Entering a room closes the Spend page (loop-6 verifier catch: without
+  // this the FULL spend hero stayed rendered below the room feed under a
+  // room hash — screen/hash drift, the exact thing the spine exists to kill).
+  var _sv0=document.getElementById('spend-view'); if(_sv0) _sv0.style.display='none';
+  document.getElementById('task-list-view').style.display='';
+  // Project-memory status for the nudge — fetched once per entry from the
+  // daemon (the SAME readiness the injector acts on, not a guess).
+  _roomMemory=null;
+  (function(forCwd){
+    fetch('/api/memory/status?cwd='+encodeURIComponent(forCwd)).then(x=>x.json()).then(j=>{
+      if(_room===forCwd){ _roomMemory=!!j.ready; render(); }
+    }).catch(()=>{});
+  })(_room);
+  // Pull the FULL project thread (all clones, all-time) so the room renders the complete
+  // conversation, not the recent /api/tasks subset (e.g. 405 turns, not 15).
+  _roomThread=null;
+  (function(forCwd){
+    var proj=(_cached.projects||[]).find(function(x){return projPaths(x).indexOf(normC(forCwd))>=0;});
+    var slug=proj&&proj.slug;
+    if(!slug) return;
+    fetch('/api/projects/'+encodeURIComponent(slug)).then(x=>x.json()).then(j=>{
+      if(_room===forCwd && j && j.thread){ _roomThread={cwd:forCwd, tasks:(j.thread.tasks||[])}; render(); }
+    }).catch(function(){});
+  })(_room);
+  document.getElementById('task-list-view').style.display='';
+  document.getElementById('task-detail-view').style.display='none';
+  document.body.classList.remove('detail-open');
+  // Hand-off affordance: inside a room the composer targets THIS goal (cwd is
+  // pinned in submit) and the picker defaults to whoever worked it last —
+  // continuing is zero clicks, handing to a different agent is one visible
+  // click. Set once on entry (not in renderRoom, which re-runs every poll and
+  // would stomp the user's choice).
+  const ta=document.getElementById('main-ta');
+  if(ta) ta.placeholder='Add the next task in this goal\\u2026 any agent picks up where the last one left off';
+  const ap=document.getElementById('agent-pick');
+  if(ap){
+    const turns=allS(_cached.tasks||{}).filter(x=>!/^demo-/.test(x.sessionId||'')&&!x.mockRun&&normC(x.cwd)===normC(_room)&&x.agent).sort((a,b)=>(a.startedAt||0)-(b.startedAt||0));
+    const raw=turns.length?String(turns[turns.length-1].agent):'';
+    ap.value=['claude-code','codex','aider','gemini','opencode'].indexOf(raw)>=0?raw:'auto';
+  }
+  render();
+}
+function closeRoom(){
+  _room=null; _roomMemory=null; _roomThread=null;
+  try{ if((location.hash||'').indexOf('#/room/')===0) history.replaceState(null,'',location.pathname+location.search); }catch(e){}
+  const ta=document.getElementById('main-ta');
+  if(ta) ta.placeholder='Describe a task or ask a question...';
+  const ap=document.getElementById('agent-pick'); if(ap){ if(typeof setAgentPick==='function') setAgentPick('auto'); else ap.value='auto'; }
+  render();
+}
+async function initRoomMemory(btn){
+  if(!_room) return;
+  if(btn){ btn.disabled=true; btn.textContent='turning on\\u2026'; }
+  try{
+    const r=await fetch('/api/memory/init',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({cwd:_room})});
+    if(r.ok){ _roomMemory='just-on'; render(); }
+    else { const e=await r.json().catch(()=>({})); al('Could not turn on memory: '+(e.error||e.reason||'unknown')); if(btn){btn.disabled=false;btn.textContent='turn on project memory';} }
+  }catch(e){ al('Network error: '+e.message); if(btn){btn.disabled=false;btn.textContent='turn on project memory';} }
+}
+// Group turns into threads (continued conversations) within a room. Union-find
+// over the persisted/live lineage edge (continuedFrom — set on reply turns +
+// in-session hand-offs). A turn with no edge is its own single-turn thread.
+// Returns an array of turn-arrays, each sorted oldest-first, groups ordered by
+// their earliest turn. Sparse today (most threads = 1 turn); richer once
+// cross-agent hand-off (Phase 3) persists more edges.
+function threadGroups(items){
+  const byId={}; items.forEach(t=>{ byId[t.sessionId]=t; });
+  const parent={};
+  const find=x=>{ while(parent[x]!==undefined && parent[x]!==x){ parent[x]=parent[parent[x]]!==undefined?parent[parent[x]]:parent[x]; x=parent[x]; } return x; };
+  items.forEach(t=>{ if(parent[t.sessionId]===undefined) parent[t.sessionId]=t.sessionId; });
+  items.forEach(t=>{ const f=t.continuedFrom||t.parentSessionId; if(f&&byId[f]){ const ra=find(t.sessionId), rb=find(f); if(ra!==rb) parent[ra]=rb; } });
+  // Re-runs of the same task are one thread even without a lineage edge — the
+  // same rule the home card uses (title(prompt) equality, see the runs strip).
+  // Scoped to the same cwd so cross-project coincidences never merge.
+  const byTitle={};
+  items.forEach(t=>{
+    const k=title(t.prompt);
+    if(!k||k==='Untitled') return;
+    const key=String(t.cwd||'')+'\\u0000'+k;
+    if(byTitle[key]){ const ra=find(t.sessionId), rb=find(byTitle[key]); if(ra!==rb) parent[ra]=rb; }
+    else byTitle[key]=t.sessionId;
+  });
+  const groups={};
+  items.forEach(t=>{ const r=find(t.sessionId); (groups[r]=groups[r]||[]).push(t); });
+  const arr=Object.keys(groups).map(k=>groups[k].slice().sort((a,b)=>(a.startedAt||0)-(b.startedAt||0)));
+  arr.sort((a,b)=>(a[0].startedAt||0)-(b[0].startedAt||0));
+  return arr;
+}
+
+// Day Log (Direction A, Ega-picked 2026-07-06) — one line per task: rail hue =
+// agent, title, glance fragment, receipt right. Same-title re-runs collapse to
+// one line with a run count + total cost. Conversations/hand-offs (the wedge)
+// keep the full turn treatment.
+function dayLogGlance(t){
+  if(t.finalReport && typeof t.finalReport.summary==='string' && t.finalReport.summary.trim()){
+    var s=String(t.finalReport.summary).replace(/[#*>_~\\[\\]\\u0060]/g,'').replace(/\\s+/g,' ').trim();
+    s=s.replace(/^Aider v[\\d.]+\\s*/i,'');
+    var m=s.match(/^[\\s\\S]*?(?:[!?]|\\.(?!\\.))(?:\\s|$)/);
+    s=(m?m[0]:s).trim();
+    if(s.length>110) s=s.slice(0,110)+'\\u2026';
+    return s;
+  }
+  if(['running','queued','paused','blocked'].indexOf(t.status)>=0 && (t.steps||[]).length){
+    return 'working\\u2026 '+compactLabel((t.steps[t.steps.length-1]||{}).label||'');
+  }
+  var n=(t.steps||[]).length;
+  return n? n+' step'+(n===1?'':'s'):'';
+}
+// Day-divider label · the Day Log's calendar seams: 'today' / 'yesterday' /
+// '30 Jun' (+ the year when it isn't this year). Machine fact -> mono (it
+// reuses the .turns-label treatment; the static "Tasks in this project"
+// header died for it — the first divider anchors the list).
+function dayLabel(ts){
+  var d=new Date(ts), now=new Date();
+  var key=function(x){ return x.getFullYear()+'-'+x.getMonth()+'-'+x.getDate(); };
+  if(key(d)===key(now)) return 'today';
+  if(key(d)===key(new Date(now.getTime()-86400000))) return 'yesterday';
+  return d.getDate()+' '+['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'][d.getMonth()]
+    +(d.getFullYear()!==now.getFullYear()?' '+d.getFullYear():'');
+}
+function dayLogRow(t, runCount, totalCents){
+  var esc=function(s){return String(s==null?'':s).replace(/[&<>"]/g,function(c){return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c];});};
+  var _verified=!t.mockRun && !(t.artifacts&&t.artifacts.noGitTracking) && !!(t.verdict&&(t.verdict.grade?t.verdict.grade.green:(t.verdict.claim&&t.verdict.claim.status==='verified')));
+  var live=['running','queued','paused','blocked'].indexOf(t.status)>=0;
+  var bad=['failed','error','crashed','killed'].indexOf(t.status)>=0;
+  var cents=(typeof totalCents==='number')?totalCents:((t.cost&&typeof t.cost.spent==='number')?t.cost.spent:null);
+  var co=(cents!==null)?'$'+(cents/100).toFixed(cents<10?4:2):'';
+  var meta=[(runCount>1?'':taskDur(t)),co].filter(Boolean).join(' \\u00b7 ')+(runCount>1&&co?' total':'');
+  var g=dayLogGlance(t);
+  return '<div class="dlog'+(live?' live':'')+'" tabindex="0" role="button" style="--rail:'+railHue(t.agent,t.agent,false)+'" onclick="showD(\\''+t.sessionId+'\\')" onkeydown="if(event.key===\\'Enter\\')showD(\\''+t.sessionId+'\\')">'
+    +'<span class="dlog-t" data-user-content>'+esc(title(t.prompt))+'</span>'
+    +(runCount>1?'<span class="dlog-x">\\u00d7'+runCount+'</span>':'')
+    +(_verified?'<span class="dlog-v">verified</span>':(bad?'<span class="dlog-b">stopped</span>':(live?'<span class="dlog-l">'+esc(String(t.status))+'</span>':'')))
+    +(g?'<span class="dlog-g" data-user-content>'+esc(g)+'</span>':'')
+    +(meta?'<span class="dlog-r">'+esc(meta)+'</span>':'')
+    +'</div>';
+}
+function renderRoom(){
+  const c=document.getElementById('task-list');
+  const _or=document.getElementById('observer-rail'); if(_or){ _or.style.display='none'; }
+  const esc=s=>String(s==null?'':s).replace(/[&<>"]/g,ch=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[ch]));
+  const cwd=_room;
+  const projects=_cached.projects||[];
+  // A room is a PROJECT (a repo), which may span several local clones. Find the
+  // project that owns this cwd (membership over its localPaths), then scope the
+  // room to every clone's turns. Falls back to the single cwd when no project
+  // record exists (e.g. mock daemon with no /api/projects).
+  const p=projects.find(x=>projPaths(x).indexOf(normC(cwd))>=0)||projects.find(x=>normC(x.cwd)===normC(cwd));
+  const paths=p?projPaths(p):[normC(cwd)];
+  // S18 · practice runs never sit among the room's real turns either — they
+  // collapse behind the same quiet practice row (still one click to detail).
+  // Base the room on the FULL project thread when loaded (all turns, all-time), then let
+  // live/recent tasks from the cache override by sessionId (fresher status/verdict/cost,
+  // plus just-spawned turns not yet mirrored). Falls back to the cache subset (mock daemon
+  // / pre-fetch) so the room is never empty.
+  let roomAll;
+  if(_roomThread && _roomThread.cwd===_room && _roomThread.tasks){
+    const byId=new Map();
+    for(const t of _roomThread.tasks){ if(!/^demo-/.test(t.sessionId||'')) byId.set(t.sessionId, t); }
+    for(const t of allS(_cached.tasks||{})){ if(!/^demo-/.test(t.sessionId||'') && paths.indexOf(normC(t.cwd))>=0){ var _prev=byId.get(t.sessionId); byId.set(t.sessionId, (_prev&&_prev.archived&&!('archived' in t))?Object.assign({},t,{archived:_prev.archived}):t); } }
+    roomAll=[...byId.values()];
+  } else {
+    roomAll=allS(_cached.tasks||{}).filter(x=>!/^demo-/.test(x.sessionId||'') && paths.indexOf(normC(x.cwd))>=0);
+  }
+  const practice=roomAll.filter(x=>x.mockRun);
+  const items=roomAll.filter(x=>!x.mockRun);
+  items.sort((a,b)=>(a.startedAt||0)-(b.startedAt||0)); // turns in the order they happened
+  // Fold zero-signal runs (terminal, no report, no cost, <2 steps) so abandoned
+  // junk doesn't sit among real work. An honest failure (with a report, cost, or
+  // steps) is signal and stays visible.
+  const _zeroSig=function(t){
+    if(t.batchId) return false; // batch fan-outs are real multi-agent work
+    if(['running','queued','paused','blocked','completed','done'].indexOf(t.status)>=0) return false;
+    const hasReport=!!(t.finalReport&&t.finalReport.summary&&String(t.finalReport.summary).trim());
+    const hasCost=!!(t.cost&&typeof t.cost.spent==='number'&&t.cost.spent>0);
+    return !hasReport && !hasCost && (t.steps||[]).length<2;
+  };
+  const archivedItems=items.filter(function(x){return x.archived;});
+  const folded=items.filter(function(x){return _zeroSig(x)&&!x.archived;});
+  const shown=items.filter(function(x){return !_zeroSig(x)&&!x.archived;});
+  window._roomSlug=(p&&p.slug)||''; // the archive handler needs the project slug
+  const repoName=p?projName(p):(cwd?(cwd.split('/').filter(Boolean).pop()||'Project'):'Project');
+  // Title = the project name (same as the breadcrumb + the home list). Using
+  // p.title directly diverged ("Agent" vs "muhammadegaa/codehere"); projName
+  // already prefers the remote name, so repoName is the one consistent identity.
+  const title=repoName;
+  const agents=[...new Set(items.map(x=>x.agent).filter(Boolean))];
+  // The "← Projects" back button died for the rail's Today row (nav option B,
+  // 2026-07-07) — the crumb keeps the place-label, the rail does the moving.
+  let html='<div class="room-head">';
+  html+='<div class="room-crumb" style="font-family:var(--mono);font-size:10.5px;color:var(--fg-40);margin:2px 0 4px">Projects / '+esc(repoName)+'</div>';
+  // Rename is offered ONLY for local projects (no remote): there projName returns
+  // p.title, so a rename shows immediately. Remote projects keep their canonical
+  // repo name (renaming the slug would be a lie), so no pencil.
+  var _canRename=!!(p&&p.slug&&!p.remote);
+  html+='<div class="room-title-row"><span class="room-title" id="room-title" data-user-content>'+esc(title)+'</span>'
+    +(_canRename?'<button class="room-rename" title="Rename project" aria-label="Rename project" onclick="renameRoom(\\''+esc(p.slug)+'\\')"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20h9"/><path d="M16.5 3.5a2.1 2.1 0 0 1 3 3L7 19l-4 1 1-4Z"/></svg></button>':'')
+    +'</div>';
+  // Everyone sees the plain-English outcome; the cwd path rides along
+  // (S20: the persona CSS-hiding died — lenses recompose via templates).
+  const _done=shown.filter(x=>x.status==='completed'||x.status==='done').length;
+  const _outcome=shown.length?(_done===shown.length?('all '+shown.length+' done'):(_done+' of '+shown.length+' done')):'no tasks yet';
+  // Short trailing path, not the dev-y full /Users/... (full path on hover).
+  var _cwParts=String(cwd||'').split('/').filter(Boolean);
+  var _cwShort=_cwParts.length>3?('\\u2026/'+_cwParts.slice(-3).join('/')):(cwd||'');
+  html+='<div class="room-sub">'+esc(_outcome)+(agents.length?' \\u00b7 '+partStack(agents):'')+'<span class="room-cwd" data-user-content title="'+esc(cwd||'')+'"> \\u00b7 '+esc(_cwShort)+'</span></div></div>';
+  // Live-agents strip · the room shows who is working right now, at the top,
+  // before the task history (L2 mockup). Real state only (running/queued/paused/blocked).
+  const _live=items.filter(x=>['running','queued','paused','blocked'].indexOf(x.status)>=0);
+  if(_live.length){
+    html+='<div class="live-strip">'+_live.map(function(x){
+      return '<span class="live-a"><span class="live-dot"></span>'+esc(agentLabel(x.agent)||'agent')+' <span class="live-task" data-user-content>'+esc(String(x.prompt||'').slice(0,48))+'</span></span>';
+    }).join('')+'</div>';
+  }
+  if(shown.length){
+    // It-4 V1-MULTITASK + V1-FANOUT-ALL · batch grouping. Turns spawned by one
+    // /api/task/batch call share a batchId. When >=2 turns share one, render a
+    // single .project-rollup header (counts DERIVED LIVE every render — never a
+    // stored aggregate, which would lie after a crash) + the children as a
+    // side-by-side .fanout-all grid. Lone turns render as one-line rows.
+    const seenBatch={};
+    const renderTurn=(t,full)=>{
+      const bid=t.batchId;
+      if(bid){
+        if(seenBatch[bid]) return ''; // batch already rendered at its first turn
+        const sibs=items.filter(x=>x.batchId===bid);
+        if(sibs.length>=2){ seenBatch[bid]=1; return batchH(sibs); }
+      }
+      // Day Log (Direction A, Ega-picked 2026-07-06) — ONE row treatment for
+      // the whole feed. Depth lives in the detail view, not the feed. The
+      // cleanup pass (same day) removed the coexisting full-turn treatment:
+      // groups keep only their border + label as context.
+      return dayLogRow(t,1);
+    };
+    // Threads-as-groups · turns continued from one another (a hand-off or a
+    // follow-up) wrap into one conversation. Most threads are a single turn —
+    // those render exactly as before, no wrapper. Richer once Phase 3 persists
+    // cross-agent hand-off edges.
+    const groups=threadGroups(shown);
+    // Day dividers · the Day Log's calendar seams. Groups arrive sorted by
+    // first-turn startedAt, so one running lastDay marker is enough.
+    let _lastDay='';
+    for(const g of groups){
+      const _gts=g[0].startedAt||0;
+      if(_gts){ const _dk=new Date(_gts).toDateString(); if(_dk!==_lastDay){ _lastDay=_dk; html+='<div class="turns-label day-div">'+esc(dayLabel(_gts))+'</div>'; } }
+      if(g.length>1){
+        // A thread that crosses AGENTS is the wedge — make it pop. A same-agent
+        // follow-up stays quiet (the plain border); a cross-agent hand-off gets
+        // the accent border + an agent-chain header + a "handed to X" marker
+        // between the turns where the baton changes hands.
+        const ga=[...new Set(g.map(x=>x.agent).filter(Boolean))];
+        const crossAgent=ga.length>1;
+        const chain=ga.map(agentLabel);
+        const border=crossAgent?'2px solid var(--accent)':'2px solid var(--border)';
+        // A group can form two ways: lineage edges (a real conversation) or
+        // same-title re-runs (the home runs-strip rule). Label what it IS.
+        const ids={}; g.forEach(x=>{ ids[x.sessionId]=1; });
+        const hasEdge=g.some(x=>{ const f=x.continuedFrom||x.parentSessionId; return f&&ids[f]; });
+        // Same-title re-runs (no lineage, one agent) collapse to ONE Day-Log
+        // line: newest run's glance + a run count + the family's total cost.
+        // Six identical failed runs used to eat 30 lines; now they eat one.
+        if(!crossAgent && !hasEdge){
+          let cents=0, any=false;
+          for(const x of g){ if(x.cost&&typeof x.cost.spent==='number'){ cents+=x.cost.spent; any=true; } }
+          html+=dayLogRow(g[g.length-1], g.length, any?cents:undefined);
+          continue;
+        }
+        // A failover is not a chosen hand-off — the label and the baton mark
+        // say which one happened (quiet: same treatment, honest words + reason).
+        const anyFailover=g.some(x=>x.failoverFrom);
+        html+='<div class="thread-group'+(crossAgent?' handoff':'')+'" style="border-left:'+border+';padding-left:10px;margin:6px 0">'
+          +'<div class="turns-label" style="margin-top:0">'
+          +(crossAgent?(anyFailover?'failover':'hand-off')+' \\u00b7 '+esc(chain.join(' \\u203a ')):(hasEdge?'conversation \\u00b7 '+g.length+' turns':g.length+' runs of this task'))
+          +'</div>';
+        let prevAgent=null;
+        for(const t of g){
+          if(crossAgent&&prevAgent&&t.agent&&t.agent!==prevAgent){
+            const _foR=(t.failoverFrom&&t.failoverReason)?String(t.failoverReason).replace(/_/g,' '):'';
+            html+='<div class="handoff-mark" style="color:var(--accent);font-size:12px;margin:2px 0 2px 2px">\\u21b3 '+(t.failoverFrom?esc(agentLabel(t.agent))+' took over'+(_foR?' \\u00b7 '+esc(_foR):''):'handed to '+esc(agentLabel(t.agent)))+'</div>';
+          }
+          html+=renderTurn(t);
+          if(t.agent) prevAgent=t.agent;
+        }
+        html+='</div>';
+      } else {
+        html+=renderTurn(g[0]);
+      }
+    }
+    // One quiet door to the proof — for the moment someone actually doubts, not
+    // a standing billboard about our own honesty. The audit log is still there;
+    // it just doesn't narrate itself in the conversation.
+  } else if(!practice.length && !folded.length){
+    html+='<div class="empty-state"><h2>No tasks here yet.</h2><p style="color:var(--fg-50);font-size:13px;margin-top:6px">Describe a task below \\u00b7 any agent picks it up, and codehere records what it did and checks it.</p></div>';
+  }
+  if(folded.length){
+    html+='<details class="folded-runs"><summary>'+folded.length+' run'+(folded.length===1?'':'s')+' that changed nothing</summary><div class="reveal-wrap"><div class="reveal-body">'+folded.map(function(t){return dayLogRow(t,1);}).join('')+'</div></div></details>';
+  }
+  if(archivedItems.length){
+    html+='<details class="folded-runs archived-runs"><summary>'+archivedItems.length+' archived</summary><div class="reveal-wrap"><div class="reveal-body">'+archivedItems.map(function(t){return dayLogRow(t,1);}).join('')+'</div></div></details>';
+  }
+  practice.sort((a,b)=>(a.startedAt||0)-(b.startedAt||0));
+  html+=pracGroupHtml(practice);
+  // Project-memory nudge (stranger-walk finding 2026-06-06): web-only users
+  // never run codehere-init, so agents silently get NO memory of the project.
+  // First-run only (Ega 2026-06-17) — shown on a fresh project (<=1 turn), not
+  // re-nagged on every visit. The confirmation says "from the next task" because
+  // injection happens at spawn — no fake instant effect.
+  if(_roomMemory===false && items.length<=1){
+    html+='<div class="mem-nudge">agents forget this project between runs \\u00b7 <button class="mem-btn" onclick="initRoomMemory(this)">turn on project memory</button></div>';
+  } else if(_roomMemory==='just-on'){
+    html+='<div class="mem-nudge on">\\u2713 project memory is on \\u00b7 agents will remember this project from the next task</div>';
+  }
+  // S12 · same non-destructive morph as renderL (hover/scroll survive polls).
+  morphInto(c, html);
+}
+// Inline-rename a (local) project. Swaps the title to an input; Enter or blur
+// saves via the existing POST /api/projects/:slug/rename, Esc restores. Same-origin
+// POST (no token needed). On success, refetch + re-render so the new name shows
+// everywhere (room title + crumb + home), consistently.
+window.renameRoom = function(slug){
+  var el=document.getElementById('room-title'); if(!el) return;
+  var cur=el.textContent||'';
+  var inp=document.createElement('input');
+  inp.className='room-title-edit'; inp.value=cur; inp.setAttribute('aria-label','Project name');
+  el.replaceWith(inp); inp.focus(); inp.select();
+  var settled=false;
+  var finish=function(save){
+    if(settled) return; settled=true;
+    var v=(inp.value||'').trim();
+    if(save && v && v!==cur){
+      fetch('/api/projects/'+encodeURIComponent(slug)+'/rename',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({title:v})})
+        .then(function(r){return r.json().catch(function(){return {};});})
+        .then(function(){ return (typeof fetchAll==='function'?fetchAll():Promise.resolve()); })
+        .then(function(){ if(window._room) renderRoom(); })
+        .catch(function(){ render(); });
+    } else { render(); }
+  };
+  inp.onkeydown=function(e){ if(e.key==='Enter'){e.preventDefault();finish(true);} else if(e.key==='Escape'){e.preventDefault();finish(false);} };
+  inp.onblur=function(){ finish(true); };
+};
+// Archive (soft-delete) or restore a task. POSTs the audit-safe archive event,
+// then refetches the project thread so the archived flag is recomputed, and
+// re-renders. The task is never deleted — it moves to the "archived" reveal.
+window.archiveTask = function(sessionId, archived){
+  var slug=window._roomSlug; if(!slug) return;
+  fetch('/api/projects/'+encodeURIComponent(slug)+'/archive',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({sessionId:sessionId, archived:!!archived})})
+    .then(function(r){return r.json().catch(function(){return {};});})
+    .then(function(){
+      return fetch('/api/projects/'+encodeURIComponent(slug)).then(function(x){return x.json();}).then(function(j){
+        if(j&&j.thread&&window._room){ _roomThread={cwd:_room, tasks:(j.thread.tasks||[])}; }
+      }).catch(function(){});
+    })
+    .then(function(){ if(window._room) renderRoom(); })
+    .catch(function(){});
+};
+
+
+// C-01 · first-run indexing banner · auto-show when session count < 3 +
+// only once per browser session (sessionStorage tracks the dismissal).
+function upIdx(){
+  const banner=document.getElementById('indexing-banner');
+  if(!banner)return;
+  try{
+    if(sessionStorage.getItem('codehere_indexing_dismissed')==='1'){banner.style.display='none'; return;}
+  }catch{}
+  const all=allS(_cached.tasks||{});
+  banner.style.display = all.length<3 ? 'block' : 'none';
+  if(all.length>=3){
+    try{sessionStorage.setItem('codehere_indexing_dismissed','1');}catch{}
+  }
+}
+
+// F-02 · cross-worktree alert · scan for any running session whose cwd
+// differs from the most-common cwd AND has been running > 5 minutes. Pulses
+// in the squad row · click to jump to that session's detail.
+function upWk(){
+  const all=allS(_cached.tasks||{});
+  const running=all.filter(x=>['running','queued','paused','blocked'].includes(x.status) && x.cwd);
+  const ae=document.getElementById('worktree-alert');
+  const at=document.getElementById('worktree-alert-text');
+  if(!ae||!at){return;}
+  if(running.length<2){ae.style.display='none'; window._wkTarget=null; return;}
+  // Pick the cwd that's most-common · everything else is "other"
+  const cwdCounts={};
+  for(const r of running) cwdCounts[normC(r.cwd)]=(cwdCounts[normC(r.cwd)]||0)+1;
+  let topCwd='', topN=0;
+  for(const k in cwdCounts) if(cwdCounts[k]>topN){topN=cwdCounts[k]; topCwd=k;}
+  const now=Date.now();
+  const oddOnes=running.filter(r=>normC(r.cwd)!==topCwd && (now-r.startedAt) > 5*60*1000);
+  if(!oddOnes.length){ae.style.display='none'; window._wkTarget=null; return;}
+  const t=oddOnes[0];
+  window._wkTarget=t.sessionId;
+  // Shorten cwd to its last path component for display
+  const short=String(t.cwd||'').split('/').filter(Boolean).slice(-1)[0] || t.cwd;
+  // S12 · taskDur honesty rule for the chip: a live minute counter ONLY for a
+  // session that is verifiably live (a heartbeat — its latest step or its
+  // spawn — within the last 30 minutes). A stuck/stalled record (the demo
+  // fixture frozen 16 days on "running") shows its stalled state, never a
+  // "running 23362m" lie.
+  const _steps=t.steps||[];
+  const _lastStep=_steps.length?_steps[_steps.length-1]:null;
+  const _beat=Math.max(t.startedAt||0, _lastStep&&(_lastStep.completedAt||_lastStep.startedAt)||0);
+  ae.style.display='inline-flex';
+  if(t.stalledReason || (now-_beat) > 30*60*1000){
+    at.textContent='stalled in '+short;
+  } else {
+    const mins=Math.floor((now-t.startedAt)/60000);
+    at.textContent='running '+mins+'m in '+short;
+  }
+}
+
+// ── S12 · A-home hero — the story of your day ──────────────────────────────
+// Every number is COMPUTED from _cached.tasks, never hardcoded: today =
+// startedAt within the LOCAL day · agents = distinct agents among today's
+// non-demo tasks (demo/practice sessions never inflate the story). Zero tasks
+// today -> the honest first-run hero, no fake numbers. data-verify-hero-*
+// stamps carry the claim so the H13 probe can re-derive and catch a lie.
+let _heroPrev={agents:0,verified:0,caught:0,stopped:0,running:0,spend:0};
+let _heroSnap=null;
+function heroCounts(){
+  // S18 · PAIRED with verify-page H13's expected-derivation (hReal filter):
+  // practice runs (mockRun) never feed the day-line — a practice agent never
+  // counts as "worked for you today". Change BOTH sides identically (the
+  // honest-rule update), never one side alone.
+  const all=allS(_cached.tasks||{}).filter(t=>!/^demo-/.test(t.sessionId||'')&&!t.mockRun);
+  const sod=new Date(); sod.setHours(0,0,0,0);
+  const today=all.filter(t=>(t.startedAt||0)>=sod.getTime());
+  const liveSt=['running','queued','paused','blocked'];
+  // Refuter C4 · a task still running that started BEFORE midnight is part of
+  // "now" — live counts ignore the day boundary; day-scoped counts don't.
+  const live=all.filter(t=>liveSt.includes(t.status));
+  // Refuter C1 · "verified" derives from the VERDICT (claims match recorded
+  // reality), never the dead t.verification field — and never a mock run, a
+  // failed run, or an untracked repo (the same gates the green block obeys).
+  // 2.2 · "verified" derives from the COMPOSITE GRADE (green only with an
+  // INDEPENDENT signal — observed on disk or adversarial cross-vendor), never
+  // self-report alone. Fallback to the legacy claim check for any verdict with
+  // no grade attached (real tasks always carry one via composeVerdict).
+  const isVerified=t=>!!(t.verdict&&(t.verdict.grade?t.verdict.grade.green:(t.verdict.claim&&t.verdict.claim.status==='verified')))
+    && !t.mockRun
+    && ['completed','done'].includes(t.status)
+    && !(t.artifacts&&t.artifacts.noGitTracking);
+  return {
+    today: today.length,
+    agents: [...new Set(today.concat(live).map(t=>String(t.agent||'')).filter(Boolean))].length,
+    verified: today.filter(isVerified).length,
+    // Refuter C3 · "caught" means the VERIFIER caught a contradiction —
+    // user-killed / crashed runs are honest "didn't finish", a separate word.
+    caught: today.filter(t=>{var v=t.verdict;return !!(v&&(v.grade?v.grade.headline==='broken':(v.claim&&v.claim.status==='broken')));}).length,
+    stopped: today.filter(t=>['failed','error','crashed','killed'].includes(t.status)).length,
+    running: live.length,
+  };
+}
+// S13 · with tasks today the hero element IS the TODAY day-line — same
+// element, same data-verify-hero-* stamps, same heroCounts derivations
+// (H13 unchanged). The big two-line hero renders ONLY first-run, where it
+// keeps its teach copy. The S12 proof strip merged into the OSS footer
+// (one audit truth line, not two).
+function upHero(){
+  const el=document.getElementById('home-hero');
+  if(!el) return;
+  if(_room){ el.style.display='none'; document.body.classList.remove('first-run'); return; }
+  el.style.display='block';
+  // A scan/fix lives INSIDE this hero's innerHTML. While one is mid-flight, never rebuild the hero —
+  // it would wipe the result (and break the running fix timer's DOM refs) out from under the user.
+  if(window._scanBusy) return;
+  const c=heroCounts();
+  const p=_cached.pricing;
+  const spendC=p?(p.spentTodayCents||0):null;
+  const capC=p&&p.dailyBudgetCents?p.dailyBudgetCents:null;
+  // The claim, stamped for the H13 probe — re-derived independently there.
+  el.setAttribute('data-verify-hero-mode', c.today?'counts':'first-run');
+  el.setAttribute('data-verify-hero-agents', String(c.agents));
+  el.setAttribute('data-verify-hero-verified', String(c.verified));
+  el.setAttribute('data-verify-hero-caught', String(c.caught));
+  el.setAttribute('data-verify-hero-stopped', String(c.stopped));
+  el.setAttribute('data-verify-hero-running', String(c.running));
+  // The product home is never a landing page — always the compact day-line, never
+  // the big marketing hero (that pitch lives on codehere.uk + the onboarding tour).
+  document.body.classList.remove('first-run');
+  el.classList.add('day-line-mode');
+  const snap=JSON.stringify([c.today,c.agents,c.verified,c.caught,c.stopped,c.running,spendC,capC]);
+  if(snap===_heroSnap) return; // unchanged — leave the DOM (and any focus) alone
+  _heroSnap=snap;
+  if(!c.today){
+    // No activity today: a slim, product-y day-line. When there's earlier work
+    // (surfaced as "Recent" below), drop the "no tasks" note — it contradicts it.
+    const dt=new Date();
+    const DAYS=['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'];
+    const MONTHS=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+    var _anyHist=allS(_cached.tasks||{}).some(function(x){return !/^demo-/.test(x.sessionId||'')&&!x.mockRun;});
+    el.innerHTML='<div class="day-line"><span class="dl-today">'+DAYS[dt.getDay()]+' \\u00b7 '+MONTHS[dt.getMonth()]+' '+dt.getDate()+'</span>'+(_anyHist?'':'<span>\\u00b7</span><span class="dl-quiet">no tasks yet today</span>')+'</div>';
+    _heroPrev={agents:0,verified:0,caught:0,stopped:0,running:0,spend:0};
+    return;
+  }
+  // Day-line · plain language, calm casing. "checked" splits into verified
+  // (the claim held) and caught (the claim broke) — a broken claim is never
+  // folded into a "verified" count. Every number still comes from heroCounts;
+  // the data-verify-hero-* stamps (set in upHero) are untouched.
+  el.innerHTML='<div class="day-line"><span class="dl-today">Today</span>'
+    +'<span>\\u00b7</span><span><b>'+c.agents+'</b> agent'+(c.agents===1?'':'s')+'</span>'
+    +(c.verified>0?'<span>\\u00b7</span><span><b>'+c.verified+'</b> verified</span>':'')
+    +(c.caught>0?'<span>\\u00b7</span><span><b>'+c.caught+'</b> caught</span>':'')
+    +(c.running>0?'<span>\\u00b7</span><span><b>'+c.running+'</b> running</span>':'')
+    +(spendC!=null?'<span>\\u00b7</span><span><b>$'+(spendC/100).toFixed(2)+'</b>'+(capC?' / $'+(capC/100).toFixed(2):'')+'</span>':'')
+    +'</div>';
+  _heroPrev={agents:c.agents,verified:c.verified,caught:c.caught,stopped:c.stopped,running:c.running,spend:spendC!=null?spendC/100:0};
+}
+
+function fmtGap(ms){
+  // Two-line label · big "4h 38m later" + small relative-time sub
+  // ("≈ 5 hours" · "≈ 2 days"). Demo v12 lines 425-426 ·
+  // .time-gap .label b / .time-gap .label .sub. R10 retro 2026-05-24:
+  // earlier adjective sub ("between sessions") was banked as a
+  // "numbers over adjectives" violation · replaced with a real
+  // approximate delta so the gap reads as a measurement, not a feeling.
+  let main;
+  const m=Math.floor(ms/60000);
+  if(m<60) main = m+'m later';
+  else {
+    const h=Math.floor(m/60); const rm=m%60;
+    if(h<24) main = rm ? h+'h '+rm+'m later' : h+'h later';
+    else main = Math.floor(h/24)+'d later';
+  }
+  let sub;
+  const hours = ms / 3600000;
+  if(hours < 1) {
+    const mins = Math.round(ms/60000);
+    sub = '\\u2248 ' + mins + ' minute' + (mins===1?'':'s');
+  } else if(hours < 24) {
+    const h = Math.round(hours);
+    sub = '\\u2248 ' + h + ' hour' + (h===1?'':'s');
+  } else if(hours < 24*30) {
+    const days = Math.round(hours/24);
+    sub = '\\u2248 ' + days + ' day' + (days===1?'':'s');
+  } else {
+    const wks = Math.round(hours/(24*7));
+    sub = '\\u2248 ' + wks + ' week' + (wks===1?'':'s');
+  }
+  return '<b>'+main+'</b><span class="sub">'+sub+'</span>';
+}
+
+// One goal = one room regardless of path SPELLING. New spawns canonicalize
+// cwd server-side (realpath at the spawn boundary), but persisted records
+// predate that: on macOS /tmp/x and /private/tmp/x are the same directory
+// (/tmp -> /private/tmp symlink) and rendered as TWO goals for one repo
+// (browser dogfood 2026-06-10). Merge the known-equivalent legacy spellings
+// at every cwd comparison; display keeps the canonical (/private) form.
+function normC(s){ var c=String(s==null?'':s); return c.replace(/^\\/(tmp|var)(\\/|$)/,'/private/$1$2'); }
+
+// S12 · non-destructive list render. Build the new HTML into a detached
+// container and morph children by index (the SAME reconcile writeDetail
+// uses), so a poll never wipes hover / focus / scroll — every unchanged card
+// keeps its exact DOM node. This is the renderL/renderRoom counterpart of
+// writeDetail's morph; morphNode is hoisted (function declaration).
+function morphInto(c, html){
+  if(!c.firstElementChild && !(c.textContent||'').trim()){ c.innerHTML=html; return; }
+  var tmp=document.createElement('div'); tmp.innerHTML=html;
+  var nw=Array.prototype.slice.call(tmp.childNodes);
+  for(var i=0;i<nw.length;i++){
+    var o=c.childNodes[i];
+    if(!o){ c.appendChild(nw[i]); continue; }
+    morphNode(o, nw[i]);
+  }
+  while(c.childNodes.length>nw.length){ c.removeChild(c.lastChild); }
+}
+
+// S12 · EARLIER chapter progressive disclosure — render the latest ~20, the
+// rest behind an explicit expander (no unbounded DOM, no scroll hijack).
+let _earlierShown = 20;
+function showEarlier(){
+  _earlierShown = Number.MAX_SAFE_INTEGER;
+  const sc=document.querySelector('.content');
+  const y=sc?sc.scrollTop:0;
+  renderL();
+  if(sc) sc.scrollTop=y; // scroll preserved across expansion
+}
+
+// S13 · the history row — EARLIER + demo fixtures collapse behind ONE quiet
+// row; expanding reuses the S12 scroll-preserving mechanics. The harness
+// expands/collapses through this REAL render path (never DOM injection).
+let _histOpen = false;
+function toggleHist(){
+  const sc=document.querySelector('.content');
+  const y=sc?sc.scrollTop:0;
+  _histOpen=!_histOpen;
+  if(!_histOpen) _earlierShown=20;
+  renderL();
+  if(sc) sc.scrollTop=y; // scroll preserved across expansion
+}
+window.__histExpand=function(){ if(!_histOpen){ _histOpen=true; renderL(); } };
+window.__histCollapse=function(){ if(_histOpen){ _histOpen=false; _earlierShown=20; renderL(); } };
+
+// S18 · the practice expander — practice (CODEHERE_MOCK) runs collapse behind
+// their own quiet row beside the history row. Same scroll-preserving
+// mechanics as toggleHist; shared by the home and the room render.
+let _pracOpen = false;
+function togglePrac(){
+  const sc=document.querySelector('.content');
+  const y=sc?sc.scrollTop:0;
+  _pracOpen=!_pracOpen;
+  if(_room) renderRoom(); else renderL();
+  if(sc) sc.scrollTop=y;
+}
+window.__pracExpand=function(){ if(!_pracOpen){ _pracOpen=true; if(_room) renderRoom(); else renderL(); } };
+window.__pracCollapse=function(){ if(_pracOpen){ _pracOpen=false; if(_room) renderRoom(); else renderL(); } };
+// One quiet row + (when open) the one-line practice rows. Used by renderL
+// and renderRoom so practice never sits among real work on either surface.
+function pracGroupHtml(practice){
+  if(!practice.length) return '';
+  let html='<button class="hist-row prac-row" onclick="togglePrac()" aria-expanded="'+(_pracOpen?'true':'false')+'" data-verify-unit="practice" data-verify-practice-n="'+practice.length+'">practice runs \\u00b7 '+practice.length+(_pracOpen?' \\u00b7 collapse':' \\u00b7 expand \\u203A')+'</button>';
+  if(_pracOpen) html+='<div class="practice-rows">'+practice.map(rowH).join('')+'</div>';
+  return html;
+}
+
+// One goal group (head + its cards, with the >2h time-gap separators kept).
+function goalGroupsHtml(items, titleFor, esc){
+  const groups=new Map();
+  for(const t of items){
+    const key=normC(t.cwd)||'ungrouped';
+    if(!groups.has(key)) groups.set(key,{cwd:t.cwd,items:[]});
+    groups.get(key).items.push(t);
+  }
+  const lastTs=g=>g.items.reduce((m,x)=>Math.max(m,x.startedAt||0),0);
+  const ordered=[...groups.values()].sort((a,b)=>lastTs(b)-lastTs(a));
+  let html='';
+  for(const g of ordered){
+    g.items.sort((a,b)=>(b.startedAt||0)-(a.startedAt||0));
+    const running=g.items.filter(x=>['running','queued','paused','blocked'].includes(x.status)).length;
+    const meta=g.items.length+' task'+(g.items.length===1?'':'s')+(running?' · '+running+' running':'');
+    html+='<div class="goal-group"><div class="goal-head" tabindex="0" role="button" data-goal-cwd="'+encodeURIComponent(g.cwd||'')+'" onclick="event.stopPropagation();openRoom(\\''+encodeURIComponent(g.cwd||'')+'\\')" onkeydown="if(event.key===\\'Enter\\'||event.key===\\' \\'){event.preventDefault();openRoom(\\''+encodeURIComponent(g.cwd||'')+'\\')}"><span class="goal-title" data-user-content>'+esc(titleFor(g.cwd))+'</span><span class="goal-meta">'+esc(meta)+' \\u00b7 open \\u203A</span></div>';
+    // Time-gap separator within a goal · a big gap between consecutive tasks
+    // in the same goal is meaningful ("picked this back up 3 days later").
+    let prevTs=null;
+    for(const runs of groupByTitle(g.items)){
+      const t=runs[0];
+      const ts=t.startedAt||0;
+      if(prevTs!==null && ts>0 && prevTs>0){
+        const gap=Math.abs(prevTs-ts);
+        if(gap>2*3600*1000){ html+='<div class="time-gap"><span class="line"></span><span class="label">'+fmtGap(gap)+'</span><span class="line"></span></div>'; }
+      }
+      html+=groupCardH(runs);
+      prevTs=ts;
+    }
+    html+='</div>';
+  }
+  return html;
+}
+
+// Project = a repository (git remote = identity; clones collapse server-side).
+// Display name: org/repo from the remote when present, else the project title
+// or the folder basename.
+function projName(p){
+  if(p&&p.remote){ const parts=String(p.remote).split('/').filter(Boolean); return parts.length>=2?parts.slice(1).join('/'):p.remote; }
+  if(p&&p.title) return p.title;
+  const cwd=(p&&(p.cwd||(p.localPaths&&p.localPaths[0])))||'';
+  const seg=String(cwd).split('/').filter(Boolean); return seg.length?seg[seg.length-1]:'Project';
+}
+// Compact relative-age label for a project's last activity.
+function projAgo(ts){
+  if(!ts) return '';
+  const s=Math.max(0,Math.floor((Date.now()-ts)/1000));
+  if(s<60) return 'just now';
+  const m=Math.floor(s/60); if(m<60) return m+'m ago';
+  const h=Math.floor(m/60); if(h<24) return h+'h ago';
+  const d=Math.floor(h/24); return d+'d ago';
+}
+// The set of normalized cwds that belong to a project (its clones).
+function projPaths(p){ return ((p&&p.localPaths&&p.localPaths.length)?p.localPaths:[(p&&p.cwd)||'']).map(normC); }
+// The project-first home body: one row per repository, newest-first. Live
+// running counts + thread counts overlay from the live /api/tasks records
+// (which carry the freshest status), keyed to the project via its localPaths.
+function projectListHtml(esc){
+  const projects=_cached.projects||[];
+  if(!projects.length) return '';
+  const real=allS(_cached.tasks||{}).filter(x=>!/^demo-/.test(x.sessionId||'')&&!x.mockRun);
+  // normalized-cwd -> project.id
+  const cwdToId={};
+  projects.forEach(p=>{ projPaths(p).forEach(np=>{ if(np) cwdToId[np]=p.id; }); });
+  const tasksById={};
+  real.forEach(t=>{ const pid=cwdToId[normC(t.cwd)]; if(pid){ (tasksById[pid]=tasksById[pid]||[]).push(t); } });
+  const _live=t=>['running','queued','paused','blocked'].includes(t.status);
+  let html='<div class="section-label section-label-row">Projects<button class="add-gh" onclick="event.stopPropagation();openClone()" title="Clone a GitHub repo and open it as a project">+ from GitHub</button></div>';
+  for(const p of projects){
+    const mine=tasksById[p.id]||[];
+    const running=mine.filter(_live).length;
+    // turns = all-time count from the project thread.jsonl (p.taskCount). A "threads"
+    // count is intentionally NOT shown here: it was computed from _cached.tasks (a recent
+    // subset) while turns came from thread.jsonl (all-time) — incoherent. Threads-as-groups
+    // is shown IN the room where it's consistent; bring a count back (server-side, same
+    // source) once cross-agent hand-offs make multi-turn threads meaningful (Phase 3).
+    const turns=p.taskCount||mine.length||0;
+    const bits=[];
+    bits.push(turns+' turn'+(turns===1?'':'s'));
+    if(running) bits.push(running+' running');
+    if(p.totalCostCents>0) bits.push('$'+(p.totalCostCents/100).toFixed(2));
+    const ago=projAgo(p.lastActivityAt); if(ago) bits.push(ago);
+    const cwd=(p.cwd||(p.localPaths&&p.localPaths[0]))||'';
+    html+='<div class="goal-group'+(running?' running':'')+'"><div class="goal-head" tabindex="0" role="button" data-verify-unit="project" data-project-id="'+esc(p.id)+'" data-goal-cwd="'+encodeURIComponent(cwd)+'" onclick="event.stopPropagation();openRoom(\\''+encodeURIComponent(cwd)+'\\')" onkeydown="if(event.key===\\'Enter\\'||event.key===\\' \\'){event.preventDefault();openRoom(\\''+encodeURIComponent(cwd)+'\\')}">'
+      +'<span class="goal-title" data-user-content>'+esc(projName(p))+'</span>'
+      +'<span class="goal-meta">'+(partStack(p.recentAgents)?partStack(p.recentAgents)+' \\u00b7 ':'')+esc(bits.join(' \\u00b7 '))+' \\u00b7 open \\u203A</span></div></div>';
+  }
+  return html;
+}
+
+function renderL() {
+  const c=document.getElementById('task-list'), all=allS(_cached.tasks||{});
+  const esc=s=>String(s==null?'':s).replace(/[&<>"]/g,ch=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[ch]));
+  const fl=all.filter(FILTERS[_filter]||FILTERS.all);
+  let html='';
+  // Demo-shape sessions (id prefix 'demo-') render AFTER the real work —
+  // they demonstrate the product, but the home leads with YOUR story.
+  const demo=fl.filter(x=>/^demo-/.test(x.sessionId||''));
+  // S18 · practice runs (mockRun-stamped by the daemon under CODEHERE_MOCK)
+  // never sit among real work — they collapse behind their own quiet row
+  // beside the history expander. Same records, same showD detail: grouped,
+  // never deleted, never unreachable. Demo fixtures stay the FEATURED group.
+  const practice=fl.filter(x=>!/^demo-/.test(x.sessionId||'')&&x.mockRun);
+  const rest=fl.filter(x=>!/^demo-/.test(x.sessionId||'')&&!x.mockRun);
+  // cwd -> project title (from /api/projects); fall back to the folder name.
+  const projects=_cached.projects||[];
+  const titleFor=cwd=>{
+    if(!cwd) return 'Ungrouped';
+    const p=projects.find(x=>normC(x.cwd)===normC(cwd));
+    if(p&&p.title) return p.title;
+    const parts=String(cwd).split('/').filter(Boolean);
+    return parts.length?parts[parts.length-1]:'Ungrouped';
+  };
+  // S13 · TODAY = live tasks (any start day) + today's finished work, as
+  // ONE-LINE rows (direction E), live first then newest. EARLIER + the demo
+  // fixtures collapse behind the single history row; expanding keeps the S12
+  // goal groups (goal heads still open rooms, time-gaps + demo cards intact).
+  const _live=t=>['running','queued','paused','blocked'].includes(t.status);
+  const _sod=new Date(); _sod.setHours(0,0,0,0);
+  const _dayStart=_sod.getTime();
+  const chToday=rest.filter(t=>_live(t)||(t.startedAt||0)>=_dayStart);
+  chToday.sort((a,b)=>{ const la=_live(a)?1:0, lb=_live(b)?1:0; if(la!==lb) return lb-la; return (b.startedAt||0)-(a.startedAt||0); });
+  let chEarlier=rest.filter(t=>!_live(t)&&(t.startedAt||0)<_dayStart);
+  chEarlier.sort((a,b)=>(b.startedAt||0)-(a.startedAt||0));
+  const histN=chEarlier.length+demo.length;
+  if(chToday.length){
+    html+='<div class="section-label">Recent</div><div class="today-rows">'+groupByTitle(chToday).map(groupRowH).join('')+'</div>';
+  }
+  // Projects live in the persistent sidebar now; on the home pane the list is a
+  // duplicate (the confusion Ega flagged), so .home-projects is hidden on desktop
+  // and kept only for mobile (sidebar collapses) + the verify probe (display:none
+  // still matches querySelectorAll).
+  var _projHtml=projectListHtml(esc); // '' when there are no projects (keeps the first-run empty-state trigger alive)
+  if(_projHtml) html+='<div class="home-projects">'+_projHtml+'</div>';
+  // A returning user whose last work was before today would otherwise land on an
+  // EMPTY home — everything hidden behind this collapsed "earlier" row. So when
+  // there's nothing today, surface the recent work DIRECTLY (grouped by project),
+  // never a blank page. When there IS work today, keep "earlier" collapsible.
+  const _todayEmpty=!chToday.length;
+  if(histN){
+    if(_todayEmpty){
+      html+='<div class="section-label">Recent</div>';
+    } else {
+      html+='<button class="hist-row" onclick="toggleHist()" aria-expanded="'+(_histOpen?'true':'false')+'">earlier \\u00b7 '+histN+' run'+(histN===1?'':'s')+(_histOpen?' \\u00b7 collapse':' \\u00b7 expand \\u203A')+'</button>';
+    }
+  }
+  if(_histOpen||_todayEmpty){
+    const earlierTotal=chEarlier.length;
+    const earlierHidden=Math.max(0, earlierTotal-_earlierShown);
+    if(earlierHidden>0) chEarlier=chEarlier.slice(0,_earlierShown);
+    if(chEarlier.length){
+      html+=goalGroupsHtml(chEarlier, titleFor, esc);
+      if(earlierHidden>0){
+        html+='<button class="show-earlier" onclick="showEarlier()">show earlier work ('+earlierHidden+' more)</button>';
+      }
+    }
+    if(demo.length){
+      html+='<div class="section-label featured">Featured \\u00b7 demo</div>';
+      for(const t of demo) html+=cardH(t);
+    }
+  }
+  practice.sort((a,b)=>(b.startedAt||0)-(a.startedAt||0));
+  html+=pracGroupHtml(practice);
+  if(!html){
+    if(_filter==='all'){
+      // First-run onboarding: what codehere is, the coding agents detected on THIS
+      // machine (the cross-vendor lineup is the whole point), and a one-click first
+      // task. Genuine first run only (no tasks, no projects).
+      html='<div class="empty-state onboarding">'
+        +'<h2>Welcome to codehere</h2>'
+        +'<p class="ob-lede">Running locally. No account, nothing leaves your machine. Two steps to your first verified task:</p>'
+        +'<div class="ob-cta"><button class="ob-tourbtn" onclick="startTour()">Take the 30-second tour \\u2192</button></div>'
+        +'<div class="ob-step"><span class="ob-num">1</span><div class="ob-b"><div class="ob-h">Your agents</div>'+obAgentsHtml()+'</div></div>'
+        +'<div class="ob-step"><span class="ob-num">2</span><div class="ob-b"><div class="ob-h">Start a task</div>'
+          +'<div class="ob-ex">'
+          +'<button class="ex-prompt" data-ex="Review the code in this project for bugs and security issues, and tell me what to fix" onclick="exFill(this.dataset.ex)">Review my code for bugs</button>'
+          +'<button class="ex-prompt" data-ex="Explain how this project is structured and what the main parts do" onclick="exFill(this.dataset.ex)">Explain this codebase</button>'
+          +'<button class="ex-prompt" data-ex="Add a test for the most important function in this project and make it pass" onclick="exFill(this.dataset.ex)">Write a test</button>'
+          +'</div>'
+          +'<div class="ex-gh">Working on a repo on GitHub? <button class="add-gh" onclick="openClone()">+ from GitHub</button></div>'
+        +'</div></div>'
+      +'</div>';
+    } else {
+      const h={running:'No running tasks.',done:'No completed tasks.',failed:'No failed tasks.'};
+      html='<div class="empty-state"><h2>'+(h[_filter]||'No tasks found.')+'</h2></div>';
+    }
+  }
+  // S12 · morph, never wipe — zero hover/scroll/focus loss on the poll.
+  morphInto(c, html);
+}
+
+${TOUR}
+${ONBOARDING}
+${GITHUB_INTEGRATION}
+
+${OBSERVER_RAIL}
+
+// It-4 V1-MULTITASK + V1-FANOUT-ALL · render one batch (siblings sharing a
+// batchId) as a derived-live rollup header + a side-by-side fanout grid.
+// Counts are computed from the child records on EVERY render — never stored —
+// so a daemon crash mid-run reads "running", not a stale "done" (the plan's
+// honesty constraint). Each grid column reuses cardH so a column is a real
+// turn card labelled with the real adapter chip; a not-ready adapter is simply
+// absent (it never got a child), never a faked column.
+function batchH(sibs){
+  const isDone=x=>x.status==='completed'||x.status==='done';
+  const isRun=x=>['running','queued','paused','blocked'].includes(x.status);
+  const isFail=x=>['error','killed','crashed','failed'].includes(x.status);
+  const n=sibs.length, done=sibs.filter(isDone).length, run=sibs.filter(isRun).length, fail=sibs.filter(isFail).length;
+  const parts=[done+' done'];
+  if(run>0) parts.push(run+' running');
+  if(fail>0) parts.push(fail+' failed');
+  let html='<div class="project-rollup"><span class="rollup-icon">&#8801;</span>'
+    +'<span class="rollup-count">'+n+' sub-task'+(n===1?'':'s')+'</span>'
+    +'<span class="rollup-sep">\\u00b7</span><span class="rollup-stat">'+parts.join(' \\u00b7 ')+'</span>'
+    +'<span class="rollup-note">sent to every ready agent</span></div>';
+  // Fanout grid · one column per child, sorted by adapter for a stable order.
+  const ordered=[...sibs].sort((a,b)=>String(a.agent||'').localeCompare(String(b.agent||'')));
+  html+='<div class="fanout-all">';
+  for(const t of ordered){
+    html+='<div class="fanout-col"><div class="fanout-col-head">'+ab(t.agent,'sm')+agentLabel(t.agent)+'</div>'+cardH(t)+'</div>';
+  }
+  html+='</div>';
+  return html;
+}
+// S12 · ONE story-arc line per card, derived from REAL data only — steps
+// count, verdict status, failover lineage, a caught contradiction when
+// tests.claimed disagrees with the observed counts. No real arc data -> ''
+// (the existing meta stays); we never invent narrative.
+function cardArc(t){
+  const he=s=>String(s==null?'':s).replace(/[&<>"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]));
+  const steps=t.steps||[];
+  if(['running','queued','paused','blocked'].includes(t.status)){
+    if(!steps.length) return '';
+    const last=steps[steps.length-1];
+    return '<div class="card-arc">Now: <span data-user-content>'+compactLabel(last.label||last.tool||'')+'</span> \\u00b7 step '+steps.length+'</div>';
+  }
+  const parts=[];
+  if(t.failoverFrom&&t.failoverTo) parts.push('<span class="wr">recovered from '+he(agentLabel(t.failoverFrom))+'</span>');
+  const tests=t.artifacts&&t.artifacts.tests;
+  const vr=t.verdict&&t.verdict.claim;
+  const passed=tests?(tests.passed||0):0, failed=tests?(tests.failed||0):0;
+  const cl=tests&&tests.claimed;
+  const caught=!!(cl&&((cl.passed!==passed)||(cl.failed!==failed)));
+  const isFail=['failed','error','crashed','killed'].includes(t.status);
+  if(caught){
+    parts.push('<span class="wr">verifier caught a claimed '+cl.passed+'/'+(cl.passed+cl.failed)+'</span> \\u203A re-ran \\u203A '+passed+'/'+(passed+failed));
+  } else if(isFail && failed>0){
+    parts.push('<span class="wr">verifier found '+failed+' red test'+(failed===1?'':'s')+' \\u00b7 left unmerged</span>');
+  } else if(vr&&vr.status==='broken'){
+    parts.push('<span class="wr">claim contradicts reality \\u00b7 caught by the verifier</span>');
+  } else if(vr&&vr.status==='verified'&&!isFail&&tests&&tests.observed){
+    parts.push('<span class="ok">verifier re-ran the tests \\u203A '+passed+'/'+(passed+failed)+' \\u2713</span>');
+  }
+  if(!parts.length) return '';
+  const lead=steps.length?steps.length+' step'+(steps.length===1?'':'s')+' \\u203A ':'';
+  return '<div class="card-arc">'+lead+parts.join(' \\u00b7 ')+'</div>';
+}
+function cardH(t) {
+  // Unified card (2026-06-20): every card — today, history, demo, fanout — uses
+  // the SAME .tcard render as the home rows, so the product never shows two card
+  // styles. Preserve the demo pin marker (the F-PIN-DEMO coverage selector
+  // .task-card.tc-pinned).
+  var h = rowH(t);
+  if(/^demo-/.test(t.sessionId||'')) h = h.replace('class="task-card tcard', 'class="task-card tcard tc-pinned');
+  return h;
+}
+
+// S13 · ONE-line row (direction E): status dot+word · title · agent (mono,
+// no rainbow) · checks · cost. Keeps the task-card class + tabindex/Enter +
+// the stop control + the agent-* class — harness selectors + the morph rely
+// on them. Verified green ONLY through the same gate heroCounts uses (S12).
+// S20 fix · ONE verdict precedence for every row-level derivation. This is
+// the canonical detail verdictLine order (practice first, then the gated
+// verified branches, then broken) extended with the row-only states the
+// detail never renders (stalled, live, terminal-unclean, done). rowStatus,
+// rowClaims and outcomeSentence all read THIS state, never their own branch
+// order — before this, each hand-rolled its own precedence and the same
+// mock+broken record wore a different verdict word per lens.
+function verdictState(t){
+  const claim=(t.verdict&&t.verdict.claim&&t.verdict.claim.status)||'';
+  const live=['running','queued','paused','blocked'].includes(t.status);
+  const unclean=['failed','error','crashed','killed'].includes(t.status);
+  const doneSt=['completed','done'].includes(t.status);
+  const noGit=!!(t.artifacts&&t.artifacts.noGitTracking);
+  if(t.mockRun&&!live) return 'practice';
+  if(claim==='verified'&&doneSt&&!noGit) return 'verified';
+  if(claim==='verified'&&doneSt&&noGit) return 'partial';
+  if(claim==='broken') return 'caught';
+  if(t.stalledReason) return 'stalled';
+  if(live) return 'live';
+  if(unclean) return 'stopped';
+  if(doneSt) return 'done';
+  return 'unknown';
+}
+function rowStatus(t){
+  switch(verdictState(t)){
+    case 'verified': return {cls:'verified',word:'Verified'};
+    case 'caught': return {cls:'caught',word:'Caught'};
+    case 'stalled': return {cls:'stalled',word:'Stalled'};
+    case 'live':
+      if(t.status==='running') return {cls:'running',word:'Running'};
+      if(t.status==='queued') return {cls:'running',word:'Queued'};
+      return {cls:'running',word:'Paused'};
+    case 'stopped': return {cls:'stopped',word:'Stopped'};
+    case 'practice':
+      // Default vocabulary stays run-status (the practice group already names
+      // the mode; the detail's verdict word is Practice) — but a practice
+      // verdict NEVER wears Caught/Verified: a mock run fabricated its own
+      // artifacts, so a verdict word here would contradict the detail.
+      if(t.stalledReason) return {cls:'stalled',word:'Stalled'};
+      if(['failed','error','crashed','killed'].includes(t.status)) return {cls:'stopped',word:'Stopped'};
+      return {cls:'done',word:'Done'};
+    case 'partial': return {cls:'done',word:'Done'};
+    case 'done': return {cls:'done',word:'Done'};
+    default: return {cls:'done',word:String(t.status||'?')};
+  }
+}
+function rowH(t){
+  // S20 · Status lens: the row IS the outcome sentence (template branch).
+  if(curLens()==='status') return statusRowH(t);
+  const rs=rowStatus(t);
+  const agentClass='agent-'+String(t.agent||'').toLowerCase().replace(/[^a-z0-9]/g,'-');
+  const live=['running','queued','paused','blocked'].includes(t.status);
+  const tests=t.artifacts&&t.artifacts.tests;
+  const passed=tests?(tests.passed||0):0, failed=tests?(tests.failed||0):0, total=passed+failed;
+  const co=(t.cost&&typeof t.cost.spent==='number')?'$'+(t.cost.spent/100).toFixed(2):'';
+  const nf=(t.artifacts&&t.artifacts.files&&t.artifacts.files.length)||0;
+  // the status stat-pill carries the HONEST verdict word (rowClaims) — green ✓
+  // ONLY when verified, never a fake ✓ for a stopped/caught/partial run. Live
+  // gets the run pulse. This keeps the H15 honesty contract across both lenses.
+  const vs=verdictState(t);
+  // 2.2 honesty gate — IDENTICAL to the detail headline + summary tile: a green
+  // ✓ verified ONLY when the composite grade confirms an INDEPENDENT signal.
+  // A self-reported run (grade present but not green) reads '○ reported', never
+  // a green check. Legacy/seeded verdicts with no grade keep the claim check.
+  const _graded=t.verdict&&t.verdict.grade;
+  const _green=vs==='verified'&&(_graded?!!t.verdict.grade.green:true);
+  var pill;
+  if(live){ pill='<span class="tc-stat run"><span class="tc-pulse"></span>'+rs.word+'</span>'; }
+  else if(_green){ pill='<span class="tc-stat ok">\\u2713 verified'+(total>0?' '+passed+'/'+total:'')+'</span>'; }
+  else if(vs==='verified'){ pill='<span class="tc-stat neutral">\\u25CB reported</span>'; }
+  else { var cl=rowClaims(t); var pc=(vs==='caught'?'fail':'neutral'); pill='<span class="tc-stat '+pc+'">'+cl.word+'</span>'; }
+  // meta line: the vendor + what it touched (mockup: "Claude Code · 3 files")
+  var meta='<span class="tc-vendor">'+agentLabel(t.agent)+'</span>'+(nf?' \\u00b7 '+nf+' file'+(nf===1?'':'s'):'');
+  const stop=live?'<button class="card-stop" data-verify-action="stop" title="Stop this agent now" aria-label="Stop this agent now" onclick="stopTask(event,\\''+t.sessionId+'\\')">\\u25A0 stop</button>':'';
+  return '<div class="task-card tcard '+agentClass+(live?' active':'')+'" tabindex="0" role="button" onclick="showD(\\''+t.sessionId+'\\')">'
+    +'<span class="tc-av">'+ab(t.agent)+'</span>'
+    +'<div class="tc-body"><div class="tc-title" data-user-content title="'+convHe(displayPrompt(t.prompt)).slice(0,400)+'">'+convHe(title(t.prompt))+'</div>'
+    +'<div class="tc-meta">'+meta+'</div></div>'
+    +'<div class="tc-glyphs">'+pill+(co?'<span class="tc-cost">'+co+'</span>':'')+stop+'<span class="tc-arrow">\\u203A</span></div>'
+    +'</div>';
+}
+
+// S21 · thread grouping — runs of the SAME task (same title) collapse into one
+// thread: the newest run is the head card, older runs nest below as compact rows.
+// Every run keeps its own showD(sessionId) target (one-click record, and the e2e
+// sid selectors still resolve). A single-run task renders exactly as before.
+function groupByTitle(items){
+  const map=new Map();
+  // Same guards as threadGroups (cold-review P2): Untitled tasks never merge
+  // (each keys on its own sessionId) and the key is cwd-scoped so same-title
+  // tasks from different projects stay separate threads.
+  for(const t of items){ const tt=title(t.prompt); const k=(tt&&tt!=='Untitled')?(String(t.cwd||'')+'\\u0000'+tt):('sid:'+String(t.sessionId||'')); if(!map.has(k)) map.set(k,[]); map.get(k).push(t); }
+  const groups=[];
+  for(const pair of map){ const runs=pair[1]; runs.sort((a,b)=>(b.startedAt||0)-(a.startedAt||0)); groups.push(runs); }
+  groups.sort((a,b)=>(b[0].startedAt||0)-(a[0].startedAt||0));
+  return groups;
+}
+function _runRowH(r){ const rc=rowClaims(r); const co=(r.cost&&typeof r.cost.spent==='number')?'$'+(r.cost.spent/100).toFixed(2):'\\u2014';
+  const sid=String(r.sessionId||'').replace(/[^A-Za-z0-9._:-]/g,'');
+  return '<div class="task-run" tabindex="0" role="button" onclick="showD(\\''+sid+'\\')"><span class="tr-who">'+convHe(agentLabel(r.agent))+'</span><span class="tr-st st-'+rc.cls+'">'+convHe(rc.word)+'</span><span class="tr-c">'+co+'</span></div>'; }
+function _threadWrap(headHtml, runs){
+  let cents=0; for(const r of runs){ if(r.cost&&typeof r.cost.spent==='number') cents+=r.cost.spent; }
+  const tot=cents?'$'+(cents/100).toFixed(2):'';
+  return '<div class="task-thread">'+headHtml
+    +'<div class="task-runs"><div class="tr-more">'+runs.length+' runs \\u00b7 '+tot+'</div>'+runs.slice(1).map(_runRowH).join('')+'</div>'
+    +'</div>';
+}
+function groupRowH(runs){ return runs.length===1?rowH(runs[0]):_threadWrap(rowH(runs[0]), runs); }
+function groupCardH(runs){ return runs.length===1?cardH(runs[0]):_threadWrap(cardH(runs[0]), runs); }
+
+// ── S20 · lenses: claims-state word + honest outcome sentence ──────────────
+// rowClaims = the Review lead. outcomeSentence = the Status line, built ONLY
+// from recorded verdict/status/stall facts (the S13 story-arc rule — no real
+// data, no narrative). BOTH derive from verdictState above — one precedence,
+// one truth per record, only the vocabulary differs per lens. A stopped or
+// stalled run wears the same word family as the default lens (stopped, never
+// a failure word the default lens does not claim).
+function rowClaims(t){
+  switch(verdictState(t)){
+    case 'practice': return {cls:'done',word:'\\u25CB practice'};
+    case 'verified': return {cls:'verified',word:'\\u2713 verified'};
+    case 'partial': return {cls:'done',word:'\\u25CB partial'};
+    case 'caught': return {cls:'caught',word:'\\u2715 caught'};
+    case 'stalled': return {cls:'stopped',word:'\\u25A0 stalled'};
+    case 'live': return {cls:'running',word:'\\u25CF unchecked'};
+    case 'stopped': return {cls:'stopped',word:'\\u25A0 stopped'};
+    default: return {cls:'done',word:'\\u25CB unverified'};
+  }
+}
+function outcomeSentence(t){
+  switch(verdictState(t)){
+    case 'practice': return 'practice run \\u00b7 wiring only';
+    case 'verified': return 'verified \\u00b7 claims match reality';
+    case 'partial': return 'done \\u00b7 partly verified \\u00b7 not a git repo';
+    case 'caught': return 'caught \\u00b7 the claim contradicted the record';
+    case 'stalled': return 'did not finish \\u00b7 stopped for going silent';
+    case 'live': return t.status==='running'?'in progress':String(t.status);
+    case 'stopped': return 'did not finish \\u00b7 '+String(t.status);
+    case 'done': return 'done \\u00b7 unverified';
+    default: return String(t.status||'unknown');
+  }
+}
+// Status-lens row: title + the outcome sentence + spend. Keeps the
+// .task-card/.trow contract (tabindex, Enter, agent-* class, stop, pin).
+function statusRowH(t){
+  const agentClass='agent-'+String(t.agent||'').toLowerCase().replace(/[^a-z0-9]/g,'-');
+  const pinClass=/^demo-/.test(t.sessionId||'')?' tc-pinned':'';
+  const live=['running','queued','paused','blocked'].includes(t.status);
+  const stop=live?'<button class="card-stop" data-verify-action="stop" title="Stop this agent now" aria-label="Stop this agent now" onclick="stopTask(event,\\''+t.sessionId+'\\')">\\u25A0 stop</button>':'';
+  const co=(t.cost&&typeof t.cost.spent==='number')?'<span class="row-meta">$'+(t.cost.spent/100).toFixed(2)+'</span>':'';
+  return '<div class="task-card trow srow '+agentClass+pinClass+'" tabindex="0" role="button" onclick="showD(\\''+t.sessionId+'\\')">'
+    +'<span class="row-title" data-user-content title="'+displayPrompt(t.prompt).replace(/"/g,'&quot;').slice(0,400)+'">'+titleH(t.prompt)+'</span>'
+    +'<span class="row-outcome">'+outcomeSentence(t)+'</span>'
+    +co
+    +stop
+    +'</div>';
+}
+
+// ── S13 · NEEDS YOUR DECISION — the only orange on the page ────────────────
+// Derived from REAL state on every render: (a) pending W-PASS intents (the
+// same /api/writepass/pending list the modal polls — window._wpPendingAll),
+// (b) tasks whose claim the verifier BROKE today, (c) today's failed/killed
+// runs with the original prompt recorded (Retry can respawn them). Empty ->
+// the section does not render at all; H14 pins absent <=> N===0.
+function decisionItems(){
+  // S18 · PAIRED with verify-page H14's expected-derivation (dAll filter):
+  // a practice (mockRun) failure never demands a real decision. Change BOTH
+  // sides identically (the honest-rule update), never one side alone.
+  const all=allS(_cached.tasks||{}).filter(t=>!/^demo-/.test(t.sessionId||'')&&!t.mockRun);
+  const sod=new Date(); sod.setHours(0,0,0,0);
+  const ds=sod.getTime();
+  const today=t=>(t.startedAt||0)>=ds;
+  const passes=window._wpPendingAll||[];
+  const broken=all.filter(t=>today(t)&&t.verdict&&t.verdict.claim&&t.verdict.claim.status==='broken');
+  const failed=all.filter(t=>today(t)&&['failed','error','crashed','killed'].includes(t.status)
+    &&t.prompt&&!(t.verdict&&t.verdict.claim&&t.verdict.claim.status==='broken'));
+  return {passes,broken,failed,n:passes.length+broken.length+failed.length};
+}
+function renderDecisions(){
+  const c=document.getElementById('decision-queue');
+  if(!c) return;
+  const he=s=>String(s==null?'':s).replace(/[&<>"]/g,ch=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[ch]));
+  const d=decisionItems();
+  if(_room||d.n===0){
+    c.style.display='none'; c.innerHTML='';
+    c.removeAttribute('data-verify-unit'); c.removeAttribute('data-verify-decisions-n');
+    return;
+  }
+  c.style.display='block';
+  c.setAttribute('data-verify-unit','decisions');
+  c.setAttribute('data-verify-decisions-n', String(d.n));
+  // Exactly ONE filled button on the screen: the first row's primary.
+  let first=true;
+  const btn=(act,label,kbd,onclick,fill)=>'<button class="dq-btn'+(fill?' fill':(act==='deny'||act==='retry')?' quiet':'')+'" data-act="'+act+'" onclick="'+onclick+'">'+label+' <span class="kbd">'+kbd+'</span></button>';
+  let rows='';
+  for(const p of d.passes){
+    const it=p.intent||{};
+    rows+='<div class="dq-row" tabindex="0" data-kind="pass">'
+      +'<div class="dq-what"><div class="dq-t"><span class="dq-id">W-PASS</span>'+he(it.emittedBy||'an agent')+' wants to write: <span data-user-content>'+he((it.method||'')+' '+(it.target||''))+'</span></div>'
+      +'<div class="dq-why">external write \\u00b7 gated by codehere'+(it.reason?' \\u00b7 <span data-user-content>'+he(String(it.reason).slice(0,140))+'</span>':'')+'</div>'
+      +'<div class="dq-result" style="display:none"></div></div>'
+      +'<div class="dq-acts">'
+      +btn('approve','Approve','A',"wpQueueDecide('"+he(it.id)+"','approve',this)",first)
+      +btn('deny','Deny','X',"wpQueueDecide('"+he(it.id)+"','cancel',this)",false)
+      +'</div></div>';
+    first=false;
+  }
+  for(const t of d.broken){
+    rows+='<div class="dq-row" tabindex="0" data-kind="broken">'
+      +'<div class="dq-what"><div class="dq-t">'+agentLabel(t.agent)+' says it\\u2019s done. The verifier disagrees.</div>'
+      +'<div class="dq-why"><span data-user-content>'+titleH(t.prompt)+'</span> \\u00b7 the claim contradicts recorded reality \\u00b7 left for your call</div></div>'
+      +'<div class="dq-acts">'+btn('review','Review','\\u23CE',"showD('"+he(t.sessionId)+"')",first)+'</div></div>';
+    first=false;
+  }
+  // Collapse identical failed attempts (same prompt+cwd+agent) into ONE row — a
+  // Retry that re-fails (e.g. a rate-limited agent) shouldn't stack duplicate
+  // decision rows. One row per distinct failure, with the attempt count; the
+  // latest attempt drives Review/Retry.
+  const _fg=[], _fk={};
+  for(const t of d.failed){
+    const k=(t.prompt||'')+'|'+(t.cwd||'');
+    if(_fk[k]!==undefined){ const g=_fg[_fk[k]]; g.count++; if(g.agents.indexOf(t.agent)<0) g.agents.push(t.agent); if((t.startedAt||0)>(g.t.startedAt||0)) g.t=t; }
+    else { _fk[k]=_fg.length; _fg.push({t:t,count:1,agents:[t.agent]}); }
+  }
+  for(const g of _fg){ const t=g.t;
+    const who=g.agents.map(a=>agentLabel(a)).join(', ');
+    rows+='<div class="dq-row" tabindex="0" data-kind="failed">'
+      +'<div class="dq-what"><div class="dq-t"><span data-user-content>'+titleH(t.prompt)+'</span> didn\\u2019t finish.</div>'
+      +'<div class="dq-why">'+who+' \\u00b7 '+he(t.stalledReason||t.status)+(g.count>1?' \\u00b7 '+g.count+' attempts':'')+' \\u00b7 Retry respawns the same prompt fresh</div></div>'
+      +'<div class="dq-acts">'+btn('review','Review','\\u23CE',"showD('"+he(t.sessionId)+"')",first)
+      +btn('retry','Retry','R',"recoverRetry('"+he(t.sessionId)+"')",false)+'</div></div>';
+    first=false;
+  }
+  // Kicker counts the actionable ROWS shown (failures collapsed by attempt), not
+  // raw attempts — so "· N" always matches what's on screen. (The verify
+  // attribute above keeps d.n, the raw count, for the H14 contract.)
+  c.innerHTML='<div class="dq-kicker">Needs your decision <span class="cnt">\\u00b7 '+(d.passes.length+d.broken.length+_fg.length)+'</span></div>'+rows;
+}
+
+function upBud() {
+  const p=_cached.pricing||_cached.tasks?.pricing;
+  const e=document.getElementById('budget');
+  const banner=document.getElementById('budget-banner');
+  const bwhat=document.getElementById('budget-banner-what');
+  const bmsg=document.getElementById('budget-banner-msg');
+  if(!p||!p.dailyBudgetCents){
+    e.textContent='';e.className='budget';
+    if(banner) banner.style.display='none';
+    return;
+  }
+  const d=p.dailyBudgetCents,s=p.spentTodayCents||0;
+  e.textContent=' \\u00b7 $'+(s/100).toFixed(2)+' / $'+(d/100).toFixed(2);
+  e.className='budget'+(s>=d?' block':s>=d*0.8?' warn':' safe');
+  const ib=document.querySelector('.input-bar');
+  if(ib){ib.className='input-bar'+(s>=d?' block':s>=d*0.8?' warn':'');}
+  // F-01 · budget threshold banner · only shows when crossing 80%
+  if(banner && bwhat && bmsg){
+    if(s>=d){
+      banner.style.display='block';
+      banner.className='budget-banner block';
+      bwhat.textContent='budget exhausted';
+      bmsg.textContent='daily cap $'+(d/100).toFixed(2)+' spent · paid spawns will block until tomorrow.';
+    } else if(s>=d*0.8){
+      banner.style.display='block';
+      banner.className='budget-banner';
+      bwhat.textContent='budget threshold';
+      bmsg.textContent='$'+(s/100).toFixed(2)+' of $'+(d/100).toFixed(2)+' spent today · paid spawns require confirm.';
+    } else {
+      banner.style.display='none';
+    }
+  }
+}
+
+// Map readiness state -> dot class. 'setup' is distinct from 'busy': busy means
+// actively working a task, setup means installed/known but can't run until the
+// user does something (auth, key, install). Conflating them was a screen lie —
+// a dead-without-setup agent looked like it was working (dogfood 2026-05-27 #4).
+// S13: the squad strip died; this readiness map feeds the ⌘K Agents command.
+function agentS(state){if(!state||state==='error')return'offline';if(state==='installed'||state==='ready')return'ready';if(state==='needs_install'||state==='needs_auth'||state==='billed_key_required')return'setup';return'busy';}
+
+// S13 · filters live in ⌘K; the active filter shows as ONE removable token
+// above the list (never a tab bar).
+function setFilter(f){
+  _filter=f;
+  const tk=document.getElementById('filter-token');
+  if(tk){
+    if(f==='all'){ tk.style.display='none'; tk.innerHTML=''; }
+    else { tk.style.display='block'; tk.innerHTML='<span class="ftoken">filter: '+f+' <span class="x" role="button" tabindex="0" aria-label="Clear filter" title="clear \\u00b7 back to everything" onclick="setFilter(\\'all\\')">\\u00d7</span></span>'; }
+  }
+  if(_cached.tasks)render();
+}
+
+// URL-sync (eng-review 2026-07-03, D3) — hash deep-link so /#/task/:id is unique,
+// bookmarkable, and the back-button works. SINGLE-MACHINE by design: session ids
+// aren't portable across daemons (the record travels by signed bundle, not this
+// link), so this is DX + a foundation, not team-share. The URL is a PROJECTION:
+// written only in the mutators (showD/hideD), hydrated on load + hashchange.
+// render() NEVER reads it — reading it per-frame would re-introduce the
+// poll-render-wipe class the sweep fixed. String-only (no regex: template literal).
+function _hashForDetail(){ return _detail ? ('#/task/'+encodeURIComponent(_detail)) : ''; }
+// The URL spine (nav option A, Ega-approved 2026-07-06): rooms and the Spend
+// page get hashes too, so refresh / back / forward always land where you were.
+// Same projection rule as tasks: mutators write the hash, hydration reads it,
+// render() never touches it. Room ids prefer the project SLUG (short, stable);
+// a raw cwd is accepted on read as the fallback.
+function _roomHash(){
+  if(!_room) return '';
+  var p=(_cached.projects||[]).find(function(x){ return projPaths(x).indexOf(normC(_room))>=0; });
+  return '#/room/'+encodeURIComponent(p&&p.slug?p.slug:_room);
+}
+function _spendVisible(){ var sv=document.getElementById('spend-view'); return !!(sv&&sv.style.display==='block'); }
+function _routeFromHash(){
+  var h=location.hash||'', pfx='#/task/', rfx='#/room/';
+  if(h.indexOf(pfx)===0){
+    var id=decodeURIComponent(h.slice(pfx.length));
+    if(!id || id===_detail) return;
+    if(typeof findS==='function' && findS(id)) showD(id);
+    // Unresolvable id → say so. Silently keeping the previous screen under a
+    // hash that names a different task showed the WRONG task to anyone opening
+    // a shared link (verify-distill loop-2 find, confirmed on both builds).
+    else showTaskNotFound(id);
+  } else if(h.indexOf(rfx)===0){
+    var key=decodeURIComponent(h.slice(rfx.length));
+    if(!key) return;
+    var p=(_cached.projects||[]).find(function(x){ return x.slug===key; })
+      ||(_cached.projects||[]).find(function(x){ return projPaths(x).indexOf(normC(key))>=0; });
+    var cwd=p?(p.cwd||projPaths(p)[0]):(key.indexOf('/')===0?key:null);
+    if(!cwd){
+      // Unknown project id → say so and land home (leaving whatever screen was
+      // up under an empty hash is the same state-drift the spine kills).
+      al('No project with this id here.');
+      try{ history.replaceState(null,'',location.pathname+location.search); }catch(e){}
+      if(_detail||document.body.classList.contains('detail-open')) hideD();
+      if(_spendVisible()){ document.getElementById('spend-view').style.display='none'; document.getElementById('task-list-view').style.display=''; }
+      if(_room) closeRoom();
+      return;
+    }
+    // Widened gates here + below (ship-review catch): the not-found screen
+    // nulls _detail with the container visible — Back/Today must clear it too.
+    if(_detail||document.body.classList.contains('detail-open')) hideD();
+    if(normC(_room)!==normC(cwd)) openRoom(encodeURIComponent(cwd));
+  } else if(h==='#/spend'){
+    if(!_spendVisible()) showSpend();
+  } else {
+    if(_detail||document.body.classList.contains('detail-open')) hideD();
+    if(_spendVisible()){ document.getElementById('spend-view').style.display='none'; document.getElementById('task-list-view').style.display=''; renderSidebar(); }
+    if(_room) closeRoom();
+  }
+}
+// Honest dead-link state (reuses the .empty-state treatment — no new class).
+// Plain about WHY the id can miss: this view loads recent + opened-room tasks
+// only, and session ids aren't portable across machines (the URL-sync design
+// note above). The one real affordance is the way back.
+function showTaskNotFound(id){
+  _detail=null;
+  if(_ctlPoll){ clearInterval(_ctlPoll); _ctlPoll=null; } _ctlId=null; // stop polling the task we navigated away from (ship-review catch)
+  document.getElementById('task-list-view').style.display='none';
+  document.getElementById('task-detail-view').style.display='block';
+  var _sv=document.getElementById('spend-view'); if(_sv) _sv.style.display='none';
+  document.body.classList.add('detail-open');
+  var dv=document.getElementById('detail-view');
+  dv.setAttribute('data-sid','');
+  dv.innerHTML='<div class="detail-header"><span class="back-btn" onclick="hideD()">\\u2190 back \\u00b7 <span class="kbd">Esc</span></span></div>'
+    +'<div class="empty-state" data-verify-unit="task-not-found"><h2>No task with this id here.</h2>'
+    +'<p style="color:var(--fg-50);font-size:13px;margin-top:6px" data-user-content>'+String(id).slice(0,80).replace(/[&<>"]/g,function(c){return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c];})
+    +'</p><p style="color:var(--fg-40);font-size:12px;margin-top:10px">It may live in a project\\u2019s older history (open that project first), or on another machine \\u2014 task links don\\u2019t travel between daemons; the signed record does.</p></div>';
+}
+if(typeof window!=='undefined') window.addEventListener('hashchange', _routeFromHash);
+function showD(id){
+  if(id!==_detail){ _artOpen=false; _stepOpen={}; _receiptOpen={}; _glMoreOpen={}; } // a different task starts with drawer closed + collapsed receipt + no step expansions carried over
+  _detail=id;
+  try{ var _h=_hashForDetail(); if(location.hash!==_h) location.hash=_h; }catch(e){} // project state → URL (not the reverse)
+  const t=findS(id);
+  if(!t){_detail=null;return;}
+  document.getElementById('task-list-view').style.display='none';
+  document.getElementById('task-detail-view').style.display='block';
+  var _sv2=document.getElementById('spend-view'); if(_sv2) _sv2.style.display='none';
+  // R10 fix · when detail-view opens, hide the global main composer so the
+  // detail-view follow-up composer ("Ask a follow-up about this task...")
+  // is the ONLY input visible. Pre-fix · BOTH composers rendered stacked,
+  // both with "-> Auto · ~$0.02" chips · user couldn't tell which one
+  // typed to which target. Surfaced 2026-05-24 by Ega.
+  document.body.classList.add('detail-open');
+  renderD(t);
+  try{ updateCostEst(); }catch(e){}
+}
+function hideD(){
+  _detail=null;
+  // Leaving a task lands in the room (when one is open) — the URL says so too.
+  try{
+    var _h0=location.hash||'';
+    if(_h0.indexOf('#/task/')===0||_h0==='#/spend'){
+      var _rh=_roomHash();
+      if(_rh){ if(_h0!==_rh) location.hash=_rh; }
+      else history.replaceState(null,'',location.pathname+location.search);
+    }
+  }catch(e){}
+  if(_ctlPoll){ clearInterval(_ctlPoll); _ctlPoll=null; } _ctlId=null; // stop control polling
+  document.getElementById('task-list-view').style.display='';
+  document.getElementById('task-detail-view').style.display='none';
+  var _sv=document.getElementById('spend-view'); if(_sv) _sv.style.display='none';
+  document.body.classList.remove('detail-open');
+  render();
+}
+// Spend & Audit page: the team cost+audit ledger as its own destination (nav tab),
+// not a banner on the workspace. Loaded on demand from /api/team.
+function showSpend(){
+  // Spend is a top-level place — entering it ENDS the room/detail context
+  // (loop-7 verifier catch: without this the project row stayed .active
+  // beside Spend's .here — two you-are-heres — and _detail went stale).
+  if(_detail) hideD();
+  if(_room) closeRoom();
+  document.getElementById('task-list-view').style.display='none';
+  document.getElementById('task-detail-view').style.display='none';
+  document.body.classList.remove('detail-open');
+  var sv=document.getElementById('spend-view'); if(sv) sv.style.display='block';
+  try{ if(location.hash!=='#/spend') location.hash='#/spend'; }catch(e){}
+  try{ renderSidebar(); }catch(e){} // the rail's you-are-here follows
+  try{ renderTeamHero(); }catch(e){}
+}
+
+// Open an observed host session as a THREAD · the meta-dogfood payoff: the
+// coding-agent session running in your own terminal, with every tool call
+// codehere scanned, in order, hash-chained.
+async function showHostSession(shortId){
+  _detail='host:'+shortId;
+  document.getElementById('task-list-view').style.display='none';
+  document.getElementById('task-detail-view').style.display='block';
+  document.body.classList.add('detail-open');
+  const dv=document.getElementById('detail-view');
+  dv.innerHTML='<div class="detail-header"><span class="back-btn" onclick="hideD()">\\u2190 Back</span></div><div style="color:var(--fg-40);font-size:12px;padding:20px 0">loading observed session...</div>';
+  let d;
+  try{ d=await fetch('/api/host-sessions/'+encodeURIComponent(shortId)).then(x=>x.json()); }
+  catch(e){ dv.innerHTML='<div class="detail-header"><span class="back-btn" onclick="hideD()">\\u2190 Back</span></div><div style="color:var(--caught);padding:20px 0">Could not load session.</div>'; return; }
+  if(!d||d.error){ dv.innerHTML='<div class="detail-header"><span class="back-btn" onclick="hideD()">\\u2190 Back</span></div><div style="color:var(--fg-40);padding:20px 0">'+he(d&&d.error||'No such session')+'</div>'; return; }
+  function he(s){ return String(s).replace(/[&<>"]/g, c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c])); }
+  function ago(ts){ const m=Math.floor((Date.now()-new Date(ts).getTime())/60000); if(m<1)return'just now'; if(m<60)return m+'m ago'; const h=Math.floor(m/60); if(h<24)return h+'h ago'; return Math.floor(h/24)+'d ago'; }
+  function clock(ts){ try{ return new Date(ts).toLocaleTimeString([], {hour:'2-digit',minute:'2-digit',second:'2-digit'}); }catch{return'';} }
+  const calls=d.calls||[];
+  // Tool-call timeline · one row per observed call · time · tool · preview · state
+  // No phase narrative here · raw terminal tool calls don't carry lifecycle
+  // semantics (a dev session building codehere mentions "audit"/"build"/"test"
+  // as domain words, so the classifier lies). Phases are a spawned-task concept.
+  // Instead, group calls by tool so the timeline reads as activity, not noise.
+  let timeline='';
+  for(const c of calls){
+    const tag = c.criticalFindings>0 ? '<span class="obs-call-tag crit">critical</span>'
+      : c.blocked ? '<span class="obs-call-tag block">blocked</span>'
+      : c.findings>0 ? '<span class="obs-call-tag warn">'+c.findings+' finding'+(c.findings===1?'':'s')+'</span>'
+      : '<span class="obs-call-tag ok">scanned</span>';
+    timeline+='<div class="obs-call'+(c.blocked?' is-block':'')+'">'
+      +'<span class="obs-call-time">'+he(clock(c.timestamp))+'</span>'
+      +'<span class="obs-call-tool">'+he(c.toolName||'')+'</span>'
+      +'<span class="obs-call-prev">'+(c.preview?he(c.preview):'<span style="color:var(--fg-30)">\\u2014</span>')+'</span>'
+      +tag
+      +'</div>';
+  }
+  // Tool mix summary · gives the observed thread a real "outcome"-style header
+  // (what KIND of work happened) without inventing phases that aren't there.
+  const _mix={};
+  for(const c of calls){ const k=c.toolName||'?'; _mix[k]=(_mix[k]||0)+1; }
+  const _mixStr=Object.entries(_mix).sort((a,b)=>b[1]-a[1]).map(([k,v])=>he(k)+' '+v).join(' · ');
+  // Three states, not two. A chain with no entries walks clean, so treating validity as a
+  // boolean painted this green over a log that did not exist. It is not broken either — there
+  // is simply nothing recorded, and DESIGN.md §1 reserves green for a measurement, which an
+  // empty walk is not.
+  const chainKnown=d.chainVerifiable!==false;
+  const chainOk=chainKnown&&d.chainValid;
+  // Chain-flow · the real audit chain as connected nodes (demo v12 .chain-flow,
+  // gap 4.8). Condensed to KEY events: the first/last few + every blocked or
+  // critical call (never hide those), with a gap marker for the elided middle.
+  // Each node is a real chain entry — seq + tool + state — linked left->right.
+  function chainFlow(cs){
+    if(!cs.length) return '';
+    function he(s){ return String(s==null?'':s).replace(/[&<>"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c])); }
+    function init(tool){ return (String(tool||'?').replace(/[^A-Za-z]/g,'')[0]||'?').toUpperCase(); }
+    var keep=new Set();
+    for(var i=0;i<cs.length;i++){ if(i<2||i>=cs.length-2||cs[i].blocked||cs[i].criticalFindings>0) keep.add(i); }
+    var nodes='';
+    var prevKept=-1;
+    for(var j=0;j<cs.length;j++){
+      if(!keep.has(j)) continue;
+      if(prevKept>=0 && j-prevKept>1) nodes+='<span class="cf-gap" title="'+(j-prevKept-1)+' more scanned">···</span>';
+      else if(prevKept>=0) nodes+='<span class="cf-link"></span>';
+      var c=cs[j];
+      var cls=c.criticalFindings>0?'crit':c.blocked?'block':'ok';
+      var t=c.preview?he(c.preview).slice(0,60):he(c.toolName||'');
+      nodes+='<span class="cf-node '+cls+'" title="'+(c.seq!=null?'#'+c.seq+' · ':'')+he(c.toolName||'')+' · '+t+'">'
+        +'<span class="cf-seq">'+(c.seq!=null?'#'+c.seq:'')+'</span><span class="cf-tool">'+init(c.toolName)+'</span></span>';
+      prevKept=j;
+    }
+    return '<div class="chain-flow-wrap"><div class="chain-flow">'+nodes+'</div>'
+      +'<div class="cf-legend">spawn \\u203A latest · '+cs.length+' calls · each node is a hash-linked entry</div></div>';
+  }
+  const chainHtml='<div class="panel"><div class="panel-title">Audit chain</div>'
+    +chainFlow(calls)
+    +'<div class="verified-block" style="padding:14px 0">'
+    +'<div class="badge" style="background:'+(!chainKnown?'var(--fg-30)':(chainOk?'var(--verified)':'var(--caught)'))+'">'+(!chainKnown?'\\u00b7':(chainOk?'\\u2713':'\\u2715'))+'</div>'
+    +'<div class="k">'+(!chainKnown?'nothing recorded yet':(chainOk?'hash chain verified':'chain broken'))+'</div>'
+    +'<div class="what">'+(!chainKnown
+      ?'No audit entries on this machine. Install the hook to start recording: codehere hook install'
+      :d.chainEntries+' entries · SHA-256 hash-chained · integrity-checked (catches edits after writing)')+'</div>'
+    +'</div></div>';
+  const oHtml='<div class="panel"><div class="panel-title">Observed</div>'
+    +'<div class="outcome-item"><span class="check">'+ms(true)+'</span> '+d.totalCalls+' tool calls scanned by the hook</div>'
+    +(d.blockedCalls>0?'<div class="outcome-item"><span class="cross">'+ms(false)+'</span> '+d.blockedCalls+' blocked before running</div>':'<div class="outcome-item"><span class="check">'+ms(true)+'</span> nothing blocked</div>')
+    +(d.criticalCalls>0?'<div class="outcome-item"><span class="cross">'+ms(false)+'</span> '+d.criticalCalls+' critical finding'+(d.criticalCalls===1?'':'s')+'</div>':'')
+    +(_mixStr?'<div class="outcome-item" style="color:var(--fg-50);font-family:var(--mono);font-size:12px"><span class="pending">\\u2022</span> '+_mixStr+'</div>':'')
+    +'</div>';
+  dv.innerHTML='<div class="detail-header">'
+    +'<span class="back-btn" onclick="hideD()">\\u2190 Back</span>'
+    +'<div class="detail-title-wrap">'
+    +'<div class="detail-kicker">observed · runs in your terminal · read-only</div>'
+    +'<h1 class="detail-title">'+he(d.sessionId)+'</h1>'
+    +'</div></div>'
+    +'<div class="detail-meta"><span class="status-icon done"></span> last activity '+he(ago(calls.length?calls[calls.length-1].timestamp:Date.now()))+' · '+d.totalCalls+' calls</div>'
+    +oHtml+chainHtml
+    +'<div class="panel"><div class="panel-title">Tool calls ('+calls.length+')</div><div class="obs-timeline">'+timeline+'</div></div>'
+    // Honest interaction affordance · an observed session runs in the user's own
+    // terminal; codehere watches it read-only via the hook and cannot inject a
+    // prompt into it. So NO fake composer (that would be a screen-lie). Instead,
+    // an honest note + a real action: fork the context into a managed agent the
+    // user CAN drive from here.
+    +'<div class="obs-readonly-note">'
+    +'<div class="t">This session runs in your terminal. codehere observes it read-only · it can\\'t send a prompt back into your shell. Continue the work in a managed agent codehere CAN drive:</div>'
+    +'<button class="obs-fork-btn" id="ctl-open-btn" onclick="controlManagedAgent(\\''+he(d.sessionId)+'\\')">Continue in a managed agent \\u203A</button>'
+    +'<div id="control-panel"></div>'
+    +'</div>';
+}
+
+// Remote-control · open a codehere-managed agent (codex) and DRIVE it from here:
+// open a control session, then inject() messages into the running turn via the
+// daemon control endpoints. The observed terminal session stays read-only; this
+// is a real agent codehere owns end-to-end (turn/steer).
+let _ctlId=null, _ctlPoll=null;
+async function controlManagedAgent(sessionId){
+  const btn=document.getElementById('ctl-open-btn');
+  const panel=document.getElementById('control-panel');
+  if(!panel)return;
+  if(btn)btn.disabled=true, btn.textContent='opening managed agent…';
+  try{
+    const r=await fetch('/api/control/open',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({agent:'codex',prompt:'Continue the work from terminal session '+sessionId})}).then(x=>x.json());
+    if(!r.controlId){ if(btn)btn.disabled=false,btn.textContent='Continue in a managed agent \\u203A'; al('Control open failed: '+(r.error||'unknown')); return; }
+    _ctlId=r.controlId;
+    if(btn)btn.style.display='none';
+    // Honest "Remote Control · live" affordance — rendered ONLY here, after a
+    // real channel opened. data-verify-channel="live" lets /verify assert the
+    // badge can never exist without a live channel (anti-screen-lie invariant).
+    panel.innerHTML='<div class="ctl-badge" data-verify-unit="remote-control" data-verify-channel="live"><span class="lv"></span> Remote Control \\u00b7 live</div>'
+      +'<div class="ctl-head">managed agent \\u00b7 <span class="ag">codex</span> \\u00b7 thread <code>'+r.threadId+'</code> \\u00b7 steer it below</div>'
+      +'<div class="ctl-steer">'
+      +  '<span class="chip" data-steer="continue">\\u203A continue</span>'
+      +  '<span class="chip" data-steer="run the tests">run the tests</span>'
+      +  '<span class="chip" data-steer="show me the diff">show me the diff</span>'
+      +  '<span class="chip stop" data-steer="__stop">\\u2715 stop steering</span>'
+      +'</div>'
+      +'<div class="ctl-feed" id="ctl-feed"></div>'
+      +'<div class="ctl-composer"><input id="ctl-input" placeholder="Steer this live session\\u2026 (goes to the real running agent)"/><button id="ctl-send">Send \\u2191</button></div>'
+      +'<div class="ctl-channel"><span class="lv"></span> <b>live channel attached</b> \\u00b7 steers recorded in audit chain \\u00b7 reachable from any device you\\'re signed in on</div>';
+    document.getElementById('ctl-send').onclick=ctlInject;
+    document.getElementById('ctl-input').addEventListener('keydown',e=>{ if(e.key==='Enter')ctlInject(); });
+    panel.querySelectorAll('.ctl-steer .chip').forEach(function(c){ c.onclick=function(){ var s=c.getAttribute('data-steer'); if(s==='__stop'){ctlStop();return;} var inp=document.getElementById('ctl-input'); if(inp){ inp.value=s; ctlInject(); } }; });
+    ctlPollEvents();
+    _ctlPoll=setInterval(ctlPollEvents,1500);
+  }catch(e){ if(btn)btn.disabled=false,btn.textContent='Continue in a managed agent \\u203A'; al('Network error: '+e.message); }
+}
+async function ctlInject(){
+  const inp=document.getElementById('ctl-input'); if(!inp||!_ctlId)return;
+  const msg=inp.value.trim(); if(!msg)return;
+  inp.value='';
+  try{ const r=await fetch('/api/control/'+_ctlId+'/inject',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({message:msg})}).then(x=>x.json());
+    if(!r.accepted)al('Inject not accepted');
+    setTimeout(ctlPollEvents,300);
+  }catch(e){ al('Inject failed: '+e.message); }
+}
+// Stop steering from here. Honest scope: detaches the control channel (stops
+// polling + closes the panel). It does NOT claim to kill the remote process —
+// that would be an unverifiable overclaim. The badge disappears with the panel.
+function ctlStop(){
+  if(_ctlPoll){ clearInterval(_ctlPoll); _ctlPoll=null; }
+  _ctlId=null;
+  const panel=document.getElementById('control-panel');
+  if(panel)panel.innerHTML='<div class="ctl-evt dim">stopped steering \\u00b7 channel detached \\u00b7 the agent keeps running in its own session</div>';
+}
+async function ctlPollEvents(){
+  if(!_ctlId)return;
+  try{ const r=await fetch('/api/control/'+_ctlId+'/events').then(x=>x.json());
+    const feed=document.getElementById('ctl-feed'); if(!feed)return;
+    function he(s){ return String(s).replace(/[&<>"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c])); }
+    feed.innerHTML=(r.events||[]).map(e=>{ const it=(e.params||{}).item||{}; const t=it.text||it.command||it.type||e.method; return '<div class="ctl-evt">'+he(t)+'</div>'; }).join('')||'<div class="ctl-evt dim">agent working…</div>';
+  }catch{}
+}
+
+// ── Phase model · the demo v12 lifecycle spine ────────────────────────────
+// A thread reads as a phased narrative (research -> build -> ship -> audit -> live),
+// not a flat step list. Steps don't carry phase labels, so classify by the
+// dominant signal in the label/output. Order matters: test later phases first
+// so a "run tests" step lands in ship, not research.
+// Phase classifier · PHASE_ORDER / PHASE_META / stepPhase / classifySteps are
+// injected from the unit-tested module (thread-phase.ts) — one source of truth.
+// The \\bcode\\b bug that mislabeled read steps as BUILD is why this is no longer
+// inline-untested.
+${PHASE_CLASSIFIER_SRC}
+// Chapter-card divider between phases · demo v12 .chapter-card pattern.
+function chapterCard(prevPhase,nextPhase){
+  var prev=PHASE_META[prevPhase], next=PHASE_META[nextPhase];
+  return '<div class="chapter-divider">'
+    +(prev?'<span class="ch-prev">\\u2713 '+prev.done+'</span>':'<span class="ch-prev"></span>')
+    +'<span class="ch-line"></span>'
+    +'<span class="ch-next">Phase '+next.n+' of 5 \\u00B7 <b>'+next.label+'</b></span>'
+    +'</div>';
+}
+
+${ARTIFACTS}
+
+${CONVERSATION_TURN}
+function __rememberConvOpen(el){
+  try{
+    var sid=el&&el.getAttribute('data-sid');
+    if(sid) _convOpenByTask[sid]=!!el.open;
+  }catch(e){}
+}
+function __rememberStepOpen(el){
+  try{
+    var k=el&&el.getAttribute('data-stepk');
+    if(k) _stepOpen[decodeURIComponent(k)]=!!el.open;
+  }catch(e){}
+}
+function __rememberReceiptOpen(el){
+  try{
+    var k=el&&el.getAttribute('data-rsid');
+    if(k) _receiptOpen[decodeURIComponent(k)]=!!el.open;
+  }catch(e){}
+}
+// Same render-wipe guard for the glance turn's collapsed full report — without
+// it the poll morph strips the open attribute and the report snaps shut mid-read.
+function __rememberGlOpen(el){
+  try{
+    var k=el&&el.getAttribute('data-glsid');
+    if(k) _glMoreOpen[decodeURIComponent(k)]=!!el.open;
+  }catch(e){}
+}
+// Unified timeline (task #51) · the conversation IS the spine, and the tool
+// activity is woven INTO it as inline, collapsed-by-default events (native
+// <details>, no JS), grouped by EMERGENT sections (segmentSteps — dynamic, not
+// a fixed pipeline). Turn timestamps are display strings and step times are
+// epoch (not clock-comparable), so we place the activity block right where
+// execution starts: after the first non-user turn (routing / first agent),
+// before that agent reports back. Reads correct for seeded dialogues and for
+// real single-agent runs (where turns are sparse and the steps dominate).
+// Internal tool ids leak into step labels ("mcp__plugin_context-mode_context-
+// mode__ctx_batch_execute", "Claude requested permissions to use mcp__...").
+// Humanize the SUMMARY line only — the expanded output keeps the raw evidence,
+// so the record stays honest while the conversation reads like a person did it.
+function humanizeStep(s){
+  var x=String(s||'');
+  x=x.replace(/mcp__([A-Za-z0-9_-]+)__([A-Za-z0-9_-]+)/g,function(_,srv,tool){
+    srv=srv.replace(/^plugin[_-]/,'');
+    var m=srv.match(/^(.+?)[_-]\\1$/); if(m) srv=m[1];
+    return tool.replace(/_/g,' ')+' \\u00b7 '+srv;
+  });
+  x=x.replace(/Claude requested permissions? to use\\s+[^,.]+[^\\u00b7]*/i,'needed a permission that was not granted');
+  // Bare internal tool names ("ToolSearch") read like code — split the camelCase.
+  if(/^[A-Z][a-z]+(?:[A-Z][a-z]+)+$/.test(x)) x=x.replace(/([a-z])([A-Z])/g,'$1 $2').toLowerCase();
+  return x;
+}
+function renderTimeline(t, wrapCtxUrls){
+  var turns=Array.isArray(t.turns)?t.turns:[];
+  var steps=(t.toolTrace||t.steps||[]);
+  if(!turns.length && !steps.length) return '';
+  function evtRow(z){
+    var raw=String(z.label||'');
+    // Write-pass · the one moment the human MUST act. Keep the rich primitive
+    // (Approve+send opens the write-pass modal) rather than collapsing it to a
+    // one-liner — collapsing would orphan the approval trigger.
+    if(/^\\s*w-?pass\\b|^\\s*write-pass\\b/i.test(raw)){
+      var parts=raw.split(/\\s*·\\s*/);
+      var wtitle=(parts[1]||raw||'write awaits').replace(/</g,'&lt;');
+      var wtail=(parts.slice(2).join(' · ')||(z.state==='active'?'awaiting approval':'')).replace(/</g,'&lt;');
+      var pHtml=(z.output?String(z.output):'').replace(/</g,'&lt;')
+        .replace(/(in-progress|pending|todo|backlog)/g,'<span class="from">$1</span>')
+        .replace(/(\\u2192|->)/g,'<span class="arrow">$1</span>')
+        .replace(/(done|approved|merged|shipped|sent)/g,'<span class="val">$1</span>');
+      return '<div class="write-pass" style="margin-left:25px">'
+        +'<div class="head"><span>write-pass</span><span class="tail" data-user-content style="color:var(--fg-50);letter-spacing:normal;text-transform:none">'+wtail+'</span></div>'
+        +'<h4 data-user-content>'+wtitle+'</h4>'
+        +(pHtml?'<div class="payload" data-user-content>'+pHtml+'</div>':'')
+        +'<div class="actions"><button class="primary" onclick="if(window.openWpModal)openWpModal()">Approve + send</button></div>'
+        +'</div>';
+    }
+    var lbl=wrapCtxUrls(humanizeStep(raw).replace(/</g,'&lt;'));
+    var cls='allow', txt='L0';
+    if(z.state==='failed'){ cls='block'; txt=/block|denied|refused|permission/i.test(String(z.output||z.errorText||z.label||''))?'BLOCKED':'FAILED'; }
+    else if(z.state==='active'){ cls='clean'; txt='RUN'; }
+    // Active step · the agent is working on this RIGHT NOW. Render the live
+    // .thinking dots + streaming .repl-beat instead of a collapsed details row,
+    // so the reasoning primitive renders on a real active step (not only in the
+    // dead toolCardsHtml path). SSE refetch swaps it for a completed row when
+    // the step finishes.
+    if(z.state==='active'){
+      var beat=z.output?ansiToHtml(String(z.output).slice(0,300)):lbl;
+      return '<div class="tl-evt '+cls+' tl-active">'
+        +'<div class="tl-lbl" data-user-content>'+lbl+'</div>'
+        +'<div class="thinking"><span class="dots"><span></span><span></span><span></span></span>working</div>'
+        +'<div class="repl-beat" data-user-content>'+beat+'<span class="cursor"></span></div>'
+        +'</div>';
+    }
+    var dur=(z.completedAt&&z.startedAt)?'<span class="tl-dur">'+(Math.round((z.completedAt-z.startedAt)/100)/10)+'s</span>':'';
+    // Lift the step's OUTCOME into the summary line so the conversation reads as
+    // what HAPPENED ("Edit x · +59 lines · change applied"), not a hollow label.
+    // The meaningless "L0" badge is dropped for normal completed steps; the badge
+    // stays only for failed/blocked states, which are worth flagging.
+    var oc=String(z.output==null?'':z.output).trim();
+    var rawFirst=oc.split(/\\r?\\n/)[0]||'';
+    var ocFirst=humanizeStep(rawFirst);
+    var ocHtml=ocFirst?'<span class="tl-outcome" data-user-content>'+wrapCtxUrls(ocFirst.slice(0,72).replace(/</g,'&lt;'))+'</span>':'';
+    // Compare raw-to-raw: humanizeStep shortens the first line, and comparing
+    // the raw total against the shortened line faked a "more to expand" state.
+    var more=(oc.length>rawFirst.length+2)||(rawFirst.length>72);
+    var badge=(cls!=='allow')?'<span class="tl-badge '+cls+'">'+txt+'</span>':'';
+    var out=more?renderStepOutput(z):'';
+    // The raw label stays one hover away (title attr) — humanize rewrites the
+    // summary, it must not erase the original evidence from the DOM.
+    var rawTitle=(humanizeStep(raw)!==raw)?' title="'+raw.replace(/"/g,'&quot;').replace(/</g,'&lt;')+'"':'';
+    // Persist expansion across the poll re-render (systemic render-wipe sweep):
+    // key on task + step signature so an expanded step stays open. Only
+    // expandable rows (more) get the key + ontoggle; flat rows have nothing.
+    var _sk=(t.sessionId||'')+'|'+(z.startedAt||'')+'|'+raw;
+    var _stepIsOpen=more && !!_stepOpen[_sk];
+    var _stepAttrs=more?(' ontoggle="__rememberStepOpen(this)" data-stepk="'+encodeURIComponent(_sk)+'"'+(_stepIsOpen?' open':'')):'';
+    return '<details class="tl-evt '+cls+(more?'':' tl-flat')+'"'+_stepAttrs+'><summary><span class="tl-caret">\\u25B8</span><span class="tl-lbl" data-user-content'+rawTitle+'>'+lbl+'</span>'+ocHtml+dur+badge+'</summary>'+out+'</details>';
+  }
+  // The agent's own words (kind:'say') — rendered as the agent speaking, with
+  // its avatar, distinct from the collapsed tool events.
+  function thinkRow(st){
+    // The agent's interleaved reasoning — muted, with a "thinking" marker, full
+    // markdown (so code in reasoning renders properly), no trim.
+    return '<div class="tl-think" data-verify-unit="think"><span class="tl-think-tag">\\u29B8 thinking</span><div class="tl-think-text report-md" data-user-content>'+renderReportMd(st.label)+'</div></div>';
+  }
+  function askRow(st){
+    // The agent is asking the user. Renders the question + options as a real
+    // card; clicking an option (single-select) sends the answer, which continues
+    // the SAME session via /api/task/:id/message (--resume). Already answered ->
+    // shows the chosen answer, locked.
+    var q=st.question||{questions:[]};
+    var answered=st.answered||_answeredAsks[(t.sessionId||'')+'|'+(q.toolUseId||'')];
+    var anyMulti=(q.questions||[]).some(function(x){return x.multiSelect;});
+    var qs=(q.questions||[]).map(function(qq){
+      var opts=(qq.options||[]).map(function(o){
+        var picked=answered && (answered.indexOf?answered.indexOf(o.label)>=0:false);
+        return '<div class="ask-opt'+(picked?' picked':'')+'" data-ask-label="'+convHe(o.label)+'"'+(answered?'':' onclick="chAnswerOpt(this)"')+'><span class="ask-opt-label" data-user-content>'+convHe(o.label)+'</span>'+(o.description?'<span class="ask-opt-desc" data-user-content>'+convHe(o.description)+'</span>':'')+'</div>';
+      }).join('');
+      return '<div class="ask-q">'+(qq.header?'<div class="ask-q-head" data-user-content>'+convHe(qq.header)+'</div>':'')+'<div class="ask-q-text" data-user-content>'+convHe(qq.question)+'</div><div class="ask-opts">'+opts+'</div></div>';
+    }).join('');
+    var foot = answered ? '<div class="ask-answered">\\u2713 answered: <span data-user-content>'+convHe((answered.join?answered.join(', '):String(answered)))+'</span></div>'
+             : (anyMulti ? '<div class="ask-foot"><button class="ask-send" onclick="chAnswerSend(this)">Send answer</button></div>' : '<div class="ask-hint">click an option to answer \\u00b7 the agent continues from here</div>');
+    return '<div class="tl-ask'+(answered?' answered':'')+'" data-verify-unit="ask"'+(anyMulti?' data-ask-multi="1"':'')+(q.toolUseId?' data-ask-tuid="'+convHe(q.toolUseId)+'"':'')+'><div class="tl-ask-head">'+ab(t.agent,'sm')+'<span class="tl-ask-title">The agent is asking you</span></div>'+qs+foot+'</div>';
+  }
+  function sayRow(st){
+    return '<div class="tl-say" data-verify-unit="say" data-verify-textlen="'+String((st.label||'').trim().length)+'">'+ab(t.agent,'sm')+'<div class="tl-say-text report-md" data-user-content>'+renderReportMd(st.label)+'</div></div>';
+  }
+  // Single in-order pass so the agent's words + its tool actions interleave the
+  // way they actually happened ("explains -> acts"). Dynamic ⧁ section dividers
+  // appear when a RUN of tool actions shifts activity (segmentSteps logic,
+  // inline); a 'say' breaks the run so the next tool reopens a section.
+  function activityBlock(){
+    if(!steps.length) return '';
+    // Inline audit-line · the first beat of the timeline makes the local audit
+    // chain VISIBLE in the flow (not just in the footer). ONLY state-derived
+    // claims: the pre-prompt scan genuinely runs on every spawn
+    // (session-manager scanPromptBeforeSpawn, all adapters), but its VERDICT
+    // isn't plumbed to the task object — so say it ran, never that it was
+    // "clean". "L0 hooks loaded" / "writes require approval" were cut by the
+    // 2026-06-07 review: claude-only / opt-in respectively — false as blanket
+    // claims for the other vendors and the default posture.
+    var _aAgent=(agentLabel(t.agent)||'agent').toLowerCase();
+    var _aFiles=((t.artifacts&&t.artifacts.files)||[]).length;
+    var html='<div class="audit-line allow"><span class="seq">#0001</span>'
+      +'pre-prompt scan ran \\u00b7 routed to <b>'+_aAgent+'</b>'
+      +(_aFiles?' \\u00b7 context: <b>'+_aFiles+' file'+(_aFiles===1?'':'s')+'</b>':'')
+      +'</div>';
+    var curPhase=null, openActs=false;
+    var close=function(){ if(openActs){ html+='</div>'; openActs=false; } };
+    for(var i=0;i<steps.length;i++){
+      var st=steps[i];
+      if(st.kind==='say'){ close(); curPhase=null;
+        // Don't repeat the distilled report here — it's already the top summary
+        // bubble (renderD summHtml). Showing the exact same words twice is the
+        // duplication the summary-bubble comment warns against.
+        var _rep=(t.finalReport&&t.finalReport.summary)||'';
+        if(_rep&&String(st.label||'').trim()===String(_rep).trim()){ continue; }
+        html+=sayRow(st); continue; }
+      if(st.kind==='think'){ close(); curPhase=null; html+=thinkRow(st); continue; }
+      if(st.kind==='ask'){ close(); curPhase=null; html+=askRow(st); continue; }
+      var ph=(typeof stepPhase==='function'?stepPhase(st):null)||curPhase||'research';
+      // S12 · the existing phase dividers upgraded to the NUMBERED chapter
+      // style (01 RESEARCH · 02 BUILD · …) — same classifier, same .tl-div
+      // class (the F-THREAD-PHASED probe keeps matching), richer staging.
+      if(ph!==curPhase){
+        close();
+        var _pm=(typeof PHASE_META!=='undefined'&&PHASE_META[ph])||null;
+        var _plabel=(_pm&&_pm.label)||ph;
+        // No canonical phase number prefix: steps render chronologically, so a
+        // phase index (research=01…ship=03) reads out of order (03 · 01 · 02 · 03)
+        // and looks broken. The phase word alone marks what kind of work it is.
+        html+='<div class="tl-div"><span class="tl-verb">'+convHe(_plabel)+'</span><span class="tl-ln"></span></div>';
+        curPhase=ph;
+      }
+      if(!openActs){ html+='<div class="tl-acts">'; openActs=true; }
+      html+=evtRow(st);
+    }
+    close();
+    return html;
+  }
+  // split point: just after the first non-user (routing / agent) turn
+  var splitAt=0;
+  for(var i=0;i<turns.length;i++){ var sp=turns[i].speaker||turns[i].role; if(isAgentSpeaker(sp)){ splitAt=i+1; break; } }
+  if(!turns.length) splitAt=0;
+  var head=turns.slice(0,splitAt).map(renderTurn).join('');
+  var tail=turns.slice(splitAt).map(renderTurn).join('');
+  // DESIGN.md §4.3 — collapse the step wall into a one-line receipt. Evidence
+  // one click away, never always-on. The room meta line already carries the
+  // room-level summary (duration · cost · steps · artifacts), so the receipt
+  // summary labels what expands (the trace) without re-stating cost/files.
+  function receiptWrap(inner){
+    if(!steps.length) return inner; // nothing to collapse (routing-only turn)
+    var _rsid=(t.sessionId||'');
+    var _open=!!_receiptOpen[_rsid];
+    var _tests=(t.artifacts&&t.artifacts.tests)||null;
+    var _tp=_tests?(_tests.passed||0):0, _tf=_tests?(_tests.failed||0):0;
+    var parts=[steps.length+' step'+(steps.length===1?'':'s')];
+    if(_tests&&(_tp+_tf)>0) parts.push(_tp+'/'+(_tp+_tf)+' tests');
+    var summary=parts.join(' \\u00b7 ');
+    return '<details class="tl-receipt" data-rsid="'+convHe(_rsid)+'" ontoggle="__rememberReceiptOpen(this)"'+(_open?' open':'')
+      +'><summary class="rcpt-row"><span class="tl-caret">\\u25B8</span><span class="rcpt-sum">'+summary+'</span><span class="rcpt-view">view receipt \\u203A</span></summary>'
+      +'<div class="rcpt-body">'+inner+'</div></details>';
+  }
+  return '<div class="panel tl-panel"><div class="panel-title">Conversation</div>'+head+receiptWrap(activityBlock())+tail+'</div>';
+}
+
+// Recursive DOM morph: reconcile an old node toward a new one, descending so
+// only the leaves that actually changed get touched — a new timeline step
+// appends its row, every existing row keeps its exact DOM node (no flicker, no
+// restarted animation). isEqualNode short-circuits any unchanged subtree.
+function morphNode(o, n){
+  if(o.nodeType!==n.nodeType){ o.replaceWith(n); return; }
+  if(o.nodeType===3){ if(o.nodeValue!==n.nodeValue) o.nodeValue=n.nodeValue; return; }
+  if(o.nodeType!==1){ if(!o.isEqualNode(n)) o.replaceWith(n); return; }
+  if(o.tagName!==n.tagName){ o.replaceWith(n); return; }
+  if(o.isEqualNode(n)) return;
+  // sync attributes
+  var oa=o.attributes, i;
+  for(i=oa.length-1;i>=0;i--){ if(!n.hasAttribute(oa[i].name)) o.removeAttribute(oa[i].name); }
+  var na=n.attributes;
+  for(i=0;i<na.length;i++){ if(o.getAttribute(na[i].name)!==na[i].value) o.setAttribute(na[i].name, na[i].value); }
+  // reconcile child nodes (text + elements) by index — content here is
+  // append-mostly (streaming steps), so positional matching holds
+  var nNodes=Array.prototype.slice.call(n.childNodes);
+  for(i=0;i<nNodes.length;i++){
+    var oNode=o.childNodes[i];
+    if(!oNode){ o.appendChild(nNodes[i]); continue; }
+    morphNode(oNode, nNodes[i]);
+  }
+  while(o.childNodes.length>nNodes.length){ o.removeChild(o.lastChild); }
+}
+// Layer 3 · answer the agent's question. Clicking an option (single-select)
+// sends immediately; multi-select toggles + a Send button. The answer POSTs to
+// the existing /api/task/:id/message route -> appendMessage continues the SAME
+// claude session via --resume, and its steps merge back into the timeline.
+function chAnswerOpt(el){
+  var card=el.closest('.tl-ask'); if(!card||card.classList.contains('answered'))return;
+  if(card.getAttribute('data-ask-multi')==='1'){ el.classList.toggle('picked'); return; }
+  chSendAnswer(card,[el.getAttribute('data-ask-label')]);
+}
+function chAnswerSend(btn){
+  var card=btn.closest('.tl-ask'); if(!card)return;
+  var picked=Array.prototype.slice.call(card.querySelectorAll('.ask-opt.picked')).map(function(o){return o.getAttribute('data-ask-label');});
+  if(!picked.length)return;
+  chSendAnswer(card,picked);
+}
+function chSendAnswer(card,labels){
+  var sid=_detail; if(!sid)return;
+  _answeredAsks[sid+'|'+(card.getAttribute('data-ask-tuid')||'')]=labels;
+  var qtext=(card.querySelector('.ask-q-text')||{}).textContent||'';
+  var answer='You asked: "'+qtext+'"\\nMy answer: '+labels.join(', ');
+  card.classList.add('answered');
+  card.querySelectorAll('.ask-opt').forEach(function(o){ o.removeAttribute('onclick'); if(labels.indexOf(o.getAttribute('data-ask-label'))>=0)o.classList.add('picked'); });
+  var foot=card.querySelector('.ask-foot, .ask-hint');
+  if(foot)foot.outerHTML='<div class="ask-answered">\\u2713 sending your answer\\u2026</div>';
+  fetch('/api/task/'+encodeURIComponent(sid)+'/message',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({text:answer})})
+    .then(function(r){return r.json();})
+    .then(function(){ if(typeof fetchAll==='function'){ fetchAll(); } else if(_detail===sid){ showD(sid); } })
+    .catch(function(){ var a=card.querySelector('.ask-answered'); if(a)a.textContent='could not send \\u00b7 try again'; });
+}
+// SAME-session live re-render -> morph in place (fine-grained, incl. inside the
+// timeline). First render / a different session -> full innerHTML write.
+// (Ega: append-only render, reconcile inside the timeline)
+function writeDetail(t, html){
+  var dv=document.getElementById('detail-view');
+  var sid=String((t&&t.sessionId)||'');
+  var same=dv.getAttribute('data-sid')===sid && dv.childNodes.length>0;
+  dv.setAttribute('data-sid', sid);
+  if(!same){ dv.innerHTML=html; return; }
+  var tmp=document.createElement('div'); tmp.innerHTML=html;
+  var nw=Array.prototype.slice.call(tmp.childNodes);
+  for(var i=0;i<nw.length;i++){
+    var o=dv.childNodes[i];
+    if(!o){ dv.appendChild(nw[i]); continue; }
+    morphNode(o, nw[i]);
+  }
+  while(dv.childNodes.length>nw.length){ dv.removeChild(dv.lastChild); }
+}
+// The cross-vendor receipt panel — the proof a single-vendor tool can't make:
+// a DIFFERENT vendor reviewed an earlier writer in this room, the chain proves
+// both, here's the cost. Green ✓ only when the server marked it proven (a clean
+// read-only cross-vendor review whose chain verified); otherwise a neutral dot
+// + the honest caveats. codehere does NOT judge the findings here.
+function crossVendorPanel(cv){
+  function esc(x){ return String(x==null?'':x).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;'); }
+  var proven=!!cv.proven;
+  var icon=proven?'\\u2713':'\\u00B7';
+  var bg=proven?'var(--verified)':'var(--fg-30)';
+  var k=proven?(esc(cv.reviewer.agent)+' reviewed '+esc(cv.writer.agent)+'\\u2019s work \\u00b7 a different vendor')
+    :'cross-vendor review \\u00b7 not a clean proof yet';
+  var cav='';
+  if(cv.caveats&&cv.caveats.length){ for(var i=0;i<cv.caveats.length;i++){ cav+='<div class="outcome-item"><span class="pending">\\u2022</span> '+esc(cv.caveats[i])+'</div>'; } }
+  // Corroboration by a different vendor reads as the brand-gradient SEAL (v2 mockup):
+  // the one place the gradient earns its keep, the signature trust object.
+  if(proven){
+    return '<div class="seal-wrap" data-cross-vendor="proven"><div class="seal"><div class="seal-inner">'
+      +'<div class="seal-check">\\u2713</div>'
+      +'<div class="seal-txt">'
+      +'<div class="seal-l1">Corroborated by <b>'+esc(cv.reviewer.agent)+'</b> \\u00b7 a different vendor</div>'
+      +'<div class="seal-l2" data-user-content>'+esc(cv.summary)+'</div>'
+      +'</div></div>'+cav+'</div></div>';
+  }
+  return '<div class="panel" data-cross-vendor="caveated">'
+    +'<div class="panel-title">Cross-vendor review</div>'
+    +'<div class="verified-block" style="padding:14px 0">'
+    +'<div class="badge" style="background:'+bg+'">'+icon+'</div>'
+    +'<div class="k">'+k+'</div>'
+    +'<div class="what">'+esc(cv.summary)+'</div>'
+    +'</div>'+cav+'</div>';
+}
+// Lazy-load the receipt for one session, cache it, and re-render the open detail
+// so the panel joins renderD's output (morph-stable). Sets null first so renderD
+// won't re-fetch; overwrites with the verdict only if the server returns one.
+async function loadCrossVendor(id){
+  if(!id || Object.prototype.hasOwnProperty.call(_crossVendorByTask,id)) return;
+  _crossVendorByTask[id]=null;
+  try{
+    const r=await fetch('/api/task/'+encodeURIComponent(id)+'/cross-vendor');
+    if(!r.ok) return;
+    const j=await r.json();
+    const cv=j&&j.crossVendor;
+    if(!cv) return; // stays null — not a cross-vendor review
+    _crossVendorByTask[id]=cv;
+    if(_detail===id){ const tt=findS(id); if(tt) renderD(tt); }
+  }catch(e){}
+}
+
+// REQUEST_METHOD §2 — the acceptance contract, rendered at the top of the room:
+// what "done" means, agreed up front, each criterion met (✓) / unmet (✕) /
+// pending (○). This is the keystone that turns the verdict from post-hoc vibe
+// into "did it meet the criteria we set before it ran". Empty => nothing renders.
+function contractBlockHtml(t){
+  var cs=(t&&t.acceptanceCriteria)||[];
+  if(!Array.isArray(cs)||!cs.length) return '';
+  var rows=cs.map(function(c){
+    var met=(c&&c.met);
+    var g=met===true?'\\u2713':(met===false?'\\u2715':'\\u25CB');
+    var cls=met===true?'met':(met===false?'unmet':'pending');
+    return '<div class="ac-row '+cls+'"><span class="ac-g">'+g+'</span><span class="ac-t" data-user-content>'+convHe(String((c&&c.text)||''))+'</span></div>';
+  }).join('');
+  var n=cs.length, done=cs.filter(function(c){return c&&c.met===true;}).length;
+  return '<div class="contract"><div class="ac-head">Done means<span class="ac-count">'+done+'/'+n+'</span></div>'+rows+'</div>';
+}
+function renderD(t) {
+  const s=st(t.status), steps=(t.steps||[]), files=t.artifacts?.files||[], d=taskDur(t);
+  const co=t.cost?t.cost.spent:null;
+  const nStep=steps.length;
+
+  // R8/R9/R10/R11 — Final Report outcome only ✓ when prose summary actually exists.
+  // Empty finalReport object or null/empty summary => honest "unavailable" outcome,
+  // not a green check. Composer must offer a re-spawn affordance for these cases.
+  const hasReportText = !!(t.finalReport && typeof t.finalReport.summary === 'string' && t.finalReport.summary.trim());
+  // Outer-scope mirror of the conversation's default-open state (the real
+  // _convOpen is block-scoped later). When the conversation shows the steps by
+  // default, the separate collapsed "N steps" trace is redundant — hide it.
+  const _convShown = steps.length>0 || !hasReportText;
+  // §G R8 — green ✓ "Final Report" ONLY for a verified live-agent summary
+  // (source === 'agent-summary'). Every other source — deterministic fallback,
+  // error-recovery, mock synthesis — renders an honest ⚠, never a fake ✓.
+  // POSITIVE allowlist (not deny-one) so a new/unknown source can't sneak a ✓.
+  const reportSource = (t.finalReport && t.finalReport.source) || '';
+  const isVerifiedAgentReport = reportSource === 'agent-summary';
+  const isTerminal = ['completed','done','killed','failed','error','crashed'].includes(t.status);
+  // The headline "N files changed" number. Normally derived from the actual
+  // artifact list, so claim === rendered count, always. The optional
+  // artifacts.filesClaimed override is the ONE seam where a headline number can
+  // diverge from the rendered file rows — the honesty probe seeds exactly that
+  // divergence so /verify's counts-consistent invariant has a real lie to catch.
+  const claimedFiles = (t.artifacts && typeof t.artifacts.filesClaimed === 'number') ? t.artifacts.filesClaimed : files.length;
+
+  // S14 · the Outcome panel folded into the CLAIM/CHECKED/RESULT evidence
+  // table (built AFTER the verdict section so the rows can reuse the same
+  // staged verdict — same data-verify-unit="outcome" contract, same attrs).
+  // Running/queued keep the live current-action presentation here.
+  const _oAttrs=' data-verify-unit="outcome" data-verify-files-claimed="'+claimedFiles+'" data-verify-steps="'+nStep+'" data-verify-terminal="'+(isTerminal?'true':'false')+'" data-verify-has-report="'+(hasReportText?'true':'false')+'"';
+  let oHtml='';
+  if(t.status==='running'||t.status==='queued'){
+    // Live current action — the agent's latest move, prominent and updated as
+    // the timeline streams. A "0 of N done" counter reads as nothing happening;
+    // the current action reads as the agent actually working. (Ega dogfood)
+    var _last = nStep ? steps[steps.length-1] : null;
+    var _act = _last ? compactLabel(_last.label||_last.tool||'') : '';
+    oHtml='<div class="panel"'+_oAttrs+'><div class="run-now"><span class="run-pulse"></span><span class="run-now-label" data-user-content>'+(_act||'starting\\u2026')+'</span></div>'
+      +(nStep?'<div class="outcome-item pending run-sub">'+nStep+' step'+(nStep===1?'':'s')+' so far \\u00b7 live</div>':'')
+      +'</div>';
+  }
+
+  // The summary object (the glance turn) is built AFTER the verdict section —
+  // it composes the verdict line, so construction moved below vLine.
+
+  // E-03 · hook BLOCK affordance · render a red-bordered card when the session
+  // was killed by the safety hook (status='error' with a 'blocked' tag or any
+  // step in state='failed' carrying a known block signature). The user gets
+  // three named actions; the audit chain captures whichever they pick.
+  let blockHtml='';
+  const blockedStep = (t.steps||[]).find(s => s.state==='failed' && /block|denied|refused/i.test(String(s.output||s.label||'')));
+  if(blockedStep){
+    const bSid=String(t.sessionId||'').replace(/'/g,'');
+    const bTool=String(blockedStep.label||'blocked-op').replace(/"/g,'').slice(0,80);
+    blockHtml = '<div class="hook-block-card" id="hook-block-card">'
+      + '<div class="hook-block-title">safety hook · BLOCKED</div>'
+      + '<div class="hook-block-msg">'+String(blockedStep.label||'').replace(/</g,'&lt;')+'</div>'
+      + '<div class="hook-block-actions" id="hook-block-actions">'
+      +   '<button onclick="overrideBlock(\\''+bSid+'\\',\\''+bTool.replace(/'/g,'')+'\\')">Override + log reason</button>'
+      +   '<button onclick="a(\\'kill\\',\\''+bSid+'\\')">Kill session</button>'
+      + '</div>'
+      + '<div id="override-result" class="override-result"></div>'
+      + '</div>';
+  }
+
+  // E-07 · push gate · if a session attempted git push (detect via step label),
+  // surface the gate. Same shape as hook-block but warn-tinted.
+  let pushHtml='';
+  const pushStep = (t.steps||[]).find(s => /git\\s*push/i.test(String(s.label||'')));
+  if(pushStep && pushStep.state==='active'){
+    pushHtml = '<div class="push-gate-card">'
+      + '<div class="push-gate-title">push gate · awaiting confirm</div>'
+      + '<div class="hook-block-msg">'+String(pushStep.label||'').replace(/</g,'&lt;')+'</div>'
+      + '<div class="hook-block-actions">'
+      // MED #13 (atomic audit) · these were toast-only stubs — the recovery-
+      // card lie class (a button narrating an action it doesn't perform).
+      // The daemon has no push-decision endpoint yet (F-PUSH-GATE is [partial]), so
+      // the honest shape is disabled-with-reason until the wire exists.
+      +   '<button disabled title="not wired yet \\u00b7 the daemon has no push-decision endpoint (F-PUSH-GATE is in progress); run the push from your terminal">Push</button>'
+      +   '<button disabled title="not wired yet \\u00b7 the push command is shown in the step label above">Print command</button>'
+      +   '<button disabled title="not wired yet \\u00b7 stop the task instead to cancel its push">Cancel</button>'
+      + '</div>'
+      + '</div>';
+  }
+
+  // G-U10 · crash recovery · when a persisted session shows orphaned state
+  // (status='error' from a daemon death) or the session has no completedAt
+  // despite status being non-running, show a recovery affordance.
+  let crashHtml='';
+  const looksOrphaned = (t.status==='error' || t.status==='crashed') && !t.completedAt;
+  if(looksOrphaned){
+    crashHtml = '<div class="crash-recovery">'
+      + '<div class="crash-recovery-title">orphaned session</div>'
+      + '<div style="color:var(--fg-70);font-size:12px">The daemon died before this task completed. Audit chain has the partial trail; rerun the prompt to continue.</div>'
+      + '</div>';
+  }
+
+  // P3 · Recovery affordance · session-level failure with named options.
+  // Triggers when the session FAILED for reasons other than a deliberate
+  // hook block (E-03 owns that case) and isn't an orphan (G-U10 owns
+  // that). Common cases: agent crashed mid-run, provider error, test
+  // suite failed, the task itself returned non-zero.
+  let recoveryHtml='';
+  const isFailed = ['failed','error','crashed','killed'].includes(t.status);
+  const isOrphan = looksOrphaned;
+  const hasBlock = !!blockedStep;
+  if(isFailed && !isOrphan && !hasBlock){
+    const lastStep = (t.steps||[])[(t.steps||[]).length-1];
+    const lastErr = lastStep && (lastStep.error || lastStep.label || '');
+    const reasonText = t.stalledReason
+      ? '<b>What happened:</b> '+String(t.stalledReason).replace(/[&<>"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]))
+      : lastErr
+      ? '<b>What failed:</b> '+String(lastErr).slice(0,200).replace(/</g,'&lt;')
+      : '<b>What failed:</b> the agent exited with status <code style="background:var(--bg-2);padding:1px 5px;border-radius:3px;font-family:var(--mono);font-size:12px">'+t.status+'</code> · no specific error captured';
+    // Thariq loop-1 · honest recovery: every action is REAL or honestly
+    // disabled-with-reason — no button text asserts what the click won't do
+    // (the §3 binding rule; the recovery-buttons-must-not-lie probe enforces
+    // it). Retry re-POSTs /api/task with this task's own prompt/cwd/agent;
+    // Diagnose focuses the captured failing step; Mark-resolved writes a human
+    // ack into the audit chain. State is exposed via data-verify-recovery.
+    const _canRetry = !!(t.prompt && String(t.prompt).trim());
+    const _failStep = (t.steps||[]).find(s => s.state==='failed');
+    const _hasFailStep = !!_failStep;
+    const _rstate = _canRetry ? (_hasFailStep ? 'failed' : 'failed-no-step') : 'failed-no-prompt';
+    const retryBtn = _canRetry
+      ? '<button class="primary" data-verify-action="retry" onclick="recoverRetry(\\''+t.sessionId+'\\')">Retry this task <span class="kbd">\\u23ce</span></button>'
+      : '<button class="primary" disabled data-verify-action="retry-disabled" title="the original prompt wasn\\u2019t recorded for this run, so it can\\u2019t be respawned">Retry</button>';
+    const diagBtn = _hasFailStep
+      ? '<button class="linkbtn" data-verify-action="diagnose" onclick="recoverDiagnose(\\''+t.sessionId+'\\')">see the failing step</button>'
+      : '<button class="linkbtn" disabled data-verify-action="diagnose-disabled" title="this run captured no single failing step to focus">see the failing step</button>';
+    recoveryHtml = '<div class="recovery-card" data-verify-unit="recovery" data-verify-recovery="'+(t.resolvedAt?'resolved':_rstate)+'">'
+      + '<div class="recovery-title"><span class="dot"></span>Your call \\u00b7 this task did not complete cleanly</div>'
+      + '<div class="recovery-cause">'+reasonText+'</div>'
+      + '<div class="recovery-resolve"><b>codehere:</b> every step that DID run is in the audit chain. Most likely you just want to run it again \\u00b7 same prompt, same agent, same repo. Recovery doesn\\u2019t rewrite history.</div>'
+      + '<div class="recovery-actions" style="align-items:center;gap:14px">'
+      +   retryBtn
+      +   diagBtn
+      +   (t.resolvedAt
+            ? '<button class="linkbtn" disabled data-verify-action="resolve-done" title="already acknowledged \\u00b7 recorded in the audit chain">mark resolved</button>'
+            : '<button class="linkbtn" data-verify-action="resolve" onclick="recoverResolve(\\''+t.sessionId+'\\',this)">mark resolved</button>')
+      + '</div>'
+      + (_canRetry ? '' : '<div class="recovery-reason">Retry is unavailable \\u00b7 this run\\u2019s prompt wasn\\u2019t recorded, so codehere can\\u2019t reconstruct the spawn. (An honest disable, not a dead button.)</div>')
+      // S3 · the ack renders FROM TASK STATE so it sticks across reload —
+      // the click-time badge alone vanished on the next render.
+      + (t.resolvedAt ? '<div class="recovery-ack">\\u2713 acknowledged by you \\u00b7 recorded in the audit chain \\u00b7 '+new Date(t.resolvedAt).toLocaleString()+'</div>' : '')
+      + '</div>';
+  }
+
+  // S14 · files as quiet mono chips ("path +adds −dels", trust grade kept).
+  // KEEPS the .file-tree class + the filetree data-verify contract: the
+  // rendered count is the REAL chip count, so the probe-lie (claims 3, renders
+  // 1) still FAILS H5. Test counts moved into the evidence table's CHECKED row.
+  let chipsHtml='';
+  const filesArr = (t.artifacts && t.artifacts.files) || [];
+  if(filesArr.length){
+    const esc=s=>String(s||'').replace(/</g,'&lt;');
+    const grade=f=>(typeof f.trust==='number')?(f.trust>=85?'A':f.trust>=70?'B':f.trust>=50?'C':'F'):null;
+    chipsHtml='<div class="file-tree fileschips" data-verify-unit="filetree" data-verify-rendered="'+filesArr.length+'">';
+    filesArr.forEach(function(f){
+      const g=grade(f);
+      chipsHtml+='<span class="fchip"><b>'+esc(f.path)+'</b>'
+        +(f.added>0?'<span class="added">+'+f.added+'</span>':'')
+        +(f.removed>0?'<span class="removed">\\u2212'+f.removed+'</span>':'')
+        +(g?'<span class="trust '+g+'">'+g+'</span>':'')
+        +'</span>';
+    });
+    chipsHtml+='</div>';
+    // Inline code-card · render under the chips for any file carrying a
+    // .snippet. The reviewer sees WHAT got written, not just "+N lines".
+    const cards = filesArr.filter(function(f){ return f && f.snippet; }).map(function(f){
+      return codeCard(String(f.path||''), f.snippet, f.lang);
+    }).join('');
+    if(cards) chipsHtml += cards;
+  }
+
+  // Non-git honesty · codehere derives file changes from git diff. In a folder
+  // that isn't a git repo it captures zero file artifacts — NOT because nothing
+  // changed, but because it can't see what did. Say so plainly rather than
+  // letting an empty Files panel imply "no changes".
+  let gitNoteHtml='';
+  if(t.artifacts && t.artifacts.noGitTracking){
+    gitNoteHtml = '<div class="panel git-note"><div class="panel-title">File tracking</div>'
+      + '<div class="git-note-body">This folder isn\\'t a git repository, so codehere couldn\\'t track which files the agent changed. The steps below are what the agent reported. To see file changes and trust scores, run the task in a git repo (<code>git init</code> first).</div>'
+      + '</div>';
+  }
+
+  // Wrap context-source URLs (linear://X · github://Y · figma://Z · drawio://W)
+  // in .ctx-url-chip so the existing overlay-renderer (window.codehereOpenOverlay)
+  // can preview them. Otherwise the URLs render as plain mono · dead text in a
+  // primitive we already shipped to act on. (Used by renderTimeline below —
+  // the old parallel "Activity · phased" tool-card builder it served died in
+  // S14: it was computed but never rendered since the task-#51 timeline merge.)
+  function wrapCtxUrls(escapedText){
+    return escapedText.replace(
+      /(linear|github|figma|drawio):\\/\\/[A-Za-z0-9_\\/\\-.#?=&]+/g,
+      function(m){ return '<span class="ctx-url-chip" data-url="'+m+'" title="click to preview">'+m+'</span>'; }
+    );
+  }
+  // F-08 · token table · per-agent token + cost breakdown when artifacts.usage
+  // is captured. Single row when one adapter ran, multi-row + total when
+  // multiple agents handled this task (e.g., conductor -> specialist).
+  let tokenHtml='';
+  const u = t.artifacts && t.artifacts.usage;
+  if(u && (u.inputTokens || u.outputTokens || u.cacheReadTokens)){
+    const fmt=n=>n>0?n.toLocaleString():'<span class="dim">-</span>';
+    const inT=u.inputTokens||0, outT=u.outputTokens||0;
+    const cr=u.cacheReadTokens||0, cc=u.cacheCreationTokens||0;
+    const total=inT+outT+cr+cc;
+    tokenHtml = '<div class="panel"><div class="panel-title">Tokens</div>'
+      + '<table class="token-table"><thead><tr>'
+      + '<th>agent</th><th>input</th><th>output</th><th>cache read</th><th>cache new</th><th>total</th>'
+      + '</tr></thead><tbody>'
+      + '<tr><td>'+(t.agent||'agent')+'</td>'
+      +   '<td>'+fmt(inT)+'</td>'
+      +   '<td>'+fmt(outT)+'</td>'
+      +   '<td>'+fmt(cr)+'</td>'
+      +   '<td>'+fmt(cc)+'</td>'
+      +   '<td>'+fmt(total)+'</td></tr>'
+      + '</tbody></table></div>';
+  }
+
+  // F-07 / R11 · the verdict — direction E's calm dot + ONE-WORD line (S14).
+  // Replaces the S12 jewel hero AND the separate Verifier panel: same
+  // VerdictService verdict object, same branch gates, same data-verify
+  // contracts (H1 no-verified-without-git + H9 no-green-on-failed read the
+  // identical attributes off .vline). Only for terminal sessions with a
+  // Final Report · running tasks have nothing to verify yet. Green appears
+  // ONLY in the exact branch that was green before — the only green on the page.
+  let verdictLine='';
+  let verdictProv='';
+  // DESIGN.md §1 · the evidence tier, DERIVED from what actually happened —
+  // never stamped. applyTestObservation (domain/task.ts) is the one writer of
+  // these fields, so this reads its output rather than re-deciding:
+  //   tests.observed        codehere re-ran the suite and owns the exit code
+  //   tests.countSource     'claimed' = we ran it, but the NUMBER is the agent's
+  //                         (a qualifier on a measured verdict, surfaced in prose)
+  //   testsUnobserved       we could not run it, and the reason is recorded
+  // 'judged' has no producer today: nothing LLM-derived reaches a verdict — the
+  // Final Report is prose. The tier exists so that if one ever does, it cannot
+  // arrive wearing green.
+  // Did this run change its own test files? Same predicate as session-manager's
+  // touchedTestFiles (kept in sync deliberately — a suffix-only version missed a
+  // whole ecosystem once, per the 2026-06-09 devil's-advocate audit).
+  function editedOwnTests(t){
+    var fs=(t && t.artifacts && t.artifacts.files) || [];
+    return fs.some(function(f){
+      var p=String(f && f.path || '');
+      return /(^|\\/)(tests?|spec|__tests__)\\//i.test(p)
+          || /\\.(test|spec)\\.\\w+$|_test\\.\\w+$/i.test(p)
+          || /(^|\\/)test_[^/]+\\.py$/i.test(p);
+    });
+  }
+  function evidenceTier(t){
+    var a = t && t.artifacts;
+    if(!a) return 'unchecked';
+    if(a.tests && a.tests.observed) return 'measured';
+    if(a.testsUnobserved) return 'unchecked';
+    return 'unchecked';
+  }
+  function vLine(ev, cls, dv, heroTag, word, sub){
+    return '<div class="vline '+cls+'" data-evidence="'+ev+'" data-verify-unit="verifier" data-verify-verdict="'+dv+'" data-verify-verdict-hero="'+heroTag+'" data-verify-gittracked="'+((t.artifacts&&t.artifacts.noGitTracking)?'false':'true')+'">'
+      +'<span class="vl-d"></span><span class="vl-w">'+word+'</span><span class="vl-s">\\u00b7 '+sub+'</span></div>';
+  }
+  // The green-verdict sub-clause, scoped to the ACTUAL independent signal that
+  // earned the green. A LONE cross-vendor pass is one reviewer's corroboration,
+  // so it reads "corroborated by one other vendor" — never "independently
+  // corroborated", which overstates a single reviewer. Disk-observed writes and
+  // multi-signal greens keep the "independently corroborated" wording.
+  function indepClause(grade){
+    var sigs=(grade&&grade.signals)||[];
+    var pass=sigs.filter(function(s){return s&&s.provenance!=='self-reported'&&s.state==='pass';});
+    if(pass.length===1 && pass[0].provenance==='adversarial') return 'corroborated by one other vendor.';
+    var hasDisk=pass.some(function(s){return s.provenance==='observed';});
+    return hasDisk ? 'independently corroborated \\u00b7 file writes confirmed on disk.' : 'independently corroborated.';
+  }
+  const vr=t.verdict&&t.verdict.claim;
+  const _vTests=t.artifacts&&t.artifacts.tests;
+  if(vr && isTerminal && hasReportText && vr.status!=='no-report'){
+    const noGit = !!(t.artifacts && t.artifacts.noGitTracking);
+    const failingTests = ((_vTests&&_vTests.failed)||0) > 0;
+    if(t.mockRun){
+      // Tier 0.1 · a real MOCK run fabricated its own artifacts, so a green
+      // "verified" would be tautological (report vs its own synthetic data).
+      // Say Practice — honest about what a no-key/mock run actually proves.
+      // verdict is NOT "verified" so H1 + a skeptic both read it correctly.
+      verdictLine = vLine(evidenceTier(t),'v-wr','wiring-only','wiring-only',VERDICT_WORDS.practice,'wiring only \\u00b7 the agent fabricated its own result.');
+      verdictProv = 'mock mode \\u00b7 proves the pipeline, not the work \\u00b7 run a real agent (API key or subscription) for a real verdict';
+    } else if(vr.status!=='broken' && !isFailed && !failingTests && _crossVendorByTask[t.sessionId] && _crossVendorByTask[t.sessionId].proven){
+      // Single verdict (no contradiction): a clean cross-vendor review is the
+      // strongest non-broken signal, so it OWNS the headline. But a SINGLE
+      // other-vendor review is corroboration, not proof — so the headline word
+      // is "Verified" (independent corroboration), never "Proven". The seal
+      // below expands it as "Corroborated by X · a different vendor". Never
+      // render "Partial"/"Unverified" above it; broken + honest failures still
+      // win (checked first).
+      verdictLine = vLine(evidenceTier(t),'v-ok','verified','verified',VERDICT_WORDS.verified,'a different vendor reviewed this \\u00b7 corroborated by one other vendor.');
+    } else if(vr.status==='verified'){
+      // S5 honesty gate · the VerdictService says "verified" when the report's
+      // claims MATCH the recorded reality — on a failed task (or with failing
+      // tests) that means the report is honestly describing a failure. The
+      // green word reads as success, so it must never render here.
+      if(isFailed || failingTests){
+        verdictLine = vLine(evidenceTier(t),'v-wr','report-honest-'+(isFailed?'failed':'failing-tests'),'honest-failed',VERDICT_WORDS.stopped,'the report is honest about a failure.');
+      } else if(noGit){
+        // R8 honesty: in a non-git folder the verifier can't observe the file
+        // changes, so a green "verified" would overclaim.
+        verdictLine = vLine(evidenceTier(t),'v-wr','partial','partial',VERDICT_WORDS.partial,'couldn\\u2019t fully verify \\u00b7 not a git repo.');
+      } else if(!t.verdict.grade){
+        // Legacy/seeded verdict with no composite grade attached — keep prior
+        // behavior (real tasks always carry a grade via composeVerdict).
+        verdictLine = vLine(evidenceTier(t),'v-ok','verified','verified',VERDICT_WORDS.verified,'claims match reality.');
+      } else if(t.verdict.grade.green){
+        // 2.2 · green ONLY with an INDEPENDENT signal (observed on disk or
+        // adversarial cross-vendor). The composite grade owns that gate. Name the
+        // ACTUAL signal so a lone cross-vendor pass — the same state the seal
+        // branch above renders once its async fetch resolves — reads as
+        // corroboration by one vendor, not "independently corroborated".
+        verdictLine = vLine(evidenceTier(t),'v-ok','verified','verified',VERDICT_WORDS.verified,indepClause(t.verdict.grade));
+      } else {
+        // Self-report matches its own artifacts, but nothing INDEPENDENT has
+        // confirmed it — shown honestly as reported, never green (the 2.2 gate).
+        verdictLine = vLine(evidenceTier(t),'v-wr','reported','partial',VERDICT_WORDS.reported,'self-reported \\u00b7 not independently checked yet.');
+      }
+    } else if(vr.status==='broken'){
+      verdictLine = vLine(evidenceTier(t),'v-bad','broken','broken',VERDICT_WORDS.caught,'the claim didn\\u2019t match reality.');
+    } else if(vr.status==='nothing-to-verify'){
+      // The report made no checkable CLAIM — but the composite grade can still
+      // be green from an INDEPENDENT signal (the audit observing the declared
+      // file writes on disk). Defer to it: real, observed work reads as Verified
+      // (matching the row + the grade); a true no-op (no green) stays neutral, so
+      // a startup-banner run never shows a false pass. (user-#1 dogfood 2026-06-07.)
+      if(t.verdict.grade && t.verdict.grade.green){
+        // Name the ACTUAL corroborating signal (shared with the green branch
+        // above): file writes on disk, a lone cross-vendor reviewer, or multiple.
+        verdictLine = vLine(evidenceTier(t),'v-ok','verified','verified',VERDICT_WORDS.verified,indepClause(t.verdict.grade));
+      } else {
+        verdictLine = vLine(evidenceTier(t),'v-wr','nothing-to-verify','partial',VERDICT_WORDS.unverified,'the report makes no checkable claim.');
+      }
+    } else {
+      verdictLine = vLine(evidenceTier(t),'v-wr',vr.status,'partial',VERDICT_WORDS.partial,'couldn\\u2019t fully verify.');
+    }
+    if(verdictLine && !verdictProv){
+      // One-line provenance · built ONLY from real fields: tests.observed
+      // means the verifier actually re-ran the suite (rerun-tests use-case);
+      // countSource==='claimed' means the count is the agent's own stdout.
+      // Never "chain intact" here — that claim belongs on /verify where the
+      // chain check actually runs.
+      var _pv=[(agentLabel(t.agent)||'the agent')+' reported'];
+      if(_vTests && _vTests.observed) _pv.push('verifier re-ran the suite');
+      else _pv.push('checked against the recorded run');
+      if(_vTests && _vTests.countSource==='claimed') _pv.push('test count as reported');
+      // Re-running a suite the SAME agent just edited proves the suite passes, not
+      // that the work is right — making the check agree with you is the strongest
+      // lie available to an agent. codehere already computed this signal
+      // (session-manager touchedTestFiles) but used it ONLY to decide whether to
+      // re-run; it never reached the surface, so a run where the agent rewrote its
+      // own test rendered as a clean green "verifier re-ran the tests". Same
+      // predicate as session-manager, deliberately.
+      if(_vTests && _vTests.observed && editedOwnTests(t)) _pv.push('suite edited in this run');
+      _pv.push('hash-chained locally');
+      verdictProv=_pv.join(' \\u00b7 ');
+    }
+    if(verdictProv) verdictProv='<div class="vline-meta">'+verdictProv+'</div>';
+  }
+
+  // THE summary object (detail subtraction, 2026-07-06) · every terminal task
+  // gets ONE glance turn and it is the only place the outcome facts render:
+  // glance sentence (the report's first sentence, or the honest outcome
+  // sentence when no report exists) -> the verdict line (the only verdict on
+  // the page — the receipt's gl-v mini-dot died here) -> one mono receipt
+  // (cost · files · tests · time, DESIGN.md §4.3) -> the full report resting
+  // collapsed as the record. The meta line and the lenses stopped restating
+  // these facts; they read here.
+  let summHtml='';
+  if(isTerminal){
+    var _condBadge = (t.agent==='conductor' && t.delegatedTo && t.delegatedTo!=='conductor')
+      ? '<span class="card-agent">Conductor \\u2192 '+agentLabel(t.delegatedTo)+'</span>' : '';
+    var _glance='', _more='';
+    if(hasReportText){
+      var _rpt=String(t.finalReport.summary);
+      // The glance is the first meaningful sentence — drop adapter banners that
+      // some CLIs (aider's version + in-chat-filenames note) prepend to stdout, so
+      // the lead reads as the agent's words, not tooling noise. Full report keeps it.
+      // \\u0060 = backtick (can't appear literally inside this template literal);
+      // the dot alternative refuses to end inside an ellipsis (loop-1 verifier finds).
+      var _plain=_rpt.replace(/[#*>_~\\[\\]\\u0060]/g,'').replace(/\\s+/g,' ').trim();
+      _plain=_plain.replace(/^Aider v[\\d.]+\\s*/i,'').replace(/^Note: in-chat filenames are always relative to[^.]*\\.\\s*/i,'').trim();
+      var _gm=_plain.match(/^[\\s\\S]*?(?:[!?]|\\.(?!\\.))(?:\\s|$)/);
+      _glance=(_gm?_gm[0]:_plain).trim();
+      var _hasMore=_plain.length>_glance.length+2;
+      var _glsid=encodeURIComponent(String(t.sessionId||''));
+      var _glopen=!!_glMoreOpen[String(t.sessionId||'')];
+      _more=_hasMore
+        ? '<details class="gl-more" data-glsid="'+_glsid+'" ontoggle="__rememberGlOpen(this)"'+(_glopen?' open':'')+'><summary>full report \\u203A</summary><div class="tl-say-text report-md" data-user-content>'+renderReportMd(_rpt)+'</div></details>'
+        : '';
+    } else {
+      _glance=outcomeSentence(t);
+    }
+    var _rc=[];
+    if(co!==null) _rc.push('<span>$'+(co/100).toFixed(co<10?4:2)+'</span>'); // same precision rule as costPill — one convention per screen
+    if(files.length) _rc.push('<span>'+files.length+' file'+(files.length===1?'':'s')+'</span>');
+    if(_vTests && ((_vTests.passed||0)+(_vTests.failed||0))>0) _rc.push('<span>'+(_vTests.passed||0)+'/'+((_vTests.passed||0)+(_vTests.failed||0))+' tests</span>');
+    if(t.durationMs) _rc.push('<span>'+dur(t.durationMs)+'</span>');
+    else if(t.completedAt && t.startedAt) _rc.push('<span>'+dur(t.completedAt-t.startedAt)+'</span>');
+    var _receipt=_rc.length?'<div class="gl-receipt">'+_rc.join('')+'</div>':'';
+    summHtml = '<div class="tl-say summary-turn glance-turn">'+ab(t.agent)
+      + '<div class="tl-say-body">'+_condBadge
+      + '<div class="gl-line" data-user-content>'+convHe(_glance)+'</div>'
+      + verdictLine + verdictProv
+      + _receipt + _more
+      + '</div></div>';
+    // results -> GitHub: if this task came from an issue, offer to post the result back.
+    var _ghm=(t.prompt||'').match(/github\\.com\\/([^\\/\\s]+)\\/([^\\/\\s]+)\\/issues\\/(\\d+)/i);
+    if(_ghm){
+      summHtml += '<div class="gh-back" style="margin:6px 0 0 38px">'
+        +'<button type="button" onclick="_ghPostResult(\\''+t.sessionId+'\\')" style="background:none;border:1px solid rgba(255,255,255,.18);border-radius:7px;color:rgba(255,255,255,.72);font:inherit;font-size:12px;padding:5px 11px;cursor:pointer">Comment result on '+_ghm[1]+'/'+_ghm[2]+'#'+_ghm[3]+'</button>'
+        +'<span id="gh-back-msg" style="margin-left:8px;font-size:12px;color:rgba(255,255,255,.4)"></span></div>';
+    }
+  }
+
+  // S14 · the evidence table — CLAIM / CHECKED / RESULT (direction E). Every
+  // value is a recorded field (verdict findings carry claim+reality verbatim,
+  // artifacts.tests, files on disk, the headline file count); nothing is
+  // invented. With no checkable claim the table collapses to ONE honest
+  // CHECKED row. It carries the outcome data-verify contract, so H3 (no empty
+  // box) + H5 (counts-consistent — the probe-lie still FAILS off these
+  // attributes) keep reading the same truth.
+  if(!(t.status==='running'||t.status==='queued')){
+    const _evCl=_vTests&&_vTests.claimed;
+    const _evP=_vTests?(_vTests.passed||0):0, _evF=_vTests?(_vTests.failed||0):0;
+    const _evDisagree=!!(_evCl&&((_evCl.passed!==_evP)||(_evCl.failed!==_evF)));
+    const _evFinds=(vr&&vr.findings)||[];
+    const _evNoGit=!!(t.artifacts&&t.artifacts.noGitTracking);
+    const _hasVerdict=!!(vr && isTerminal && hasReportText && vr.status!=='no-report');
+    const _noCheckable=_hasVerdict && vr.status==='nothing-to-verify';
+    // CLAIM — only what the report / the agent actually said
+    let claimBits=[];
+    _evFinds.slice(0,2).forEach(function(f){ if(f&&f.claim) claimBits.push('\\u201C'+convHe(f.claim)+'\\u201D'); });
+    if(_evCl) claimBits.push(_evCl.passed+' passed'+(_evCl.failed?' \\u00b7 '+_evCl.failed+' failed':' \\u00b7 0 failed'));
+    // when observed=false the counts ARE the agent's own scraped stdout —
+    // presenting them as the claim is attribution of its actual words
+    else if(_vTests && !_vTests.observed && !_evFinds.length) claimBits.push(_evP+'/'+(_evP+_evF)+' tests green');
+    // Refuter (S14) · the file count joins CLAIM only when the report
+    // EXPLICITLY claimed one (artifacts.filesClaimed) — claimedFiles falls
+    // back to the on-disk count, and attributing disk truth to the agent's
+    // report is constructive attribution (words in the report's mouth).
+    if(t.artifacts && typeof t.artifacts.filesClaimed==='number' && t.artifacts.filesClaimed>0 && !claimBits.some(function(b){return /file/.test(b);})) claimBits.push(t.artifacts.filesClaimed+' file'+(t.artifacts.filesClaimed===1?'':'s')+' changed');
+    // CHECKED — what the verifier compared / what was actually observed
+    let checkedBits=[];
+    _evFinds.slice(0,2).forEach(function(f){ if(f&&f.reality) checkedBits.push(convHe(f.reality)); });
+    if(_vTests && _vTests.observed) checkedBits.push('verifier re-ran the suite \\u00b7 '+_evP+' green'+(_evF?' \\u00b7 '+_evF+' red':''));
+    else if(_vTests) checkedBits.push('recorded test run \\u00b7 '+_evP+' passed \\u00b7 '+_evF+' failed'+(_vTests.durationMs?' \\u00b7 '+Math.round(_vTests.durationMs/100)/10+'s':''));
+    if(files.length) checkedBits.push(files.length+' file'+(files.length===1?'':'s')+' on disk \\u00b7 git diff');
+    else if(_evNoGit) checkedBits.push('not a git repo \\u00b7 file changes not observable');
+    // RESULT — the verdict sentence + DERIVED counts, only when a verdict exists
+    let resultRow='';
+    if(_hasVerdict && !_noCheckable){
+      const _nContr=_evFinds.length+((_evDisagree&&!_evFinds.some(function(f){return f&&f.kind==='tests';}))?1:0);
+      let _rTxt='', _rCls='';
+      if(t.mockRun){ _rTxt='practice run \\u00b7 wiring proven \\u00b7 the result is the agent\\u2019s own fabrication'; }
+      else if(vr.status==='broken'){ _rTxt=_nContr+' contradiction'+(_nContr===1?'':'s')+' \\u00b7 left unmerged \\u00b7 the catch is recorded locally'; _rCls=' bad'; }
+      else if(vr.status==='verified'&&(isFailed||_evF>0)){ _rTxt='no contradiction \\u00b7 the report describes a failing run'; }
+      else if(vr.status==='verified'&&_evNoGit){ _rTxt='couldn\\u2019t fully verify \\u00b7 nothing in the report contradicts what was recorded'; }
+      else if(vr.status==='verified'){ _rTxt='0 contradictions \\u00b7 '+checkedBits.length+' check'+(checkedBits.length===1?'':'s')+' compared'; _rCls=' good'; }
+      else { _rTxt=convHe(vr.summary||'couldn\\u2019t check everything'); }
+      resultRow='<div class="erow2 result'+_rCls+' outcome-item"><span class="elbl">Result</span><span class="etxt">'+_rTxt+'</span></div>';
+    }
+    // Report provenance · zero information loss from the old Outcome panel:
+    // a non-live-agent report (R8 allowlist) or a missing report stays visible.
+    let noteRow='';
+    if(hasReportText && !isVerifiedAgentReport){
+      const _rl = reportSource==='deterministic' ? 'no written report \\u00b7 recorded facts only'
+                : reportSource==='error-recovery' ? 'final report \\u00b7 task did not complete'
+                : 'final report \\u00b7 unverified (not a live-agent summary)';
+      noteRow='<div class="erow2 note outcome-item"><span class="elbl">Report</span><span class="etxt">\\u26A0 '+_rl+'</span></div>';
+    } else if(!hasReportText && isTerminal){
+      noteRow='<div class="erow2 note outcome-item"><span class="elbl">Report</span><span class="etxt">\\u26A0 final report unavailable</span></div>';
+    }
+    const claimRow=(!_noCheckable && hasReportText && claimBits.length)
+      ? '<div class="erow2 outcome-item"><span class="elbl">Claim</span><span class="etxt" data-user-content>'+claimBits.join(' \\u00b7 ')+' \\u00b7 '+convHe(agentLabel(t.agent)||'agent')+', final report</span></div>'
+      : '';
+    if(!checkedBits.length) checkedBits.push(_noCheckable
+      ? 'the report makes no checkable claim \\u00b7 nothing to compare'
+      : nStep+' recorded step'+(nStep===1?'':'s')+' in the local chain');
+    const checkedRow='<div class="erow2 checked outcome-item"><span class="elbl">Checked</span><span class="etxt">'+checkedBits.join(' \\u00b7 ')+'</span></div>';
+    oHtml='<div class="evi"'+_oAttrs+'>'+(_noCheckable?checkedRow:claimRow+checkedRow+resultRow)+noteRow+'</div>';
+  }
+
+  // S14 · "Your call" on a CAUGHT verdict — the decision block for a broken
+  // claim on a non-failed run (a failed run's decision block is the recovery
+  // card, which already owns retry/diagnose/resolve). REAL actions only: a
+  // respawn that appends the verifier's finding to the original prompt (only
+  // when that prompt was recorded — else disabled-with-reason), and the
+  // existing human-ack path into the audit chain. No fictional actions —
+  // codehere doesn't merge, so there is no "merge anyway". Carries the same
+  // .recovery-card + data-verify-recovery contracts so H7
+  // (recovery-buttons-must-not-lie) covers these buttons too.
+  let yourCallBroken='';
+  if(vr && vr.status==='broken' && isTerminal && !isFailed && !hasBlock && !t.mockRun){
+    const _bCanRetry=!!(t.prompt && String(t.prompt).trim());
+    const _bRetry=_bCanRetry
+      ? '<button class="primary" data-verify-action="retry-with-finding" onclick="recoverRetryAttach(\\''+t.sessionId+'\\')">Retry with the contradiction attached <span class="kbd">\\u23ce</span></button>'
+      : '<button class="primary" disabled data-verify-action="retry-with-finding-disabled" title="the original prompt wasn\\u2019t recorded for this run, so it can\\u2019t be respawned with the finding attached">Retry with the contradiction attached</button>';
+    yourCallBroken='<div class="recovery-card" data-verify-unit="recovery" data-verify-recovery="'+(t.resolvedAt?'resolved':'broken-unreviewed')+'">'
+      +'<div class="recovery-title"><span class="dot"></span>Your call \\u00b7 the verifier caught a contradiction</div>'
+      +'<div class="recovery-cause">The claim didn\\u2019t match what was recorded \\u00b7 the work stays unmerged until you decide.</div>'
+      +'<div class="recovery-actions" style="align-items:center;gap:14px">'
+      +_bRetry
+      +(t.resolvedAt
+          ? '<button class="linkbtn" disabled data-verify-action="resolve-done" title="already acknowledged \\u00b7 recorded in the audit chain">mark reviewed</button>'
+          : '<button class="linkbtn" data-verify-action="resolve" onclick="recoverResolve(\\''+t.sessionId+'\\',this)">Mark reviewed \\u00b7 recorded in the audit chain</button>')
+      +'</div>'
+      +(_bCanRetry?'':'<div class="recovery-reason">Retry is unavailable \\u00b7 this run\\u2019s prompt wasn\\u2019t recorded, so codehere can\\u2019t reconstruct the spawn. (An honest disable, not a dead button.)</div>')
+      +(t.resolvedAt?'<div class="recovery-ack">\\u2713 acknowledged by you \\u00b7 recorded in the audit chain \\u00b7 '+new Date(t.resolvedAt).toLocaleString()+'</div>':'')
+      +'</div>';
+  }
+
+  const tc=t.toolTrace||t.steps||[];
+  // P10 · per-step hook badges in trace. Derive same heuristic as the
+  // tool-card hook-badge code (line 1176+): block when step.state===failed
+  // OR /blocked|denied|refused/, override when /override/, ctx when the
+  // step touched a context-source URL, otherwise allow.
+  function stepHookBadge(z){
+    const out = String(z.output||z.label||'').toLowerCase();
+    if(z.state==='failed' || /block|denied|refused/i.test(out)) return '<span class="hook-badge block">block</span>';
+    if(/override/i.test(out)) return '<span class="hook-badge override">override</span>';
+    if(/(linear|github|figma|drawio):\\/\\//i.test(out)) return '<span class="hook-badge ctx">ctx</span>';
+    return '<span class="hook-badge allow">allow</span>';
+  }
+  // Step trace rests collapsed. The summary keeps the count visible; expanding
+  // is lossless because every recorded step still renders inside the details.
+  const traceHtml=tc.length>0
+    ?'<details class="collapsible"><summary>'+tc.length+' steps</summary>'
+      +tc.map(z=>'<div class="tc">'
+        + stepHookBadge(z)
+        + '<div class="tc-label" data-user-content>'+compactLabel(z.label||z.tool||'?')+'</div>'
+        + ((z.fullOutput||z.output)?'<pre class="tc-output" data-user-content>'+ansiToHtml(String(z.fullOutput||z.output))+'</pre>':'')
+        + (z.durationMs?'<span class="tc-dur">'+z.durationMs+'ms</span>':'')
+        + '</div>').join('')+'</details>'
+    :'';
+
+  // R11 — composer enable check uses RAW backend statuses (the st() mapper
+  // converts 'completed'->'done' for display but t.status is still raw here).
+  // Enable on every known state including terminal ones so the user can ask
+  // "what happened?" / request changes; the server-side appendMessage endpoint
+  // is the authority on whether the session can still accept input.
+  const knownStatuses = ['running','queued','done','completed','paused','blocked','failed','error','crashed','killed'];
+  // S1 · the composer never invites a message that can't be delivered. The
+  // SERVER declares deliverability (canFollowUp): live sessions by adapter
+  // capability; finished ones only when the agent's session is resumable
+  // (claude-code + its native token). Disabled-with-reason, never a dead box.
+  const _termState = ['done','completed','failed','error','crashed','killed'].includes(t.status);
+  const _noFollowUp = _termState && t.canFollowUp === false;
+  const inputDisabled = !knownStatuses.includes(t.status) || _noFollowUp;
+  const ta=document.getElementById('detail-ta'), btn=document.getElementById('detail-btn');
+  if(ta){
+    ta.disabled=inputDisabled;
+    if(_noFollowUp) ta.placeholder=(t.agent||'this agent')+' can\\u2019t continue a finished task \\u00b7 start a new one; the project thread carries the context';
+    else if(inputDisabled) ta.placeholder='Follow-up unavailable for this state';
+    else if(t.status==='running') ta.placeholder='Interrupt or ask a question...';
+    else ta.placeholder='Ask a follow-up about this task...';
+    ta.setAttribute('data-verify-followup', _noFollowUp?'disabled-honest':(inputDisabled?'disabled':'enabled'));
+  }
+  if(btn){ btn.disabled=inputDisabled; if(_noFollowUp) btn.title=(t.agent||'this agent')+' can\\u2019t continue a finished task'; else btn.title=''; }
+  const _sf=document.getElementById('detail-send-fail'); if(_sf && _sf.getAttribute('data-sid')!==t.sessionId){ _sf.style.display='none'; _sf.textContent=''; }
+
+  // Failover-aware kicker · when a session crossed vendors (rate-limit
+   // failover · context handoff), surface the lineage in the title kicker
+   // so the cross-vendor wedge is visible at a glance. PHASE4 §H sharpened
+   // moat: "cross-vendor failover with context handoff" is THE unique
+   // differentiator. Show it.
+  let kicker;
+  if(t.failoverFrom && t.failoverTo){
+    // convHe-escape (uppercase first, THEN escape — escaping then uppercasing
+    // would corrupt entities). This kicker path went live with the recovery
+    // lineage wiring (2026-06-08); harden it to match the badge (refuter).
+    const from=convHe((agentLabel(t.failoverFrom)||String(t.failoverFrom)).toUpperCase());
+    const to=convHe((agentLabel(t.failoverTo)||String(t.failoverTo)).toUpperCase());
+    const reason=t.failoverReason ? ' \\u00B7 ' + convHe(String(t.failoverReason).replace(/_/g,' ').toUpperCase()) : '';
+    kicker=from+' \\u203A '+to+reason+' \\u00B7 '+s.toUpperCase();
+  } else {
+    kicker=(agentLabel(t.agent)||'task').toUpperCase()+' \\u00B7 '+s.toUpperCase();
+  }
+  // Artifacts -> side drawer (task #51): accessible via a header trigger +
+  // openable on demand, not stacked inline. Reuses renderArtifacts content.
+  var _artStruct=(t.artifacts&&t.artifacts.structured)||[];
+  var _artHtml=renderArtifacts(_artStruct);
+  var _artN=_artStruct.length;
+  var _artTrig=_artN?'<span class="art-trig" onclick="openArtD()">'+_artN+' artifact'+(_artN===1?'':'s')+' \\u203A</span>':'';
+  var _artDrawer=_artHtml?'<div class="art-scrim'+(_artOpen?' open':'')+'" id="artScrim" onclick="closeArtD()"></div>'
+    +'<div class="art-modal'+(_artOpen?' open':'')+'" id="artDrawer" role="dialog" aria-label="Artifacts"><div class="art-modal-h"><span>Artifacts \\u00B7 '+_artN+'</span><span class="x" role="button" tabindex="0" aria-label="Close artifacts" onclick="closeArtD()">\\u2715</span></div>'
+    +'<div class="art-modal-body">'+_artHtml+'</div></div>':'';
+  // Shared-proof row (Phase 2.5 team visibility): when a session was IMPORTED
+  // from a teammate's signed bundle, attribute it (provenance) + show the audit
+  // attestation. HONEST: the badge is gated on importAudit.attested (verified>0 &&
+  // no tamper) — never a bare "verified"; trust reduces to the signer's key (the
+  // CLI says the same). data-verify-imported lets the verify harness assert it.
+  var provenanceHtml='';
+  if(t.importedFrom){
+    var _fp=String(t.importedFrom);
+    var _au=t.importAudit;
+    var _badge='';
+    if(_au){
+      // importAudit comes from an attacker-controllable bundle (a malicious signer
+      // the recipient may have trusted). Two defenses (refuter 2026-06-08):
+      //  - COERCE the counts to numbers — never interpolate the raw field (a
+      //    string field would be a stored-XSS sink in the dashboard DOM).
+      //  - RE-DERIVE the gate from the coerced counts, do NOT trust the stored
+      //    attested flag — else a crafted verified:0/tampered:0/attested:true
+      //    would render a green 0-tool-calls hashes-intact badge (a fake proof).
+      var _v=Number(_au.verified)||0;
+      var _t=Number(_au.tampered)||0;
+      if(_t>0){
+        _badge='<span class="proof-badge proof-bad" data-verify-attested="false">\\u2715 audit chain inconsistent \\u00B7 '+_t+' altered</span>';
+      } else if(_v>0){
+        _badge='<span class="proof-badge proof-ok" data-verify-attested="true">\\u2713 '+_v+' agent tool call'+(_v===1?'':'s')+' recorded \\u00B7 hashes intact</span>';
+      } else {
+        _badge='<span class="proof-badge proof-neutral" data-verify-attested="false">no verifiable tool-call audit in this bundle</span>';
+      }
+    }
+    provenanceHtml='<div class="shared-proof" data-verify-imported="true">'
+      +'<span class="prov-from">imported from '+convHe(_fp)+'</span>'
+      +_badge
+      +'<span class="prov-note">signer-attested \\u00B7 your trust = this key</span>'
+      +'</div>';
+  }
+  // Recovery badge (S3 dogfood gap, 2026-06-08): when THIS session is a failover
+  // REPLACEMENT — it took over after the first agent stalled or failed — say so,
+  // so the cross-vendor resilience is VISIBLE instead of the first agent reading
+  // as a bare "killed" row. failoverReason is a controlled enum (stall/rate_limit/
+  // quota_exceeded); convHe-escaped anyway as defense. Gated on both ids present.
+  var recoveredHtml='';
+  if(t.failoverFrom && t.failoverTo){
+    var _rfrom=agentLabel(t.failoverFrom)||String(t.failoverFrom);
+    var _rreason=t.failoverReason?(' \\u00B7 '+convHe(String(t.failoverReason).replace(/_/g,' '))):'';
+    // R7 · honest handoff label, exactly what carried and what didn't: the
+    // replacement got a WARM RESTART with context (the repo + the failure
+    // lineage + the prior agent's work summary, injected as a [handoff:…]
+    // block the session's own prompt makes inspectable) — NOT a live state
+    // transfer. The tooltip + note say so; no surface implies more.
+    recoveredHtml='<div class="shared-proof" data-verify-recovered="true" data-verify-recovered-from="'+convHe(String(t.failoverFrom))+'">'
+      +'<span class="recovered-badge" title="Warm restart with context: the replacement agent got the repo + the failure lineage (plus the prior agent\\u2019s work summary when one was available) \\u00b7 not a live state transfer.">recovered from '+convHe(_rfrom)+_rreason+'</span>'
+      +'<span class="prov-note">the first agent didn\\u2019t finish \\u00B7 '+convHe(agentLabel(t.failoverTo)||String(t.failoverTo))+' restarted the work warm \\u00b7 repo + lineage (+ the prior summary when available), not a live state transfer</span>'
+      +'</div>';
+  }
+  // Tier 1.2 · audit<->disk reconciliation: the audit records what the agent
+  // DECLARED (its tool calls); this line says what codehere could CONFIRM against
+  // the real git diff. 'declared-not-observed' (writes claimed, nothing on disk)
+  // is the signal — a no-op, a write-then-revert, or a fabricated tool_use. The
+  // note + counts are server-generated (no user input); convHe-escaped as defense.
+  var auditReconHtml='';
+  var _ar=t.verdict&&t.verdict.audit;
+  if(_ar && _ar.verdict){
+    var _arv=String(_ar.verdict);
+    // 'unconfirmed' is NEUTRAL ⚠ ("couldn't confirm"), never a red ✕ — a false
+    // fabrication accusation on honest work is the worst error on a proof surface
+    // (refuter 2026-06-09). Only 'consistent' earns a positive ✓.
+    var _arcls = _arv==='consistent' ? 'proof-ok' : 'proof-neutral';
+    var _aricon = _arv==='consistent' ? '\\u2713' : _arv==='unconfirmed' ? '\\u26A0' : '\\u00B7';
+    auditReconHtml='<div class="panel"><div class="panel-title">Audit \\u00B7 disk reconciliation</div>'
+      +'<div class="shared-proof" data-verify-recon="'+_arv+'">'
+      +'<span class="proof-badge '+_arcls+'">'+_aricon+' '+convHe(String(_ar.note||''))+'</span>'
+      +'</div></div>';
+  }
+  // Cross-vendor receipt — async-loaded + cached (see _crossVendorByTask). On
+  // first sight of a session, kick the fetch; render the panel once the verdict
+  // (or null) is cached, so it survives writeDetail's morph-diff.
+  let cvHtml='';
+  { const _cvSid=String(t.sessionId||''); const _cv=_crossVendorByTask[_cvSid];
+    if(_cv===undefined){ loadCrossVendor(_cvSid); }
+    // Show the cross-vendor panel ONLY when it's a real proof — a DIFFERENT
+    // vendor genuinely corroborated the work. The gray "not a clean proof yet"
+    // box was scaffolding that existed to explain what DIDN'T happen; it's noise.
+    // Loud only on the one thing no single-vendor tool can show.
+    else if(_cv && _cv.proven){ cvHtml=crossVendorPanel(_cv); } }
+  // S14/S21 · the conversation rests as ONE quiet row ("conversation · N turns ·
+  // every tool call recorded") that expands the existing unified timeline.
+  // Live runs keep their current-action line in the outcome panel; the full
+  // timeline stays collapsed until clicked. The user's choice is remembered per
+  // task for this browser session and survives SSE re-renders.
+  const _lens=curLens();
+  const _tlHtml=renderTimeline(t, wrapCtxUrls);
+  let convWrap='';
+  if(_tlHtml){
+    const _convSid=String(t.sessionId||'');
+    // The conversation IS the record of what the agent did — the whole point of
+    // codehere. Show it by DEFAULT whenever there are steps (was collapsed under
+    // any report, which hid a 20-step run entirely). Only a report-with-no-steps
+    // leaves it closed. The user's own toggle is still remembered per task.
+    let _convOpen=Object.prototype.hasOwnProperty.call(_convOpenByTask,_convSid)?!!_convOpenByTask[_convSid]:(steps.length>0||!hasReportText);
+    try{
+      const _dvEl=document.getElementById('detail-view');
+      if(_dvEl && _dvEl.getAttribute('data-sid')===_convSid){
+        const _cw=_dvEl.querySelector('details.conv-wrap');
+        if(_cw){ _convOpen=_cw.open; _convOpenByTask[_convSid]=_convOpen; }
+      }
+    }catch(e){}
+    const _nTurns=Array.isArray(t.turns)?t.turns.length:0;
+    const _cBits=['conversation'];
+    if(_nTurns) _cBits.push(_nTurns+' turn'+(_nTurns===1?'':'s'));
+    if(nStep) _cBits.push('every tool call recorded');
+    convWrap='<details class="conv-wrap" data-sid="'+convHe(_convSid)+'" ontoggle="__rememberConvOpen(this)"'+(_convOpen?' open':'')+'><summary class="convrow">'+_cBits.join(' \\u00b7 ')+' <span class="kbd">\\u23ce</span></summary>'+_tlHtml+'</details>';
+  }
+  // DEEP-4 · the runs-timeline — when this task has SIBLING runs (same title),
+  // show a compact strip so you can move between the runs of one task (e.g.
+  // Conductor stalled -> Claude Code errored). Reuses the group key (title).
+  // Sibling = same title AND same cwd, never Untitled, never demo/practice —
+  // without those guards every untitled task claims unrelated "runs" and mock
+  // fixtures show up as pills beside a real run (cold-review P1).
+  var _tKey=title(t.prompt);
+  var _sibs=(_tKey&&_tKey!=='Untitled')?allS(_cached.tasks||{}).filter(function(x){
+    return String(x.sessionId||'') && title(x.prompt)===_tKey
+      && String(x.cwd||'')===String(t.cwd||'')
+      && (/^demo-/.test(String(x.sessionId||''))===/^demo-/.test(String(t.sessionId||'')))
+      && (!!x.mockRun===!!t.mockRun);
+  }):[];
+  var _runsStrip='';
+  if(_sibs.length>1){
+    _sibs.sort(function(a,b){ return (b.startedAt||0)-(a.startedAt||0); });
+    _runsStrip='<div class="runs-strip"><span class="runs-strip-lbl">'+_sibs.length+' runs of this task</span>'
+      +_sibs.map(function(x){ var rc=rowClaims(x); var cur=(x.sessionId===t.sessionId); var cc=(x.cost&&typeof x.cost.spent==='number')?'$'+(x.cost.spent/100).toFixed(2):'';
+        var sid=String(x.sessionId||'').replace(/[^A-Za-z0-9._:-]/g,'');
+        return '<button class="runs-pill st-'+rc.cls+(cur?' cur':'')+'" type="button"'+(cur?' aria-current="true"':' onclick="showD(\\''+sid+'\\')"')+'><span class="rp-who">'+convHe(agentLabel(x.agent))+'</span><span class="rp-st">'+convHe(rc.word)+'</span>'+(cc?'<span class="rp-c">'+cc+'</span>':'')+'</button>'; }).join('')
+      +'</div>';
+  }
+  const _hdrHtml='<div class="detail-header">'
+    +'<span class="back-btn" onclick="hideD()">\\u2190 today \\u00b7 <span class="kbd">Esc</span></span>'
+    +'<div class="detail-title-wrap">'
+    +'<div class="detail-kicker">'+kicker+'</div>'
+    +'<h1 class="detail-title" data-user-content>'+titleH(t.prompt)+'</h1>'
+    +'</div>'
+    +'</div>'
+    +_runsStrip;
+  // S2 · the moment you stop trusting a run is the moment you're looking at
+  // it — the Stop control lives on the detail too, not just the list card.
+  const _stopHero=(['running','queued','paused'].includes(t.status)?'<button class="stop-hero" data-verify-action="stop" title="Stop this agent now" onclick="stopTask(event,\\''+t.sessionId+'\\')">\\u25A0 Stop this agent</button>':'');
+  // S14 · one mono meta line. The status word lives in the kicker above
+  // (AGENT · STATUS) — the duplicated status-icon row died with the hero.
+  // The data-verify contract (status/terminal-fail/has-explanation) rides on
+  // the meta in EVERY lens — H6 reads the same truth everywhere.
+  // Terminal numbers (cost · files · tests · time) live in the summary
+  // receipt — the meta stopped restating them and keeps the run scaffolding.
+  const _metaAttrs=' data-verify-unit="detail" data-verify-status="'+s+'" data-verify-terminal-fail="'+(isFailed?'true':'false')+'" data-verify-has-explanation="'+(!!(blockHtml||crashHtml||recoveryHtml||pushHtml||t.stalledReason)?'true':'false')+'"';
+  const _metaBits=[];
+  if(!isTerminal){ _metaBits.push(d); if(co!==null) _metaBits.push(costPill(co)); }
+  // terminal always states its step count — "0 steps" is honest; an empty
+  // meta line is the empty-container lie (verify-distill loop-2 finding).
+  if(steps.length||isTerminal) _metaBits.push(steps.length+' step'+(steps.length===1?'':'s'));
+  if(_artTrig) _metaBits.push(_artTrig);
+  const _metaHtml='<div class="detail-meta"'+_metaAttrs+'>'+_metaBits.join(' \\u00B7 ')+_stopHero+'</div>';
+  // S20 · STATUS lens — outcomes only: the summary object (glance · verdict ·
+  // receipt) IS the outcomes-only view. Zero steps/tools/timeline. Honesty
+  // survives the lens: decision blocks, failure notes and the amber/red
+  // verdict line always render. Real template branch, not CSS hiding.
+  if(_lens==='status'){
+    writeDetail(t, _hdrHtml
+      +_metaHtml
+      +summHtml
+      +cvHtml
+      +provenanceHtml+recoveredHtml
+      +blockHtml+pushHtml+crashHtml
+      +recoveryHtml+yourCallBroken
+      +gitNoteHtml);
+    return;
+  }
+  // S20 · REVIEW lens — the trust job: the summary object (verdict inside) +
+  // evidence + provenance + any pending decision move to the TOP; the audit
+  // reconciliation is elevated; the conversation rests collapsed; eng detail
+  // keeps its tail seat.
+  if(_lens==='review'){
+    writeDetail(t, _hdrHtml
+      +summHtml
+      +cvHtml
+      +oHtml
+      +provenanceHtml+recoveredHtml
+      +recoveryHtml+yourCallBroken
+      +blockHtml+pushHtml+crashHtml
+      +auditReconHtml
+      +_metaHtml
+      +contractBlockHtml(t)
+      +chipsHtml+gitNoteHtml
+      +convWrap
+      +tokenHtml+(_convShown?'':traceHtml)
+      +_artDrawer);
+    return;
+  }
+  // Conversation-first anatomy (2026-06-19, Ega's design direction): the
+  // conversation IS the hero. Order: header + meta -> any failure/decision block
+  // (the one thing that must interrupt) -> the agent's words + the thread (the
+  // body) -> a COMPACT verdict marker + cross-vendor proof ONLY when it's real
+  // -> then evidence table, audit recon, eng detail rest at the bottom as
+  // progressive disclosure. No trust scaffolding stacked on top of the content;
+  // no panel that exists only to explain what didn't happen.
+  // Phase 2 · the heavy evidence / audit / token detail rests behind ONE calm
+  // disclosure so the default view stays conversation-first (mockup parity).
+  // Content stays in the DOM (collapsed), so the verify harness still reads its
+  // data-verify-* data; only the visual noise is tucked away.
+  const _detailDrawer = (oHtml || auditReconHtml || tokenHtml)
+    ? '<details class="conv-wrap" data-verify-unit="evidence-disclosure"><summary>evidence \\u00b7 audit \\u00b7 tokens</summary>' + oHtml + auditReconHtml + tokenHtml + '</details>'
+    : '';
+  writeDetail(t, _hdrHtml
+    +provenanceHtml
+    +recoveredHtml
+    +_metaHtml
+    +blockHtml+pushHtml+crashHtml
+    +recoveryHtml+yourCallBroken
+    +contractBlockHtml(t)
+    +summHtml
+    +convWrap
+    +cvHtml
+    +chipsHtml+gitNoteHtml
+    +_detailDrawer
+    +(_convShown?'':traceHtml)
+    +_artDrawer);
+}
+
+${RECOVERY_ACTIONS}
+
+${CONTEXT_SOURCES}
+${SETTINGS_DRAWER}
+
+${AUDIT_CHAIN_VERIFY}
+
+function al(m){const e=document.getElementById('toast');if(e){e.textContent=m;e.style.display='block';setTimeout(()=>{e.style.display='none';},3000);}}
+
+${COMPOSER_COST}
+${SHARE_MODAL}
+${OVERLAY_RENDERER}
+
+${WPASS_MODAL}
+
+  // Fix · local pill should reflect the ACTUAL host:port, not the hardcoded
+  // 127.0.0.1:3773 (a user on --port 3899 would see the wrong pill).
+  const localHostEl = document.getElementById('local-host');
+  if(localHostEl) localHostEl.textContent = window.location.host;
+
+  document.addEventListener('keydown', (e)=>{
+    if(e.key==='Escape'){
+      if(document.getElementById('palette-scrim')?.classList.contains('open')){ e.preventDefault(); closePalette(); }
+      else if(document.getElementById('settings-drawer')?.classList.contains('open')) closeDrawer();
+      else if(document.getElementById('share-modal')?.classList.contains('open')) closeShare();
+      else if(document.getElementById('wp-modal')?.classList.contains('open')) wpCloseModal();
+      // Fix D-ESC (2026-05-23) · overlay-renderer Esc handler · was missing
+      else if(document.getElementById('or-overlay')?.classList.contains('open')) orClose();
+      else if(document.getElementById('reshape-modal')?.classList.contains('open')) closeReshape();
+    }
+  });
+  Promise.resolve(fetchAll()).then(function(){ _routeFromHash(); }); // hydrate a deep-link (/#/task/:id) after the first load
+
+  const es=new EventSource('/api/events/sessions');
+  let pollTimer=setInterval(fetchAll,30000), sseTimer=null;
+  es.addEventListener('message',e=>{try{const m=JSON.parse(e.data);if(m.type==='change')fetchAll();}catch{}});
+  es.addEventListener('error',()=>{
+    clearInterval(pollTimer);pollTimer=setInterval(fetchAll,8000);
+    if(sseTimer)clearTimeout(sseTimer);
+    sseTimer=setTimeout(()=>{clearInterval(pollTimer);pollTimer=setInterval(fetchAll,30000);sseTimer=null;},60000);
+  });
+  es.addEventListener('open',()=>{if(sseTimer){clearInterval(pollTimer);pollTimer=setInterval(fetchAll,8000);setTimeout(()=>{clearInterval(pollTimer);pollTimer=setInterval(fetchAll,30000);},10000);}});
+
+  setInterval(pollHealth, 8000);
+  pollHealth();
+
+${AUDIT_FOOTER}
+${FAILOVER_BANNER}
+`;
+//# sourceMappingURL=app-script.js.map