samagotchi 0.134.0 → 0.136.0

data/lib/samagotchi/web/public/app.js

@@ -35,17 +35,20 @@ import {
 import { authProbe, createAuthLost } from "./auth_lost.js";
 import { REPLACE_SESSION_TEXT, fragmentCode, tradeFragmentCode } from "./token_fragment.js";
 import { createContextChips } from "./context_chips.js";
-import { createLlmContextControl } from "./llm_context_chip.js";
 import { createParticipantsControl } from "./participants_panel.js";
-import { createThinkingControl } from "./thinking_chip.js";
-import { createReasoningHistoryControl } from "./reasoning_history_chip.js";
+import { createSettingsControl } from "./settings_chip.js";
 import { renderInfoBar } from "./info_bar.js";
 import { sessionBar, workerBadgeFor } from "./info_bar_model.js";
 import { createShownTexts } from "./shown_texts.js";
 import { emptySessionState, sessionStateFrom } from "./session_state.js";
+import { sessionFieldsFrom } from "./session_payload.js";
+import { fieldsFromCard } from "./session_fields.js";
+import { createSessionStore } from "./session_store.js";
+import { createFeatureGates } from "./feature_gates.js";
+import { stillOn } from "./latest.js";
 import { thumbsTemplate } from "./images.js";
-import { normalize, failedTurnText, cantText, withLiveStatus, withoutWorker } from "./format.js";
-import { createTurnView, turnHistoryNodes } from "./turn_view.js";
+import { normalize, failedTurnText, cantText, withoutWorker } from "./format.js";
+import { turnHistoryNodes } from "./turn_block.js";
 import { elementOf, emptyAnswerTemplate } from "./turn_html.js";
 import { createBubbles, hintEl, outputBubbleTemplate } from "./bubbles.js";
 import { createCardsPlace } from "./cards_place.js";
@@ -69,6 +72,7 @@ import { OWNER_FINAL, verifyTurnOf } from "./verify_target.js";
 import { actionLine, annotationActions, composerWithAction } from "./annotate_actions.js";
 import { copyText, installCopy } from "./copy.js";
 import { installAnswerFold, sweepAnswerFolds } from "./answer_fold.js";
+import { answerLabel, installReviseStacks, reviseChipTemplate, reviseWorkerUnavailable } from "./revise_stack.js";
 import { createQuestionCards } from "./question_cards.js";
 import { splitSnapshotCards } from "./card.js";
 import { PROMPT_LINE_PX, PROMPT_MIN_PX } from "./composer_size.js";
@@ -149,30 +153,14 @@ const contextChips = createContextChips({
   api: { list: listContext, show: getContext, detach: detachContext, add: addContext },
   toast: (text) => showToast(text),
 });
-// The open session's LLM context chip in the info bar, and its popover:
-// /llm-context runs in the session's worker.
-const llmContextControl = createLlmContextControl({
+// The open session's ⚙ chip in the info bar, and its panel (thinking,
+// reasoning history, LLM context): a pick runs its command in the session's
+// worker.
+const settingsControl = createSettingsControl({
   el: infoTextEl,
-  summary: () => (selected ? current.llmContext : null),
-  session: () => selected,
-  running: () => liveTurn.running,
-  run: (line) => runSessionCommand(line),
-});
-// The open session's thinking chip, beside the llm ctx one: /thinking runs
-// in the session's worker.
-const thinkingControl = createThinkingControl({
-  el: infoTextEl,
-  summary: () => (selected ? current.thinking : null),
-  session: () => selected,
-  running: () => liveTurn.running,
-  run: (line) => runSessionCommand(line),
-});
-// The open session's reasoning history chip, after the thinking one (a
-// chat host's only): /reasoning-history runs in the session's worker.
-const reasoningHistoryControl = createReasoningHistoryControl({
-  el: infoTextEl,
-  summary: () => (selected ? current.reasoningHistory : null),
-  session: () => selected,
+  summaries: () => (store.selected ? { thinking: store.current.thinking, reasoningHistory: store.current.reasoningHistory,
+                                       llmContext: store.current.llmContext } : null),
+  session: () => store.selected,
   running: () => liveTurn.running,
   run: (line) => runSessionCommand(line),
 });
@@ -180,10 +168,10 @@ const reasoningHistoryControl = createReasoningHistoryControl({
 // (Invite, revoke, caps, the participant view).
 const participantsControl = createParticipantsControl({
   el: infoTextEl,
-  session: () => selected,
+  session: () => store.selected,
   api: { list: listParticipants, invite: inviteParticipant, revoke: revokeParticipant, cap: setParticipantCap },
   startReview: (opts) => sessionActions.reviewSelected(opts),
-  reviewing: () => sessionActions.reviewing.has(selected),
+  reviewing: () => sessionActions.reviewing.has(store.selected),
   // An older prompt drawn before the list came says "a participant": named now.
   onNames: () => {
     nameUnnamedBadges(document);
@@ -192,7 +180,7 @@ const participantsControl = createParticipantsControl({
       return badge && !badge.unnamed ? badge.name : null;
     });
   },
-  onChange: () => updateInfoBar(),
+  onChange: () => store.touch("infoBar"),
   toast: (text, action, options) => showToast(text, action, options),
 });
 // The start page's model picker, its ⚙ panel and 🧰 list with the override chips
@@ -210,10 +198,10 @@ const startPage = createStartPage({
   reviewEl: $("#reviewNew"),
   toolkitBtnEl: $("#toolkitBtn"),
   toolkitEl: $("#toolkitNew"),
-  selected: () => selected,
-  state: () => current,
+  selected: () => store.selected,
+  state: () => store.current,
   running: () => liveTurn.running,
-  sessions: () => allSessions,
+  sessions: () => store.sessions,
   run: (line) => runSessionCommand(line),
   focusPrompt: () => focusPrompt(),
   toast: (text) => showToast(text),
@@ -238,8 +226,65 @@ const attachInput = $("#attachInput");
 const infoCancelBtn = $("#infoCancelBtn");
 const composeHintEl = $("#composeHint");
 
-let selected = null;
+// The open session (store.selected), its fields (store.current: session_state.js;
+// forgetSession() starts them over) and every card (store.sessions, the hub's
+// projection): session_store.js. Read store.current fresh after every await.
+// A write redraws what reads it (the redraws are registered below, before
+// the page's first draw); an input the store doesn't hold calls
+// store.touch(name).
+const store = createSessionStore({ initial: emptySessionState() });
+// The page actions the open session's worker must support (feature_gates.js),
+// the store's featureGates redraw: a gate's redraw runs when its answer
+// flips (a restart brings the feature, the worker goes). forgetSession and
+// renderSessionView prime them: the history they draw has the answer already.
+const featureGates = createFeatureGates([
+  // Verify fresh on a verdict's card.
+  {
+    name: "verify",
+    unavailable: (cur) => verifyWorkerUnavailable(cur.workerFeatures, cur.bridgeUp),
+    redraw: () => redrawFresh(historyEl, verifyFreshState()),
+  },
+  // Revise on an answer and the composer's Revising chip (revise_stack.js).
+  {
+    name: "revise",
+    unavailable: (cur) => reviseWorkerUnavailable(cur.workerFeatures, cur.bridgeUp),
+    redraw: () => redrawRevise(),
+  },
+]);
+featureGates.prime(store.current);
+// The open session's id, for the stale-answer guards (latest.js stillOn).
+const openId = () => store.selected;
 let pendingVerifyAnchor = null;
+// The composer's armed Revise ({turn_id, label}: the answer the next
+// message rewrites), shown as its chip; Verify's lifecycle (an emptied
+// composer, another session, the send's ack let go of it). Set only
+// through setReviseAnchor (it redraws the chip and the answers' buttons).
+let pendingReviseAnchor = null;
+let reviseStacks = null;
+const reviseChipEl = $("#reviseChip");
+const reviseUnavailable = () => reviseWorkerUnavailable(store.current.workerFeatures, store.current.bridgeUp);
+function redrawRevise() {
+  if (reviseChipEl) {
+    render(reviseChipTemplate(pendingReviseAnchor, {
+      unavailable: reviseUnavailable(),
+      onClear: () => { setReviseAnchor(null); focusPrompt(); },
+    }), reviseChipEl);
+    reviseChipEl.hidden = !pendingReviseAnchor;
+  }
+  reviseStacks?.decorate();
+}
+function setReviseAnchor(anchor) {
+  if (anchor === pendingReviseAnchor) return;
+  pendingReviseAnchor = anchor;
+  redrawRevise();
+}
+// A restored Revise turn's draft ({turn_id}): armed again, its label from
+// the answer it names.
+function restoreRevise(anchor) {
+  if (!anchor?.turn_id) return;
+  const answer = historyEl.querySelector(`.bubble.output[data-answer-turn="${CSS.escape(anchor.turn_id)}"]`);
+  setReviseAnchor({ turn_id: anchor.turn_id, label: answerLabel(answer) });
+}
 let annotateBar = null;
 // The session the composer's text was last written in ("" the start page,
 // undefined unknown): the composer is one for every session, and continue →
@@ -248,7 +293,7 @@ let draftFrom;
 // Record that the composer's text was written now, in session +id+ (default
 // the open one). Every write of text into the composer comes through here.
 function noteDraft(id) {
-  draftFrom = id ?? selected ?? "";
+  draftFrom = id ?? store.selected ?? "";
 }
 let streamControl = null;
 // The session list's stream (GET /api/events); null while the page falls
@@ -258,31 +303,14 @@ let eventsControl = null;
 // session while one ran (its bridge_up event): the tail runs once more.
 let resyncsInFlight = 0;
 let resyncAgain = false;
-let allSessions = [];
 // The running turn's texts on the page (the turn output dedupe).
 const shownTexts = createShownTexts();
-// The page's view of a turn (web.view, or ?view=stage|turn): the running
-// turn pinned above the composer (the stage, stage_view.js), or one block
-// per turn with its steps in the history (turn_view.js).
-const view = ["stage", "turn"].includes(document.body.dataset.view) ? document.body.dataset.view : "stage";
-// The running turn's DOM: the turn block, or the stage (the turn block in
-// its cloud).
-const viewArgs = {
-  historyEl,
-  appendToHistory: (el) => appendToHistory(el),
-  isNearBottom: () => isNearBottom(),
-  sawText: (k) => shownTexts.saw(k),
-  sessionId: () => selected,
-  // The stop-task button on a running task_wait, for a worker that has
-  // the route (its sidecar features).
-  taskStop: createTaskStopper({ sessionId: () => selected, features: () => current.workerFeatures }),
-};
 const markdownPlace = createMarkdownPlace({
   capabilities: () => pageCapabilities,
   renderText,
   roots: () => turnRoots(),
   touchedFiles,
-  currentDir: () => current.dir,
+  currentDir: () => store.current.dir,
   linkRefs,
   applyFinalAnswer,
   findInTurnRoots: (selector) => findInTurnRoots(selector),
@@ -295,28 +323,38 @@ const { renderMarkdown, pairRefsIn, linkRefsIn, applyFinalMarkdown, linkTextRefs
 // The stage view's working set (web.working_set, or ?working_set=1|0):
 // what each turn brought into context, in a rail in the stage, a footprint
 // under each finished turn and a "set N" chip in the mem chip's place
-// (working_set_view.js). The turn view ignores it.
-const workingSet = view === "stage" && document.body.dataset.workingSet === "1"
+// (working_set_view.js).
+const workingSet = document.body.dataset.workingSet === "1"
   ? createWorkingSet({
-    historyEl, stageRoot: () => turnDom.root, state: () => current, session: () => selected, infoEl: infoTextEl,
-    onChange: () => updateInfoBar(), getWorkingSet,
+    historyEl, stageRoot: () => turnDom.root, state: () => store.current, session: () => store.selected, infoEl: infoTextEl,
+    onChange: () => store.touch("infoBar"), getWorkingSet,
     // A drop or undrop from the list: the session's command, as typed.
-    sendLine: (line) => (selected ? sendCommand(selected, line, { clientId }) : null),
+    sendLine: (line) => (store.selected ? sendCommand(store.selected, line, { clientId }) : null),
   })
   : null;
 document.body.classList.toggle("working-set", !!workingSet);
-const turnDom = view === "stage"
-  ? createStageView({
-    ...viewArgs, isNearBottom: () => atHistoryEnd(), dockEl: $("#dock"), centerEl: $("#center"),
-    renderMarkdown, linkRefs: linkRefsIn, workingSet,
-  })
-  : createTurnView(viewArgs);
+// The running turn's DOM: the stage pinned above the composer
+// (stage_view.js), the turn block (turn_block.js) in its cloud.
+const turnDom = createStageView({
+  historyEl,
+  isNearBottom: () => atHistoryEnd(),
+  sawText: (k) => shownTexts.saw(k),
+  sessionId: () => store.selected,
+  // The stop-task button on a running task_wait, for a worker that has
+  // the route (its sidecar features).
+  taskStop: createTaskStopper({ sessionId: () => store.selected, features: () => store.current.workerFeatures }),
+  dockEl: $("#dock"),
+  centerEl: $("#center"),
+  renderMarkdown,
+  linkRefs: linkRefsIn,
+  workingSet,
+});
 // The history's bottom reserve and the toast's place follow the composer
 // card and the stage floating over the history (dock_reserve.js).
 const { placeToast } = createDockReserve({
   dockEl: $("#dock"),
   centerEl: $("#center"),
-  stageEl: view === "stage" ? turnDom.root : null,
+  stageEl: turnDom.root,
   historyEl,
   toastEl: $("#toast"),
   modelPanelEl: $("#modelPanel"),
@@ -325,29 +363,26 @@ const { placeToast } = createDockReserve({
 // Where a running turn's rows can be: the history, and the stage while it
 // holds a turn (lookups by id, copy, annotate, card actions).
 function turnRoots() {
-  return turnDom.root ? [historyEl, turnDom.root] : [historyEl];
+  return [historyEl, turnDom.root];
 }
-const systemOneWrongAction = createSystemOneWrongAction({ sessionId: () => selected });
+const systemOneWrongAction = createSystemOneWrongAction({ sessionId: () => store.selected });
 turnRoots().forEach((root) => root.addEventListener("click", systemOneWrongAction));
 function findInTurnRoots(selector) {
   return turnRoots().flatMap((root) => [...root.querySelectorAll(selector)]);
 }
-// The open session's fields (session_state.js); resetSessionState() starts
-// them over.
-let current = emptySessionState();
 // The running turn as the page follows it (live_turn.js): whether one
 // runs, its timing line and the turns this page saw end (live_timing.js),
 // its merges' bubble flags, its turn-end reads.
 const liveTurn = createLiveTurn({
-  timing: () => current.timing,
+  timing: () => store.current.timing,
   // The stage's status row while it holds the turn (the line moves into
   // the history with it), else the history.
   place: (el) => {
-    const stageHost = turnDom.timingHost?.() || null;
+    const stageHost = turnDom.timingHost();
     (stageHost || historyEl).appendChild(el);
     return !!stageHost;
   },
-  onTick: () => updateInfoBar(),
+  onTick: () => store.touch("infoBar"),
 });
 
 // The composer's delivery line while the open session's turn runs
@@ -356,22 +391,22 @@ const liveTurn = createLiveTurn({
 const deliveryControl = createDeliveryControl({
   el: $("#deliveryLine"),
   read: () => {
-    const turn = turnDom.current?.().turn || null;
+    const turn = turnDom.current().turn || null;
     const running = turn ? turn.gens.flatMap((g) => g.tools).reverse().find((r) => r.status === "running") : null;
     return {
-      phase: turnDom.phase?.() || liveSlots(turn).phase,
+      phase: turnDom.phase() || liveSlots(turn).phase,
       gen: turn ? currentGen(turn) : null,
       tool: running ? { name: toolName(running), startedAt: running.startedAt ?? null } : null,
       cutAfter: liveTurn.cutAfter,
       serverGen: liveTurn.serverGen,
-      canQueue: current.workerFeatures.includes("delivery"),
-      model: current.model,
+      canQueue: store.current.workerFeatures.includes("delivery"),
+      model: store.current.model,
       participantTurn: !!liveTurn.participantTurn,
     };
   },
   composerEmpty: () => !composer.hasDraft(),
   send: (delivery) => handleSendTurn({ delivery }),
-  session: () => selected,
+  session: () => store.selected,
 });
 
 // This tab's id in the session's events: tells its own prompts from the
@@ -379,7 +414,7 @@ const deliveryControl = createDeliveryControl({
 const clientId = newClientId();
 // The question and continue cards in the history (question_cards.js).
 const questionCards = createQuestionCards({
-  sessionId: () => selected,
+  sessionId: () => store.selected,
   clientId,
   place: (card) => appendToHistory(card),
   isNearBottom: () => isNearBottom(),
@@ -400,7 +435,7 @@ const bubbles = createBubbles({
   findInTurnRoots: (selector) => findInTurnRoots(selector),
   shownTexts,
   liveTurn,
-  selected: () => selected,
+  selected: () => store.selected,
   clientId,
 });
 const {
@@ -415,7 +450,7 @@ const cards = createCardsPlace({
   historyEl,
   turnDom,
   findInTurnRoots: (selector) => findInTurnRoots(selector),
-  selected: () => selected,
+  selected: () => store.selected,
   clientId,
   questionCards,
   bubbles,
@@ -450,23 +485,22 @@ let foldsSwept = false;
 function sweepFoldsOnce() {
   if (foldsSwept) return;
   foldsSwept = true;
-  sweepAnswerFolds(allSessions, { scoped: !!scope.dir });
+  sweepAnswerFolds(store.sessions, { scoped: !!scope.dir });
 }
 
 // The list by fetching: the fallback when there is no events stream (a
 // chi web without a hub, or ?dir the server refused: the 400 is read here).
 async function refresh() {
   try {
-    allSessions = await listSessions("updated_at", "desc", { dir: scope.dir });
-    notifications.noticeList(allSessions);
+    store.update({ sessions: await listSessions("updated_at", "desc", { dir: scope.dir }) });
+    notifications.noticeList(store.sessions);
     sweepFoldsOnce();
   } catch (e) {
     if (e.status !== 400 || !scope.dir) throw e;
     scopeError = e.message;
-    allSessions = [];
+    store.update({ sessions: [] });
     renderScope();
   }
-  lists.render();
 }
 
 // The list as a projection of the hub's events: a snapshot on every
@@ -474,35 +508,27 @@ async function refresh() {
 // worker follow its events (a new worker's bridge_up reconnects the stream).
 function openSessionEvents() {
   eventsControl = openEvents({
-    snapshot: (data) => {
+    // The list redraws the lists and the bar (its children chip, its chain's
+    // ← → links): store.update({sessions}).
+    snapshot: (data) => store.batch(() => {
       noticeVersions(data);
       if (updateSheet.reconnected(data.version)) showToast(`chi web reconnected on chi ${data.version}`);
       if (data.chi_update) updateFrame(data.chi_update, { snapshot: true });
       notifications.noticeSessions("snapshot", data);
-      allSessions = applySessionEvent(allSessions, "snapshot", data);
+      store.update({ sessions: applySessionEvent(store.sessions, "snapshot", data) });
       sweepFoldsOnce();
-      lists.render();
-      const sess = allSessions.find((s) => s.id === selected);
+      const sess = store.sessions.find((s) => s.id === store.selected);
       if (sess) followSelectedSession(sess);
-    },
-    session: (data) => {
+    }),
+    session: (data) => store.batch(() => {
       notifications.noticeSessions("session", data);
-      allSessions = applySessionEvent(allSessions, "session", data);
-      lists.render();
-      if (data.session && data.session.id === selected) followSelectedSession(data.session);
-      // Its children chip; its chain's ← → links (a link that continues it, its previous one).
-      else if (selected && (data.session?.parent_id === selected || data.session?.continues === selected
-                            || (data.session?.id && data.session.id === current.continues))) updateInfoBar();
-    },
+      store.update({ sessions: applySessionEvent(store.sessions, "session", data) });
+      if (data.session && data.session.id === store.selected) followSelectedSession(data.session);
+    }),
     session_gone: (data) => {
       notifications.noticeSessions("session_gone", data);
       lists.forget(data.id);
-      const next = applySessionEvent(allSessions, "session_gone", data);
-      if (next !== allSessions) {
-        allSessions = next;
-        lists.render();
-        if (selected) updateInfoBar(); // a deleted child leaves the children chip, a deleted chain link its ← → link
-      }
+      store.update({ sessions: applySessionEvent(store.sessions, "session_gone", data) });
       leaveGoneSession(data.id, "deleted");
     },
     chi: (data) => noticeVersions(data),
@@ -548,7 +574,7 @@ function noticeVersions(data) {
   const notice = versionNotice({ loaded: document.body.dataset.version, served: versions.served,
                                  installed: versions.installed, available: versions.available,
                                  updateBlocked: versions.updateBlocked, shown: versionNoticesShown });
-  updateInfoBar(); // the worker badge compares with the newest installed
+  store.touch("infoBar"); // the worker badge compares with the newest installed
   if (!notice) return;
   versionNoticesShown.add(notice.key);
   if (notice.key.startsWith("available:")) writeStored(AVAILABLE_SHOWN_KEY, notice.key.slice("available:".length));
@@ -603,18 +629,13 @@ function copyUpdateCommand(command) {
 // (a turn another client sent woke one, or a replacement after a kill)
 // gets the stream attached through one resync.
 function followSelectedSession(sess) {
-  current.owner = sess.owner || null;
-  current.workerVersion = sess.worker_version || null;
-  const verifyWas = verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp);
-  current.workerFeatures = Array.isArray(sess.worker_features) ? sess.worker_features : [];
-  current.bridgeUp = sess.bridge_up === true;
-  // The Verify gate flipped (a restart brought the feature): the cards' Verify fresh part follows.
-  if (verifyWas !== verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp)) {
-    redrawFresh(historyEl, verifyFreshState());
-  }
   const streaming = !!(streamControl && streamControl.live);
-  if (!streaming) current.status = sess.status;
-  updateInfoBar();
+  // A Verify gate that flips (a restart brought the feature) redraws the
+  // cards' Verify fresh part: featureGates.
+  store.batch(() => {
+    store.update({ current: fieldsFromCard(sess) });
+    store.setStatus(sess.status, "hub", { streaming });
+  });
   if (!sess.bridge_up || streaming) return;
   if (resyncsInFlight > 0) resyncAgain = true;
   else resync();
@@ -625,7 +646,7 @@ function followSelectedSession(sess) {
 // new session starts on the start page.
 function renderScope() {
   const el = $("#scope");
-  render(scopeTemplate(scope, { error: scopeError, where: () => ({ hash: location.hash, search: location.search }) }), el);
+  render(scopeTemplate(scope, { error: scopeError, where: () => ({ hash: location.hash }) }), el);
   el.hidden = false;
   // The tab: "<session title> · Chi · <project>" (updateSessionTitle).
   tabBase = scope.projectName ? `Chi · ${scope.projectName}` : "Chi";
@@ -634,7 +655,6 @@ function renderScope() {
 
 createProjectPicker({
   el: $("#scope"), scope, scopeError: () => scopeError, api,
-  where: () => ({ search: location.search }),
 });
 
 // The session lists (lists_view.js): the strip, all sessions, their cards,
@@ -644,8 +664,8 @@ const lists = createListsView({
   win: window,
   topStripEl,
   allListEl,
-  sessions: () => allSessions,
-  selected: () => selected,
+  sessions: () => store.sessions,
+  selected: () => store.selected,
   scope,
   scopeError: () => scopeError,
   eventsLive: () => !!eventsControl,
@@ -654,7 +674,6 @@ const lists = createListsView({
   confirmDelete: (id) => confirmDelete(id),
   setArchived: (id, archive) => setArchived(id, archive),
   archiveOne: (id, archive) => archiveOne(id, archive),
-  updateInfoBar: () => updateInfoBar(),
   updateSessionTitle: () => updateSessionTitle(),
   showToast: (text, action) => showToast(text, action),
   allViewOpen: () => allViewOpen(),
@@ -676,19 +695,17 @@ const stopSheet = createStopSheet({
 });
 
 const sessionActions = createSessionActions({
-  selected: () => selected,
-  state: () => current,
-  sessions: () => allSessions,
-  setSessions: (list) => { allSessions = list; },
+  selected: () => store.selected,
+  store,
+  sessions: () => store.sessions,
+  setSessions: (list) => store.update({ sessions: list }),
   api: { continueSession, startReview, archiveSession, unarchiveSession, deleteSession, stopSession,
          sessionHolds, stopSessionHolds },
   eventsLive: () => !!eventsControl,
   refresh,
-  lists,
   select,
   clearSelection,
   showNotice,
-  updateInfoBar,
   toast: showToast,
   addCreatedSession,
   fillOpener,
@@ -707,7 +724,7 @@ const rename = createRename({
     const row = topStripEl.querySelector(".card.active .preview-row");
     return row && row.getClientRects().length ? row : null; // not in the All sessions view's hidden strip
   },
-  session: () => selected,
+  session: () => store.selected,
   titleOf: (id) => lists.sessionsById().get(id)?.title || null,
   shownTitle: () => shownTitle(),
   closePopovers: () => {
@@ -741,7 +758,7 @@ function closeAllView() {
   if (allViewPushed) {
     history.back();
   } else {
-    leaveAllView(sessionHash(selected));
+    leaveAllView(sessionHash(store.selected));
   }
 }
 // Leave all sessions for a place of our own (a picked session, a new session):
@@ -768,7 +785,7 @@ function selectFromHash() {
   const claim = claimFromHash(location.hash);
   const id = sessionIdFromHash(location.hash) || claim?.sessionId || null;
   if (claim) pendingClaim = claim;
-  if (id && id !== selected) select(id);
+  if (id && id !== store.selected) select(id);
   else if (claim) showPendingClaim();
 }
 let pendingClaim = null;
@@ -781,10 +798,10 @@ const CLAIM_ROOTS = ".bubble.output, .bubble.user .user-message, .gen-text";
 // switched), so the same link opened again is a hashchange.
 function showPendingClaim() {
   const claim = pendingClaim;
-  if (!claim || claim.sessionId !== selected) return;
+  if (!claim || claim.sessionId !== store.selected) return;
   pendingClaim = null;
-  if (!allViewOpen() && location.hash !== sessionHash(selected)) {
-    history.replaceState(null, "", location.pathname + location.search + sessionHash(selected));
+  if (!allViewOpen() && location.hash !== sessionHash(store.selected)) {
+    history.replaceState(null, "", location.pathname + location.search + sessionHash(store.selected));
   }
   if (showClaim(historyEl, claim, { roots: CLAIM_ROOTS, opts: claimOpts() })) return;
   historyEl.scrollTop = 0;
@@ -792,25 +809,25 @@ function showPendingClaim() {
 }
 // How the participant page shows this page's text (claim_link.js).
 function claimOpts() {
-  return { home: document.body.dataset.home || "", cwd: current.dir || "" };
+  return { home: document.body.dataset.home || "", cwd: store.current.dir || "" };
 }
 // Annotate's "Copy link" for a selection in a turn's answer, step or own
 // message: the participant page's link when the session has a person
 // active (it opens in the browser their review link was opened in: one
 // link per browser, the cookie), else this page's own.
 function claimLinkFor(source, range) {
-  if (!selected || !["answer", "step", "user"].includes(source.kind) || !historyEl.contains(source.root)) return null;
+  if (!store.selected || !["answer", "step", "user"].includes(source.kind) || !historyEl.contains(source.root)) return null;
   const turnId = turnIdOf(historyEl, source.root);
   if (!turnId) return null;
   const claim = { turnId, ...selectionClaim(source.root, range, claimOpts()) };
   if (!claim.q) return null;
   const target = participantsControl.claimTarget();
   if (!target) {
-    return { url: `${location.origin}${location.pathname}${location.search}${ownerClaimHash(selected, claim)}`,
+    return { url: `${location.origin}${location.pathname}${location.search}${ownerClaimHash(store.selected, claim)}`,
              title: "A link to this on your page (no person is invited to this session)" };
   }
   const whose = target.names.map((name) => `${name}'s`).join(" or ");
-  return { url: participantClaimLink(target.base, selected, claim),
+  return { url: participantClaimLink(target.base, store.selected, claim),
            title: `A link to this for ${whose} browser: it opens where their review link was opened (one link per browser). Opened here, it shows your page.` };
 }
 async function copyClaimLink({ url }) {
@@ -833,8 +850,8 @@ function applyView() {
     lists.familyPop.close(); // the strip is hidden in the all view
     // The list is live; only its order can lag (upserts keep cards in
     // place), so the all view opens in the server's order.
-    allSessions = sortedByUpdated(allSessions);
-    lists.renderAll();
+    // A new list: the lists' redraw draws the all view (lists.render).
+    store.update({ sessions: sortedByUpdated(store.sessions) });
     if (!eventsControl) refresh();
     $("#filter").select();
   }
@@ -848,6 +865,8 @@ $("#allBack").addEventListener("click", closeAllView);
 // A phone's composer fits a few words and has no Shift+Enter: the short
 // placeholder there.
 const narrowScreen = window.matchMedia("(max-width: 600px)");
+// An input the store doesn't hold, with the composer as its only reader: a
+// direct call (the bar doesn't read it).
 narrowScreen.addEventListener("change", () => updateComposerMode());
 function setPlaceholder(long, short) {
   promptEl.placeholder = narrowScreen.matches ? short : long;
@@ -862,7 +881,7 @@ let hadSession = false;
 // its next step (steering). Cancel is its own button then.
 function updateComposerMode() {
   // In a session the box is one line: its minimum follows the class.
-  if (document.body.classList.toggle("has-session", !!selected) !== hadSession) {
+  if (document.body.classList.toggle("has-session", !!store.selected) !== hadSession) {
     hadSession = !hadSession;
     // Back on the start page: its remembered model, not the last link's.
     if (!hadSession) startPage.restoreStartPick();
@@ -871,12 +890,12 @@ function updateComposerMode() {
   }
   startPage.syncModelPick();
   // The start page's choice was for a new session: opening a session drops it.
-  if (selected) startPage.dropChoices();
-  const running = liveTurn.running && !!selected;
+  if (store.selected) startPage.dropChoices();
+  const running = liveTurn.running && !!store.selected;
   cancelBtn.style.display = running ? "" : "none";
   // No images for a session a terminal owns (it takes no message from here);
   // on a phone none while a turn runs either: Stop turn needs the row's room.
-  attachBtn.hidden = (!!selected && current.owner === "tui") || (running && narrowScreen.matches);
+  attachBtn.hidden = (!!store.selected && store.current.owner === "tui") || (running && narrowScreen.matches);
   syncDeliveryLine();
   if (running) {
     setPlaceholder("Running… a message goes in at the next step · Enter to send · Alt+Enter queues", "Steer the turn…");
@@ -885,15 +904,14 @@ function updateComposerMode() {
     emptyEl.classList.add("hidden");
     return;
   }
-  if (!selected) {
+  if (!store.selected) {
     setPlaceholder("Ask chi anything…", "Ask chi anything…");
     composeHintEl.textContent = "Enter to start · Shift+Enter for a newline";
     actionBtn.textContent = "Start";
     actionBtn.disabled = false;
     emptyEl.classList.remove("hidden");
     historyEl.replaceChildren();
-    updateInfoBar();
-  } else if (current.owner === "tui") {
+  } else if (store.current.owner === "tui") {
     setPlaceholder("A terminal chi owns this session · run it with chi --shared to send from here", "A terminal chi owns this session");
     composeHintEl.textContent = "";
     actionBtn.textContent = "Send";
@@ -913,31 +931,28 @@ function updateComposerMode() {
 // while idle, where a message goes in while the turn runs.
 function syncDeliveryLine() {
   // A terminal owns the session: the composer is off, so is its row.
-  if (!selected || current.owner === "tui") deliveryControl.show("off");
-  else deliveryControl.show(liveTurn.running && current.owner !== "tui" ? "running" : "idle");
+  if (!store.selected || store.current.owner === "tui") deliveryControl.show("off");
+  else deliveryControl.show(liveTurn.running && store.current.owner !== "tui" ? "running" : "idle");
 }
 
 function setTurnRunning(running) {
-  liveTurn.running = !!running;
-  // A fresh link's picker goes now, not at the timing re-read after the turn.
-  if (running && selected) current.turnStarted = true;
-  updateComposerMode();
-  updateInfoBar();
+  store.batch(() => {
+    liveTurn.running = !!running;
+    // A fresh link's picker goes now, not at the timing re-read after the turn.
+    if (running && store.selected) store.update({ current: { turnStarted: true } });
+    // liveTurn.running isn't the store's: the composer and the bar read it.
+    store.touch("composer");
+    store.touch("infoBar");
+  });
 }
 
 // Session status is turn state (idle/running): follow the live stream in the
 // info bar and the session's card without a refetch.
 function setLiveStatus(status) {
-  current.status = status;
-  const i = allSessions.findIndex((s) => s.id === selected);
-  if (i >= 0) {
-    // Its card gets the new dot and time; it keeps its place until the next
-    // snapshot or the all view re-sorts (no card jumping under the pointer;
-    // a session event replaces it in place too, see sessions_list.js).
-    allSessions[i] = withLiveStatus(allSessions[i], status);
-    lists.render();
-  }
-  updateInfoBar();
+  // Its card gets the new dot and time (withLiveStatus); it keeps its place
+  // until the next snapshot or the all view re-sorts (no card jumping under
+  // the pointer; a session event replaces it in place too, see sessions_list.js).
+  store.setStatus(status, "stream");
 }
 
 // Plugins' slow setup still running in the open session's worker (chi.init),
@@ -952,46 +967,52 @@ function onInitEvent(type, data) {
   const done = applyInitEvent(initTasks, type, data);
   renderInitRow();
   if (!done) return;
-  const session = selected;
+  const still = stillOn(openId);
   setTimeout(() => {
-    if (session !== selected) return;
+    if (!still()) return;
     fadeDone(initTasks, done);
     renderInitRow();
     setTimeout(() => {
-      if (session !== selected) return;
+      if (!still()) return;
       dropDone(initTasks, done);
       renderInitRow();
     }, 400);
   }, DONE_MS);
 }
 
-// Forget what the info bar, composer and command list knew about the open
-// session; select() and clearSelection() both start from here, so a field
-// the previous session set (its "delegated by" parent, its commands) never
-// shows for the next one.
-function resetSessionState() {
-  current = emptySessionState();
+// Forget everything the page knew about the open session: its fields (the
+// info bar, composer, command list), the turn on view, its stream and
+// question cards, its init row, the payload's markdown warning and tip and
+// capabilities, and the composer's Verify claim and Revise (+keepVerify+:
+// the same session opened again keeps them). The one reset list select() and
+// clearSelection() share, so a field the previous session set (its
+// "delegated by" parent, its commands, its card actions) never shows for
+// the next one, also when the next one's read fails.
+function forgetSession({ keepVerify = false } = {}) {
+  if (!keepVerify) pendingVerifyAnchor = null;
+  if (!keepVerify) setReviseAnchor(null);
+  store.batch(() => {
+    store.replaceCurrent(emptySessionState());
+    featureGates.prime(store.current);
+  });
   commandList.close();
-}
-
-function clearSelection() {
-  selected = null;
+  resetTurnView();
   seedInitTasks(initTasks, []);
   renderInitRow();
-  setSessionHash(null);
-  lists.paintActive();
-  resetSessionState();
-  contextChips.clear();
-  participantsControl.load(null);
-  liveTurn.forget();
-  setTurnRunning(false);
-  closeStream();
   setMarkdownWarning(null);
   markdownTip.show(null);
   setCapabilities(null, null);
   composer.newVisit();
-  updateComposerMode();
-  updateInfoBar();
+}
+
+function clearSelection() {
+  store.batch(() => {
+    store.update({ selected: null });
+    setSessionHash(null);
+    forgetSession();
+    contextChips.clear();
+    participantsControl.load(null);
+  });
   focusPrompt();
 }
 
@@ -1008,30 +1029,30 @@ function clearNotice() {
 }
 promptEl.addEventListener("input", clearNotice);
 promptEl.addEventListener("input", () => noteDraft());
-// An emptied composer lets go of its Apply turn and its Verify claim.
+// An emptied composer lets go of its Apply turn, its Verify claim and its
+// Revise.
 promptEl.addEventListener("input", () => {
   if (promptEl.value.trim()) return;
   deliveryControl.release();
   pendingVerifyAnchor = null;
+  setReviseAnchor(null);
 });
 
 async function select(id) {
   clearNotice();
-  if (selected !== id) pendingVerifyAnchor = null;
-  selected = id;
-  setSessionHash(id);
-  lists.paintActive();
-  historyEl.replaceChildren(hintEl("Loading…"));
-  emptyEl.classList.add("hidden");
-  closeStream();
-  resyncAttempts = 0; // this session has its own re-read budget
-  resetSessionState();
-  resetTurnView();
-  composer.newVisit();
-  updateInfoBar();
-  contextChips.load(id);
-  participantsControl.load(id);
-  updateComposerMode();
+  const same = store.selected === id;
+  // Its synchronous part in one batch: the active card, the composer and
+  // the bar redraw once, at its end (never across the await).
+  store.batch(() => {
+    store.update({ selected: id });
+    setSessionHash(id);
+    historyEl.replaceChildren(hintEl("Loading…"));
+    emptyEl.classList.add("hidden");
+    resyncAttempts = 0; // this session has its own re-read budget
+    forgetSession({ keepVerify: same });
+    contextChips.load(id);
+    participantsControl.load(id);
+  });
   await resync();
   // A folded composer stays folded: typing on the page opens it.
   focusPrompt({ open: false });
@@ -1049,19 +1070,19 @@ function resetTurnView() {
 }
 
 // A re-read that failed (the phone still offline, chi web a moment): try it
-// again, backing off, and stop when the tries run out. The turn view is left
-// alone meanwhile: a worker that still owns the turn keeps showing it running,
+// again, backing off, and stop when the tries run out. The running turn's DOM
+// is left alone meanwhile: a worker that still owns the turn keeps showing it running,
 // and the hub's next event for the session is the fallback once the tries end.
 const RESYNC_RETRIES = 3;
 let resyncAttempts = 0;
 
 function retryResync(id, { endText = null } = {}) {
-  if (id !== selected) return;
+  if (id !== store.selected) return;
   const { attempt, delayMs } = resyncRetry({ attempts: resyncAttempts, max: RESYNC_RETRIES, baseMs: STREAM_RETRY_MS });
   if (delayMs === null) return;
   resyncAttempts = attempt;
   setTimeout(() => {
-    if (id !== selected || (streamControl && streamControl.live)) return;
+    if (id !== store.selected || (streamControl && streamControl.live)) return;
     resync({ endText });
   }, delayMs);
 }
@@ -1076,7 +1097,7 @@ function retryResync(id, { endText = null } = {}) {
 // worker left unfinished; shown again after the re-render when no worker
 // took over.
 async function resync({ endText = null } = {}) {
-  const id = selected;
+  const id = store.selected;
   if (!id) return;
   resyncsInFlight += 1;
   let data;
@@ -1085,14 +1106,14 @@ async function resync({ endText = null } = {}) {
       data = await getSession(id, { parts: true });
     } catch (e) {
       if (e.status === 404) return leaveGoneSession(id, "not_found");
-      if (id === selected) {
+      if (id === store.selected) {
         historyEl.replaceChildren(hintEl(`Error: ${e.message}`));
         retryResync(id, { endText });
       }
       return;
     }
     resyncAttempts = 0;
-    if (id !== selected) return;
+    if (id !== store.selected) return;
     // An archived session opens folded: decided once per visit, from its
     // first answer (the list may not hold it yet, or ever under ?dir).
     composer.decideVisit(data.session?.archived);
@@ -1102,14 +1123,14 @@ async function resync({ endText = null } = {}) {
     showPendingClaim();
     // Preview is read-only: a worker is woken only by POST /turn, so attach
     // only when a live bridge exists.
-    current.streamSeq = typeof data.last_event_seq === "number" ? (data.last_event_id || data.last_event_seq) : null;
-    if (current.streamSeq !== null) startStream(id, current.streamSeq);
+    store.update({ current: { streamSeq: typeof data.last_event_seq === "number" ? (data.last_event_id || data.last_event_seq) : null } });
+    if (store.current.streamSeq !== null) startStream(id, store.current.streamSeq);
     else if (endText) addEndBubble(endText);
   } finally {
     resyncsInFlight -= 1;
     if (resyncsInFlight === 0 && resyncAgain) {
       resyncAgain = false;
-      if (id === selected && !(streamControl && streamControl.live)) resync();
+      if (id === store.selected && !(streamControl && streamControl.live)) resync();
     }
   }
 }
@@ -1124,12 +1145,16 @@ function renderSessionView(data, { kept = [] } = {}) {
   // The saved fill (when there is one) goes in here too, so a reloaded or
   // stopped session shows it before its next turn (a running turn's replay
   // below streams over it).
-  Object.assign(current, sessionStateFrom(data));
-  liveTurn.timing.ended = current.timing.turnRecords.length;
-  const activeTurnId = current.timing.activeTurn?.id || null;
-  llmContextControl.refresh();
-  thinkingControl.refresh();
-  reasoningHistoryControl.refresh();
+  const { status, ...fields } = sessionStateFrom(data);
+  // The fields in one batch (their chips' popovers, the bar); the replay's
+  // own redraws below stay where they run.
+  store.batch(() => {
+    store.update({ current: fields });
+    store.setStatus(status, "payload");
+    featureGates.prime(store.current);
+  });
+  liveTurn.timing.ended = store.current.timing.turnRecords.length;
+  const activeTurnId = store.current.timing.activeTurn?.id || null;
   if (data.messages && data.messages.length) renderHistory(data.messages);
   else renderHistory(data.history || []);
   seedWorkingSet(data);
@@ -1148,19 +1173,20 @@ function renderSessionView(data, { kept = [] } = {}) {
   const loadWarned = (label) => (data.cards || []).some((c) => c?.type === "guardrail_warning" && (c.label || "guardrails") === label);
   if (!loadWarned("guardrails")) showGuardrailWarning(data.guardrail_warning);
   if (!loadWarned("plugins")) showGuardrailWarning(data.plugin_warning, "plugins");
-  // The recap saved with the session (also a stopped one's), else a live
-  // worker's from before saved_recap existed.
-  if (data.saved_recap) showRecap(data.saved_recap.text, data.saved_recap.turns_since, data.saved_recap.created_at || null);
-  else showRecap(data.recap);
   // A live worker's last cards and between-turns notices, where they
   // arrived; the running turn's go into its step once it is drawn.
   const snapshotCards = splitSnapshotCards(data.cards, pageCapabilities);
   placeSnapshotCards(snapshotCards.placed);
+  // The recap saved with the session (also a stopped one's), else a live
+  // worker's from before saved_recap existed. After the cards: the last
+  // turn's check-in notice goes to the end, and the recap closes the page.
+  if (data.saved_recap) showRecap(data.saved_recap.text, data.saved_recap.turns_since, data.saved_recap.created_at || null);
+  else showRecap(data.recap);
   const replay = snapshotEvents({
     current_turn: data.current_turn,
     queued: data.queued,
     queued_commands: data.queued_commands,
-    started_at: current.timing.activeTurn?.started_at,
+    started_at: store.current.timing.activeTurn?.started_at,
   });
   // Marked replayed: a call's duration isn't timed from the replay's clock.
   replay.forEach((event) => streamHandlers[event.type]?.({ ...event, replayed: true }));
@@ -1168,8 +1194,8 @@ function renderSessionView(data, { kept = [] } = {}) {
   const gen = data.current_turn?.generation;
   liveTurn.serverGen = gen ? { ...gen, at: Date.now() } : null;
   if (!data.current_turn) {
-    setTurnRunning(current.status === "running");
-    if (liveTurn.running && current.timing.activeTurn?.started_at) liveTurn.timing.start(current.timing.activeTurn.started_at, activeTurnId);
+    setTurnRunning(store.current.status === "running");
+    if (liveTurn.running && store.current.timing.activeTurn?.started_at) liveTurn.timing.start(store.current.timing.activeTurn.started_at, activeTurnId);
   } else if (liveTurn.running) {
     // The replayed turn_started carries no id: the running turn's record's.
     liveTurn.timing.turnId = activeTurnId;
@@ -1180,7 +1206,7 @@ function renderSessionView(data, { kept = [] } = {}) {
   // A question the worker is blocked on (also after a reload).
   if (data.pending_question && data.pending_question.id && data.pending_question.status === "pending") {
     // Its refs on the asking step, as question_requested puts them.
-    if (data.pending_question.refs) turnDom.questionRefs?.(data.pending_question.refs);
+    if (data.pending_question.refs) turnDom.questionRefs(data.pending_question.refs);
     questionCards.renderQuestion(data.pending_question);
     // The turn's replay drew it as asked; the snapshot knows whether it is
     // relayed to the parent now.
@@ -1188,8 +1214,12 @@ function renderSessionView(data, { kept = [] } = {}) {
   }
   // A turn ran out of iterations and waits for a yes or no.
   if (data.continue_offer) questionCards.renderContinue(data.continue_offer);
-  updateInfoBar();
-  updateComposerMode();
+  // A whole view drawn: the composer and the bar once more (the working
+  // set's seed may change the bar's chip).
+  store.batch(() => {
+    store.touch("composer");
+    store.touch("infoBar");
+  });
 }
 
 // The working set's turns from a session's messages, as turnHistoryNodes
@@ -1198,7 +1228,7 @@ function renderSessionView(data, { kept = [] } = {}) {
 function seedWorkingSet(data) {
   if (!workingSet) return;
   const items = data.messages || [];
-  const groups = typeof items[0] === "object" && items[0]?.role ? turnGroups(items, current.timing).filter((g) => g.kind === "turn") : [];
+  const groups = typeof items[0] === "object" && items[0]?.role ? turnGroups(items, store.current.timing).filter((g) => g.kind === "turn") : [];
   if (data.current_turn && groups.length) groups.pop();
   workingSet.seed(groups.map((g, i) => {
     const text = String(items[g.user]?.content ?? "").replace(/\s+/g, " ").trim();
@@ -1213,10 +1243,10 @@ function renderHistory(items) {
     return;
   }
   if (typeof items[0] === "object" && items[0].role) {
-    historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsTemplate(selected, images), workingSet: !!workingSet }));
+    historyEl.replaceChildren(turnHistoryNodes(items, store.current.timing, { thumbs: (images) => thumbsTemplate(store.selected, images), workingSet: !!workingSet }));
     renderSavedVerdicts();
     // The live dividers count from the history's last activity.
-    gapClock.seed(lastActivity(turnGroups(items, current.timing), items));
+    gapClock.seed(lastActivity(turnGroups(items, store.current.timing), items));
     linkTextRefs();
   } else {
     historyEl.replaceChildren(...items.map((c) => elementOf(outputBubbleTemplate(c))));
@@ -1253,33 +1283,31 @@ installRefClicks(document.body, pageViewer, {
 });
 
 async function readTurnEnd() {
-  if (!selected) return;
-  const id = selected;
+  if (!store.selected) return;
+  const id = store.selected;
   // The line and the turn this read is for, before the await: a turn
   // queued behind this one may start (a new live line) before it lands.
   const line = liveTurn.timing.capture();
+  const still = stillOn(openId);
   try {
     const d = await getSession(id, { tail: true, recent: true, turnId: line.turnId });
-    if (id !== selected) return;
+    if (!still()) return;
     if (d.session) {
-      if (Array.isArray(d.session.used_memory_names)) current.usedMemories = d.session.used_memory_names;
-      // The notes chip: the first turn's build (or a /model) records them.
-      if (Array.isArray(d.session.prompt_notes)) current.promptNotes = d.session.prompt_notes;
-      if (d.session.status) current.status = d.session.status;
       if (!(await mergeTurnTiming(id, d.timing))) return;
       liveTurn.timing.finishLine(line);
-      setMarkdownWarning(d.markdown_warning);
-      markdownTip.show(d.markdown_tip);
-      setCapabilities(d.capabilities, d.editor_url);
-      if (Array.isArray(d.messages)) applyFinalMarkdown(d.messages);
-      updateInfoBar();
-      const sess = allSessions.find(s=>s.id===selected);
-      if (sess) {
-        sess.used_memory_names = current.usedMemories.slice();
-        sess.status = current.status;
-      }
-      lists.render();
-      lists.paintActive();
+      // The rest in one batch: the bar and the lists redraw once, after the
+      // answer's markdown.
+      store.batch(() => {
+        // The notes chip: the first turn's build (or a /model) records them.
+        applySessionPayload(d, { fields: ["usedMemories", "promptNotes"] });
+        turnEndStatus(d);
+        setMarkdownWarning(d.markdown_warning);
+        markdownTip.show(d.markdown_tip);
+        setCapabilities(d.capabilities, d.editor_url);
+        if (Array.isArray(d.messages)) applyFinalMarkdown(d.messages);
+        // Its card, replaced (replaceSelectedCard).
+        replaceSelectedCard((sess) => ({ ...sess, used_memory_names: store.current.usedMemories.slice(), status: store.current.status }));
+      });
     }
   } catch (_) {
     // A failed read (the server or worker gone a moment) leaves the answer
@@ -1297,7 +1325,7 @@ function seedSeenFromDom() {
 // delta), so the gap measured is the one the user was sitting at. While the
 // stage holds a turn its rows go there: nothing it does moves the history.
 function isNearBottom() {
-  return !turnDom.holds?.() && atHistoryEnd();
+  return !turnDom.holds() && atHistoryEnd();
 }
 
 function atHistoryEnd() {
@@ -1314,7 +1342,7 @@ function endTurnView(kind, endText = null, { emptyAnswer = null, stopped = false
   // gone mid-turn is re-rendered (resync), which counts again.
   if (kind !== "gone") liveTurn.timing.ended += 1;
   // A completed turn with no answer: its notice where the answer goes
-  // (the turn view places it), else after the turn; before the timing.
+  // (the turn block places it), else after the turn; before the timing.
   const endNote = emptyAnswer ? elementOf(emptyAnswerTemplate(emptyAnswer)) : null;
   const kept = turnDom.turnEnded({ kind, endNote, emptyAnswer: !!emptyAnswer, turnId: liveTurn.timing.turnId }) || [];
   if (endNote && !endNote.isConnected) appendToHistory(endNote);
@@ -1322,14 +1350,12 @@ function endTurnView(kind, endText = null, { emptyAnswer = null, stopped = false
   if (endText) addEndBubble(endText, { stopped });
   if (kept.length) {
     kept.forEach((el) => appendToHistory(el));
-    if (!turnDom.holds?.()) historyEl.scrollTop = historyEl.scrollHeight;
+    if (!turnDom.holds()) historyEl.scrollTop = historyEl.scrollHeight;
   }
   // The question dies with its turn (the worker stopped waiting).
   if (questionCards.pendingQuestion()) questionCards.resolveQuestion(questionCards.pendingQuestion().id, { cancelled: true, reason: "turn ended" });
 }
 
-// The info bar's "copy chi --attach": the full id, which the page shows
-// only short; "copied ✓" for 2 s (current.attachCopiedAt: that session's).
 infoTextEl.addEventListener("click", (e) => {
   if (e.target.closest(".worker-restart")) restartWorker();
   // Pushed as openAllView does, so the view's back returns here.
@@ -1338,18 +1364,15 @@ infoTextEl.addEventListener("click", (e) => {
     openAllView();
   }
 });
+// The info bar's id: a click copies the full id, which the bar shows only short.
 infoTextEl.addEventListener("click", async (e) => {
-  if (!e.target.closest(".copy-attach") || !selected) return;
-  const id = selected;
-  if (!(await copyText(`chi --attach ${id}`)) || id !== selected) return;
-  current.attachCopiedAt = Date.now();
-  updateInfoBar();
-  setTimeout(updateInfoBar, 2000);
+  if (!e.target.closest(".id") || !store.selected) return;
+  showToast((await copyText(store.selected)) ? "Session id copied" : "Couldn't copy the session id");
 });
 
 // Apply (review_apply.js) under a participant's review turn that just
 // ended live ({turn_id, author, author_name}, from its turn_started), once:
-// a reload draws it from the history (turn_view.js).
+// a reload draws it from the history (turn_block.js).
 function placeApply(data) {
   const badge = authorBadge(data.author, data.author_name);
   if (!badge || historyEl.querySelector(`.review-apply[data-apply-turn="${CSS.escape(data.turn_id)}"]`)) return;
@@ -1358,10 +1381,12 @@ function placeApply(data) {
 
 function placeVerdict(record) {
   if (!record) return;
-  const known = (current.verdicts || []).some((item) => item.check_turn_id === record.check_turn_id);
-  if (!known) current.verdicts = [...(current.verdicts || []), record];
+  const known = (store.current.verdicts || []).some((item) => item.check_turn_id === record.check_turn_id);
+  const patch = {};
+  if (!known) patch.verdicts = [...(store.current.verdicts || []), record];
   // A fresh verdict ends its check's "verifying fresh" (the card shows it).
-  if (record.fresh) current.verifyFresh = settleRunning(current.verifyFresh, record);
+  if (record.fresh) patch.verifyFresh = settleRunning(store.current.verifyFresh, record);
+  store.update({ current: patch });
   const badge = record.by && authorBadge(record.by);
   placeVerdictWithFresh(historyEl, record, {
     who: badge ? badge.name : "You",
@@ -1369,7 +1394,7 @@ function placeVerdict(record) {
     roots: CLAIM_ROOTS,
     opts: claimOpts(),
     onMissingCheck: (missing) => {
-      const hash = ownerCheckHash(allSessions, selected, missing.check_turn_id);
+      const hash = ownerCheckHash(store.sessions, store.selected, missing.check_turn_id);
       if (hash) location.hash = hash;
       else showToast(CHECK_NOT_ON_PAGE);
     },
@@ -1380,12 +1405,11 @@ function placeVerdict(record) {
 // always theirs to start; its running check links to the child's session.
 const verifyFreshErrors = {};
 function verifyFreshState() {
-  const id = selected;
-  const unavailable = verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp);
-  if (!Array.isArray(current.verifyFresh)) current.verifyFresh = [];
+  const id = store.selected;
+  const unavailable = verifyWorkerUnavailable(store.current.workerFeatures, store.current.bridgeUp);
   return {
-    verdicts: current.verdicts || [],
-    running: current.verifyFresh,
+    verdicts: store.current.verdicts || [],
+    running: store.current.verifyFresh || [],
     errors: verifyFreshErrors,
     canStart: !!id && !unavailable,
     unavailableReason: unavailable ? VERIFY_UNAVAILABLE : null,
@@ -1402,19 +1426,19 @@ function verifyFreshState() {
 }
 
 function renderSavedVerdicts() {
-  for (const record of current.verdicts || []) placeVerdict(record);
+  for (const record of store.current.verdicts || []) placeVerdict(record);
 }
 
 // Apply: the owner's Apply turn into the composer, after what is typed
 // there; never sent from here.
 historyEl.addEventListener("click", async (e) => {
   const button = e.target.closest(".review-apply-btn");
-  if (!button || !selected) return;
-  const id = selected;
+  if (!button || !store.selected) return;
+  const id = store.selected;
   button.disabled = true;
   try {
     const text = await fetchApply(id, button.dataset.applyTurn);
-    if (id === selected) {
+    if (id === store.selected) {
       fillComposer(applyComposerText(promptEl.value, text));
       // The owner's own turn: queued after a running one, never steered in.
       deliveryControl.hold();
@@ -1428,18 +1452,18 @@ historyEl.addEventListener("click", async (e) => {
 
 // The open session's worker badge (info_bar_model.js workerBadgeFor).
 function currentWorkerBadge() {
-  return workerBadgeFor(selected, current, versions);
+  return workerBadgeFor(store.selected, store.current, versions);
 }
 
 // Restart: the session moves to a new worker on the newest chi; the page
 // follows it (its bridge_up), the composer's draft stays as it is.
 async function restartWorker() {
   const badge = currentWorkerBadge();
-  if (!badge || !badge.restart || restartingIds.has(selected)) return;
-  if (!confirm(restartConfirmText(current.workerVersion, badge.newest))) return;
-  const id = selected;
+  if (!badge || !badge.restart || restartingIds.has(store.selected)) return;
+  if (!confirm(restartConfirmText(store.current.workerVersion, badge.newest))) return;
+  const id = store.selected;
   restartingIds.add(id);
-  updateInfoBar();
+  store.touch("infoBar");
   try {
     const result = await restartSession(id);
     showToast(result.version ? `Restarted on chi ${result.version}` : "Restarting: the new worker is starting");
@@ -1447,7 +1471,7 @@ async function restartWorker() {
     showToast(cantText("restart", e), null, { sticky: true });
   } finally {
     restartingIds.delete(id);
-    updateInfoBar();
+    store.touch("infoBar");
   }
 }
 
@@ -1456,9 +1480,9 @@ async function restartWorker() {
 function updateInfoBar() {
   annotateBar?.refresh();
   const { buttons, bar } = sessionBar({
-    id: selected, state: current, sessions: allSessions, versions, cardTitle: (s) => lists.cardTitle(s),
+    id: store.selected, state: store.current, sessions: store.sessions, versions, cardTitle: (s) => lists.cardTitle(s),
     continuing: sessionActions.continuing, restarting: restartingIds, streaming: !!streamControl, running: liveTurn.running,
-    now: Date.now(), workingSet: workingSet ? workingSet.chip() : undefined, participants: participantsControl.chip(),
+    workingSet: workingSet ? workingSet.chip() : undefined, participants: participantsControl.chip(),
   });
   const stopBtn = document.getElementById("infoStopBtn");
   const deleteBtn = document.getElementById("infoDeleteBtn");
@@ -1494,9 +1518,9 @@ function updateInfoBar() {
 // browser tab names it too. It follows the card's (openTitle): a chain link
 // reads its card's title (cardTitle), whatever opener it was sent.
 function shownTitle() {
-  const shown = selected ? lists.sessionsById().get(selected) : null;
-  const first = current.firstPreview || "";
-  const raw = !selected ? "" : openTitle({ shown, first, cardTitle: (s) => lists.cardTitle(s) });
+  const shown = store.selected ? lists.sessionsById().get(store.selected) : null;
+  const first = store.current.firstPreview || "";
+  const raw = !store.selected ? "" : openTitle({ shown, first, cardTitle: (s) => lists.cardTitle(s) });
   return raw === "\u2014" ? "" : raw; // "—": no first message yet
 }
 // The top bar's ✎ follows it (not a plain terminal's session), and an open
@@ -1511,7 +1535,7 @@ function updateSessionTitle() {
   });
   if (sessionTitleEl.textContent !== text) sessionTitleEl.textContent = text;
   if (sessionTitleRowEl.hidden !== !text) sessionTitleRowEl.hidden = !text;
-  const renamable = !!text && renameShown(current.owner);
+  const renamable = !!text && renameShown(store.current.owner);
   if (titleRenameBtn.hidden !== !renamable) titleRenameBtn.hidden = !renamable;
   const tip = text ? title : "";
   if (sessionTitleEl.title !== tip) sessionTitleEl.title = tip;
@@ -1520,7 +1544,7 @@ function updateSessionTitle() {
     tabShown = tab;
     notifications.setBaseTitle(tab);
   }
-  rename.follow(selected);
+  rename.follow(store.selected);
   rename.reposition();
 }
 
@@ -1528,7 +1552,7 @@ function updateSessionTitle() {
 // @return true when the stage took +el+ (it scrolls it into its view itself)
 function appendToHistory(el) {
   // (The stage's place first moves a turn still sliding away into the history.)
-  if (turnDom.place?.(el)) return true;
+  if (turnDom.place(el)) return true;
   appendAboveLiveTiming(historyEl, el, liveTurn.timing.el);
   return false;
 }
@@ -1539,31 +1563,61 @@ function appendToHistory(el) {
 // turn that started meanwhile keeps its line and its own active turn.
 // @return false when the session changed meanwhile
 async function mergeTurnTiming(id, data) {
-  const keepActive = () => (liveTurn.running ? current.timing.activeTurn : null);
-  const merged = mergeTiming(current.timing, data);
-  current.timing = { ...merged.timing, activeTurn: keepActive() };
+  const keepActive = () => (liveTurn.running ? store.current.timing.activeTurn : null);
+  const merged = mergeTiming(store.current.timing, data);
+  store.update({ current: { timing: { ...merged.timing, activeTurn: keepActive() } } });
   if (merged.short) {
+    const still = stillOn(openId, id);
     try {
       const full = await getSession(id, { timing: true });
-      if (id !== selected) return false;
-      current.timing = { ...normalizeTiming(full.timing), activeTurn: keepActive() };
+      if (!still()) return false;
+      store.update({ current: { timing: { ...normalizeTiming(full.timing), activeTurn: keepActive() } } });
     } catch (_) {
-      if (id !== selected) return false;
+      if (!still()) return false;
     }
   }
-  liveTurn.timing.ended = Math.max(liveTurn.timing.ended, current.timing.turnRecords.length);
+  liveTurn.timing.ended = Math.max(liveTurn.timing.ended, store.current.timing.turnRecords.length);
   return true;
 }
 
 function setUsedMemories(names) {
-  current.usedMemories = names.slice();
-  updateInfoBar();
-  const sess = allSessions.find(s=>s.id===selected);
-  if (sess) {
-    sess.used_memory_names = current.usedMemories.slice();
-    lists.render();
-    lists.paintActive();
-  }
+  store.batch(() => {
+    store.update({ current: { usedMemories: names.slice() } });
+    replaceSelectedCard((sess) => ({ ...sess, used_memory_names: store.current.usedMemories.slice() }));
+  });
+}
+
+// The open session's card replaced by +change(card)+'s copy, in a new list
+// (replaceCard). @return whether the list has it
+function replaceSelectedCard(change) {
+  return replaceCard(store.selected, change);
+}
+
+// Session +id+'s card replaced by +change(card)+'s copy, in a new list
+// (never changed in place: setStatus and the hub's events replace too).
+// @return whether the list has it
+function replaceCard(id, change) {
+  const i = store.sessions.findIndex((s) => s.id === id);
+  if (i < 0) return false;
+  const next = store.sessions.slice();
+  next[i] = change(next[i]);
+  store.update({ sessions: next });
+  return true;
+}
+
+// A partial re-read of the open session (readTurnEnd, the turn_canceled
+// timing re-read): its named +fields+ into the store, read as a full load
+// reads them (session_payload.js). Not its status: turnEndStatus. Their
+// redraws follow (session_fields.js FIELDS).
+function applySessionPayload(data, { fields }) {
+  store.update({ current: sessionFieldsFrom(data, fields) });
+}
+
+// A turn end's re-read's status, when it carries one (the "turnEnd" rule:
+// not over a turn that started meanwhile).
+function turnEndStatus(data) {
+  const { status } = sessionFieldsFrom(data, ["status"]);
+  if (status) store.setStatus(status, "turnEnd", { running: liveTurn.running });
 }
 
 // A turn or command just woke the session's worker: follow its stream if
@@ -1572,12 +1626,12 @@ function setUsedMemories(names) {
 // worker have been up already, turn_started says so (replaysDrawnTurn).
 function followWokenWorker() {
   if (streamControl?.live) return;
-  startStream(selected, current.streamSeq ?? 0);
-  current.streamFromGuess = current.streamSeq === null;
+  startStream(store.selected, store.current.streamSeq ?? 0);
+  store.update({ current: { streamFromGuess: store.current.streamSeq === null } });
 }
 
 function startStream(id, fromSeq) {
-  current.streamFromGuess = false;
+  store.update({ current: { streamFromGuess: false } });
   if (streamControl) {
     streamControl.close();
     streamControl = null;
@@ -1589,7 +1643,7 @@ function startStream(id, fromSeq) {
     onStreamClosed: () => workerGone(id),
     onStreamError: () => workerGone(id, { opened: false }),
   });
-  updateInfoBar();
+  store.touch("infoBar"); // streaming
 }
 
 // +opened+ false: the stream never delivered a frame (the proxy answered
@@ -1598,38 +1652,33 @@ function startStream(id, fromSeq) {
 const STREAM_RETRY_MS = 3000;
 function workerGone(id, { opened = true } = {}) {
   streamControl = null;
-  if (id !== selected) return;
+  if (id !== store.selected) return;
   // A turn that was running is over only when the worker really left: a
   // stream that merely dropped (no stop, it was open) waits for the re-read.
   const stopped = sessionActions.stoppingId() === id;
   const { endNow, endText } = streamDropEnd({ turnRunning: liveTurn.running, stopped, opened });
-  if (endNow) {
-    endTurnView("gone", endText, { stopped });
-    if (!stopped) setLiveStatus("idle");
-  }
-  if (current.owner === "worker") current.owner = null;
-  current.bridgeUp = false;
-  // Its card says "live" (the list's owner, or setLiveStatus's) until the
-  // hub's event says otherwise: the worker is gone now, as far as this
-  // tab can tell.
-  const i = allSessions.findIndex((s) => s.id === id);
-  if (i >= 0 && allSessions[i].owner === "worker") {
-    allSessions[i] = withoutWorker(allSessions[i]);
-    lists.render();
-  }
-  updateInfoBar();
+  if (endNow) endTurnView("gone", endText, { stopped });
+  store.batch(() => {
+    if (endNow && !stopped) setLiveStatus("idle");
+    store.update({ current: { ...(store.current.owner === "worker" ? { owner: null } : {}), bridgeUp: false } });
+    // Its card says "live" (the list's owner, or setLiveStatus's) until the
+    // hub's event says otherwise: the worker is gone now, as far as this
+    // tab can tell.
+    if (store.sessions.find((s) => s.id === id)?.owner === "worker") replaceCard(id, withoutWorker);
+    store.touch("infoBar"); // streaming
+  });
   // Once: a worker still alive with a bridge (the stream dropped, not the
   // worker: chi web restarted) reconnects right here. Otherwise the next
   // worker's bridge_up event brings the stream back (followSelectedSession).
   if (opened) resync({ endText });
-  else setTimeout(() => { if (id === selected && !(streamControl && streamControl.live)) resync({ endText }); }, STREAM_RETRY_MS);
+  else setTimeout(() => { if (id === store.selected && !(streamControl && streamControl.live)) resync({ endText }); }, STREAM_RETRY_MS);
 }
 
 // The stream's event handlers (stream_handlers.js); renderSessionView
 // replays a snapshot through them too.
 const streamHandlers = createStreamHandlers({
-  selected: () => selected,
-  state: () => current,
+  selected: () => store.selected,
+  store,
   clientId,
   capabilities: () => pageCapabilities,
   historyEl,
@@ -1638,20 +1687,18 @@ const streamHandlers = createStreamHandlers({
   shownTexts,
   questionCards,
   contextChips,
-  llmContextControl,
-  thinkingControl,
-  reasoningHistoryControl,
   workingSet,
   participantsControl,
   placeApply,
   placeVerdict,
   restoreVerify: (anchor) => { pendingVerifyAnchor = anchor; },
+  restoreRevise,
   sentIds,
   earlyRestores,
   stream: {
     takeGuess: () => {
-      const guess = current.streamFromGuess;
-      current.streamFromGuess = false;
+      const guess = store.current.streamFromGuess;
+      store.update({ current: { streamFromGuess: false } });
       return guess;
     },
     restart: () => {
@@ -1674,7 +1721,7 @@ const streamHandlers = createStreamHandlers({
   getSession,
   // The page's hooks, passed as they are: function declarations (hoisted)
   // and the views' methods bound above.
-  resync, updateInfoBar, setTurnRunning, setLiveStatus, endTurnView, readTurnEnd, refreshTimingFromSession,
+  resync, setTurnRunning, setLiveStatus, endTurnView, readTurnEnd, refreshTimingFromSession,
   setUsedMemories, onInitEvent, findInTurnRoots, applyFinalMarkdown,
   // bubbles.js
   applyPromptOps, showSteers, markRecapStale, appendChunk, makeUserBubble, addEndBubble, commandBubble,
@@ -1686,14 +1733,16 @@ const streamHandlers = createStreamHandlers({
 });
 
 async function refreshTimingFromSession() {
-  if (!selected) return;
-  const id = selected;
+  if (!store.selected) return;
+  const id = store.selected;
   const line = liveTurn.timing.capture();
+  const still = stillOn(openId);
   try {
     const data = await getSession(id, { tail: true, recent: true, turnId: line.turnId });
-    if (id !== selected) return;
-    if (data.session?.status) current.status = data.session.status;
-    if (await mergeTurnTiming(id, data.timing)) liveTurn.timing.finishLine(line);
+    if (!still()) return;
+    turnEndStatus(data);
+    if (!(await mergeTurnTiming(id, data.timing))) return;
+    liveTurn.timing.finishLine(line);
   } catch (_) {}
 }
 
@@ -1710,14 +1759,13 @@ function closeStream() {
 // put it (they follow, with its owner and bridge_up).
 function addCreatedSession(created) {
   const { bridge_port: _port, ...session } = created;
-  allSessions = applySessionEvent(allSessions, "session", { session });
-  lists.render();
+  store.update({ sessions: applySessionEvent(store.sessions, "session", { session }) });
 }
 
 // /model, !ls … from the composer, and a control's command (the llm ctx
 // and thinking chips): composer.js.
 const composerCommands = createComposerCommands({
-  session: () => selected,
+  session: () => store.selected,
   clientId,
   sendCommand,
   followWokenWorker: () => followWokenWorker(),
@@ -1726,15 +1774,15 @@ const composerCommands = createComposerCommands({
   // As send_turn.js says a turn's failure after a switch.
   failedElsewhere: (line, text, id) => showToast(cantText(`run ${line} in ${id.slice(0, 8)}`, text), null, { sticky: true }),
   ownedByTui: () => {
-    current.owner = "tui";
-    updateComposerMode();
+    // The composer and the bar (its continue and stop, the title's ✎) follow.
+    store.update({ current: { owner: "tui" } });
   },
   composer: {
     busy: () => { actionBtn.disabled = true; },
     text: () => promptEl.value,
     clear: () => clearComposer(),
     done: () => {
-      actionBtn.disabled = current.owner === "tui";
+      actionBtn.disabled = store.current.owner === "tui";
       // A chip's command (the info bar) leaves a folded composer folded.
       focusPrompt({ open: false });
     },
@@ -1744,8 +1792,8 @@ const composerCommands = createComposerCommands({
 // The composer's send (send_turn.js): a line into the open session, or a
 // new session first on the start page.
 const sendTurnControl = createSendTurn({
-  session: () => selected,
-  state: () => current,
+  session: () => store.selected,
+  store,
   running: () => liveTurn.running,
   clientId,
   sentIds,
@@ -1754,6 +1802,10 @@ const sendTurnControl = createSendTurn({
   verify: () => pendingVerifyAnchor,
   clearVerify: (anchor) => { if (pendingVerifyAnchor === anchor) pendingVerifyAnchor = null; },
   restoreVerify: (anchor) => { pendingVerifyAnchor = anchor; },
+  // Not while the gate refuses (the chip says so; the line goes as a plain message).
+  revise: () => (reviseUnavailable() ? null : pendingReviseAnchor),
+  clearRevise: (anchor) => { if (pendingReviseAnchor === anchor) setReviseAnchor(null); },
+  restoreRevise,
   dir: scope.dir,
   startPage,
   takeDelivery: () => deliveryControl.take(),
@@ -1776,8 +1828,6 @@ const sendTurnControl = createSendTurn({
   addCreatedSession,
   select,
   showNotice,
-  updateInfoBar,
-  updateComposerMode,
   followWokenWorker,
   refreshHistory,
   leaveGoneSession,
@@ -1803,18 +1853,18 @@ function clearComposer() {
 // A queue (Alt+Enter, or an Apply turn's Enter) to a worker that can't
 // queue (it would steer): not sent, the text kept, a note says why.
 function queueRefused(altKey) {
-  if (!selected || !liveTurn.running || current.workerFeatures.includes("delivery")) return false;
+  if (!store.selected || !liveTurn.running || store.current.workerFeatures.includes("delivery")) return false;
   if (!altKey && !deliveryControl.held()) return false;
   addCommandBubble({ label: null, line: promptEl.value.trim(), text: QUEUE_NEEDS_WORKER, failed: true });
   return true;
 }
 
 async function handleCancel() {
-  if (!selected) return;
+  if (!store.selected) return;
   cancelBtn.disabled = true;
   infoCancelBtn.disabled = true;
   try {
-    await cancelTurn(selected);
+    await cancelTurn(store.selected);
   } catch (e) {
     // The turn ended meanwhile: nothing left to cancel.
     if (e.code !== "not_running") alert(e.message);
@@ -1858,7 +1908,7 @@ const composer = mountComposer({
   // Alt/Option+Enter: queued for after the running turn (D6), only to a
   // worker that queues (else it would steer): the text stays, a note says why.
   send: ({ queue }) => {
-    if (!selected) return handleSendTurn();
+    if (!store.selected) return handleSendTurn();
     if (!queueRefused(queue)) handleSendTurn(queue ? { delivery: "queue" } : {});
   },
   keyFirst: (e) => commandList.handleKey(e),
@@ -1867,8 +1917,8 @@ const composer = mountComposer({
   fold: {
     infoCancelBtn,
     infoBarEl: $("#infoBar"),
-    session: () => selected,
-    waiting: () => !!(waitingOn(allSessions.find((s) => s.id === selected)) || questionCards.pendingQuestion()),
+    session: () => store.selected,
+    waiting: () => !!(waitingOn(store.sessions.find((s) => s.id === store.selected)) || questionCards.pendingQuestion()),
     turnRunning: () => liveTurn.running,
     allViewOpen,
     lightboxOpen: () => !lightboxEl.hidden,
@@ -1889,7 +1939,7 @@ function refreshHistory() {
 
 // The × on a message queued for after the turn takes it back (unqueue.js).
 const unqueue = createUnqueue({
-  sessionId: () => selected,
+  sessionId: () => store.selected,
   clientId,
   toast: (text, action, options) => showToast(text, action, options),
   copy: (text) => copyText(text),
@@ -1923,7 +1973,7 @@ infoCancelBtn.addEventListener("click", () => handleCancel());
 const commandList = createCommandList({
   list: $("#commandList"),
   prompt: promptEl,
-  commands: () => (selected && current.owner !== "tui" ? current.commands : []),
+  commands: () => (store.selected && store.current.owner !== "tui" ? store.current.commands : []),
   afterPick: () => {
     noteDraft();
     fitPrompt();
@@ -1932,7 +1982,7 @@ const commandList = createCommandList({
 
 $("#infoStopBtn").addEventListener("click", () => sessionActions.stopSelected());
 $("#infoDeleteBtn").addEventListener("click", () => {
-  if (selected) confirmDelete(selected);
+  if (store.selected) confirmDelete(store.selected);
 });
 $("#infoContinueBtn").addEventListener("click", () => continueSelected());
 $("#infoArchiveBtn").addEventListener("click", () => sessionActions.toggleArchiveSelected());
@@ -1995,16 +2045,16 @@ function fillComposer(text) {
 annotateBar = createAnnotateBar({
   presets: withVerify(parsePresets(document.body.dataset.annotatePresets)),
   disabledPreset: (preset) => preset === VERIFY_PRESET
-    && verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp) ? VERIFY_UNAVAILABLE : null,
+    && verifyWorkerUnavailable(store.current.workerFeatures, store.current.bridgeUp) ? VERIFY_UNAVAILABLE : null,
   offeredPreset: (preset, source, range) => preset !== VERIFY_PRESET || !!verifyAnchorFor({ source, range }),
-  canAnnotate: () => !!selected && current.owner !== "tui",
+  canAnnotate: () => !!store.selected && store.current.owner !== "tui",
   roots: turnRoots,
   isLive: (root) => liveTurn.running && turnDom.containsLive(root),
   onQuote: (text) => fillComposer(appendQuote(promptEl.value, text)),
   onPreset: (preset, fields) => {
     pendingVerifyAnchor = preset === VERIFY_PRESET ? verifyAnchorFor(fields) : null;
   },
-  actions: () => annotationActions(current.commands),
+  actions: () => annotationActions(store.current.commands),
   running: () => liveTurn.running,
   onAction: (action, fields) => {
     const line = actionLine(action, fields);
@@ -2033,13 +2083,29 @@ historyEl.addEventListener("click", (e) => {
   const button = e.target.closest?.("[data-confirm-line]");
   if (button) applyConfirm(button, runSessionCommand);
 });
-turnDom.scrollEl?.addEventListener("scroll", annotateBar.schedule, true);
+turnDom.scrollEl.addEventListener("scroll", annotateBar.schedule, true);
 turnRoots().forEach((root) => installCopy(root));
 // Long answers fold by hand (answer_fold.js), per viewer and session.
 installAnswerFold({
   historyEl,
-  sessionId: () => selected,
-  projectRoot: () => allSessions.find((s) => s.id === selected)?.project_root ?? null,
+  sessionId: () => store.selected,
+  projectRoot: () => store.sessions.find((s) => s.id === store.selected)?.project_root ?? null,
+});
+// Revise stacks (revise_stack.js): the superseded versions fold to stubs,
+// the top answer gets its version chip, a final answer its Revise button.
+reviseStacks = installReviseStacks({
+  historyEl,
+  sessionId: () => store.selected,
+  projectRoot: () => store.sessions.find((s) => s.id === store.selected)?.project_root ?? null,
+  running: () => (liveTurn.running ? { turnId: liveTurn.timing.turnId || null } : null),
+  verifyTurn: (turnId) => (store.current.verdicts || []).some((v) => v.check_turn_id === turnId),
+  unavailable: reviseUnavailable,
+  armed: () => pendingReviseAnchor?.turn_id ?? null,
+  onRevise: (anchor) => {
+    setReviseAnchor(anchor);
+    openForVisit();
+    focusPrompt();
+  },
 });
 
 // Notifications (notifications.js): an OS notification and a title count
@@ -2100,6 +2166,22 @@ document.addEventListener("keydown", (e) => {
   }
   closeAllView();
 });
+// The redraws the store runs, by name (session_store.js ORDER), after a
+// write of what they read (session_fields.js FIELDS; sessions, selected) or
+// a touch(). Registered here, once every piece they call exists: a write
+// before it (none at load) would redraw nothing.
+store.on("lists", () => lists.render());
+store.on("paintActive", () => lists.paintActive());
+store.on("settingsPanel", () => settingsControl.refresh());
+// The working set's list offers pin only under forget.
+store.on("workingSetStrategy", () => workingSet?.strategyChanged());
+store.on("featureGates", () => featureGates.check(store.current));
+store.on("composer", updateComposerMode);
+// The answers' Revise buttons follow liveTurn.running too (none on the
+// running turn's answer), which touches the composer.
+store.on("composer", () => reviseStacks.decorate());
+store.on("infoBar", updateInfoBar);
+
 applyView();
 
 // Where sessions live: under the all-sessions search (the server fills it in).
@@ -2109,8 +2191,10 @@ if (document.body.dataset.sessionsDir) {
 }
 
 renderScope();
-updateInfoBar();
-updateComposerMode();
+store.batch(() => {
+  store.touch("composer");
+  store.touch("infoBar");
+});
 startPage.loadModels();
 // The list: the hub's stream when the browser has EventSource, else fetched.
 if (typeof globalThis.EventSource === "function") openSessionEvents();