samagotchi 0.170.0 → 0.171.0

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

@@ -169,8 +169,9 @@ export function editorUrl(template, path, line) {
 
 // A ref's targets, per kind, in order: the first available one is a plain
 // click's (the main target), all of them are the menu's. Each says when
-// it's available for +viewer+ (what this page's viewer can do: {editor,
-// editorUrl}, the server's capabilities.editor and editor_url) and
+// it's available for +refEditor+ (where this page can open a ref: {editor,
+// editorUrl}, the server's capabilities.editor and editor_url; not
+// viewer.js's viewer, which says what the viewer may do at all) and
 // +target+ (refTarget's). A secondary one (copy) joins a ref that has
 // another, never alone. A line (a diff or read line) has its click only.
 // A link whose text is the ref (github-pr's PR diff): its href stays the
@@ -181,8 +182,8 @@ const LINK = Object.freeze({
   id: "link",
   label: (target) => target.actions?.find((action) => sameUrl(action.url, target.href))?.label ||
     (/\/pull\/\d+\/files\b/.test(target.href) ? "PR diff" : "Open link"),
-  available: (_viewer, target) => !!target.href,
-  run: (target, _viewer, env) => env.openLink(target.href),
+  available: (_refEditor, target) => !!target.href,
+  run: (target, _refEditor, env) => env.openLink(target.href),
 });
 
 // The ref's own actions (a plugin's, bindRef), one target each, for every
@@ -196,8 +197,8 @@ const URL_ACTIONS = Object.freeze({
     .map((action) => Object.freeze({
       id: `url:${action.id}`,
       label: () => action.label,
-      available: (_viewer, target) => !target.isLine,
-      run: (_target, _viewer, env) => env.openLink(action.url),
+      available: (_refEditor, target) => !target.isLine,
+      run: (_target, _refEditor, env) => env.openLink(action.url),
       hint: () => action.url,
     })),
 });
@@ -226,8 +227,8 @@ const MORE_REFS = Object.freeze({
         items.push(Object.freeze({
           id: `more:${at}:editor`,
           label: () => `${name} · Open in editor`,
-          available: (viewer, target) => !target.isLine && viewer?.editor === true && !!viewer.editorUrl,
-          run: (_target, viewer, env) => env.open(editorUrl(viewer.editorUrl, ref.target.path, ref.target.line)),
+          available: (refEditor, target) => !target.isLine && refEditor?.editor === true && !!refEditor.editorUrl,
+          run: (_target, refEditor, env) => env.open(editorUrl(refEditor.editorUrl, ref.target.path, ref.target.line)),
           hint: () => `Open the current file in your editor${ref.target.line ? ` at line ${ref.target.line}` : ""}`,
         }));
       }
@@ -237,8 +238,8 @@ const MORE_REFS = Object.freeze({
         items.push(Object.freeze({
           id: `more:${at}:${action.id}`,
           label: () => `${name} · ${action.label}`,
-          available: (_viewer, target) => !target.isLine,
-          run: (_target, _viewer, env) => env.openLink(action.url),
+          available: (_refEditor, target) => !target.isLine,
+          run: (_target, _refEditor, env) => env.openLink(action.url),
           hint: () => action.url,
         }));
       }
@@ -253,10 +254,10 @@ export const REF_ACTIONS = Object.freeze({
     Object.freeze({
       id: "editor",
       label: () => "Open in editor",
-      available: (viewer) => viewer?.editor === true && !!viewer.editorUrl,
-      url: (target, viewer) => editorUrl(viewer.editorUrl, target.path, target.line),
-      run(target, viewer, env) {
-        const url = this.url(target, viewer);
+      available: (refEditor) => refEditor?.editor === true && !!refEditor.editorUrl,
+      url: (target, refEditor) => editorUrl(refEditor.editorUrl, target.path, target.line),
+      run(target, refEditor, env) {
+        const url = this.url(target, refEditor);
         if (url) env.open(url);
       },
       // The hover hint: it opens the file as it is now.
@@ -268,17 +269,29 @@ export const REF_ACTIONS = Object.freeze({
     Object.freeze({
       id: "show",
       label: () => "Show in turn",
-      available: (_viewer, target) => !target.isLine && !target.owner?.matches?.(".activity-row") && !!turnRowFor(target),
-      run: (target, _viewer, env) => env.show(target),
+      available: (_refEditor, target) => !target.isLine && !target.owner?.matches?.(".activity-row") && !!turnRowFor(target),
+      run: (target, _refEditor, env) => env.show(target),
       hint: () => "Show the row that touched it in the turn",
     }),
     MORE_REFS,
+    // What chi has of the file (the working set's reader, ws_reader.js):
+    // an owner's page with the reader, for a file of the set (env's
+    // whatChiHas). Secondary and after a row's other refs: never a ref's main
+    // target, so a click does what it did; it is in the ▾ menu.
+    Object.freeze({
+      id: "has",
+      label: () => "What chi has",
+      secondary: true,
+      available: (_refEditor, target, env) => !target.isLine && !!target.path && !!env?.whatChiHas?.has(target.path),
+      run: (target, _refEditor, env) => env.whatChiHas.open(target.path),
+      hint: () => "What chi has of it: its reads and edits, newest first",
+    }),
     Object.freeze({
       id: "copy",
       label: () => "Copy path",
       secondary: true,
-      available: (_viewer, target) => !target.isLine && !!target.path,
-      run: (target, _viewer, env) => env.copy(target.path),
+      available: (_refEditor, target) => !target.isLine && !!target.path,
+      run: (target, _refEditor, env) => env.copy(target.path),
     }),
   ]),
   // Any other kind (a plugin's issue, commit, …): its link, then its
@@ -286,14 +299,15 @@ export const REF_ACTIONS = Object.freeze({
   "*": Object.freeze([LINK, URL_ACTIONS, MORE_REFS]),
 });
 
-// The targets +viewer+ has for +target+ (refTarget's), in order; none
-// when only a secondary one is.
-export function refActions(target, viewer, actions = REF_ACTIONS) {
+// The targets +refEditor+ has for +target+ (refTarget's), in order; none
+// when only a secondary one is. +env+: installRefClicks' (an action's
+// availability may ask it: whatChiHas).
+export function refActions(target, refEditor, actions = REF_ACTIONS, env = null) {
   if (!target) return [];
   // Own keys only: a kind named like an Object property ("constructor") is
   // any other kind.
   const table = (Object.hasOwn(actions, target.kind) ? actions[target.kind] : actions["*"]) || [];
-  const found = table.flatMap((action) => (action.expand ? action.expand(target) : [action])).filter((action) => action.available(viewer, target));
+  const found = table.flatMap((action) => (action.expand ? action.expand(target) : [action])).filter((action) => action.available(refEditor, target, env));
   return found.some((action) => !action.secondary) ? found : [];
 }
 
@@ -475,16 +489,19 @@ function defaultOpenLink(href) {
 }
 
 // One delegated listener set on +root+ for every ref on the page.
-// +viewer+() is read per click, key and hover, so a capabilities change
+// +refEditor+() is read per click, key and hover, so a capabilities change
 // (another session, a reload) is seen. The targets run through: +open+(url)
 // (the editor's URL), +openLink+(href), +show+(target) and +copy+(text).
-// +menu+ is the ▾ and its menu (ref_menu.js).
-export function installRefClicks(root, viewer, {
+// +menu+ is the ▾ and its menu (ref_menu.js). +whatChiHas+: the working
+// set's reader ({has(path), open(path)}; null: none, the "What chi has"
+// target never shows).
+export function installRefClicks(root, refEditor, {
   open = defaultOpen, openLink = defaultOpenLink, show = (target) => showInTurn(target), copy = copyText,
-  selection = () => window.getSelection?.(), menu = createRefMenu(root.ownerDocument),
+  selection = () => window.getSelection?.(), menu = createRefMenu(root.ownerDocument), whatChiHas = null,
 } = {}) {
-  const env = { open, openLink, show, copy };
-  const run = (action, target) => action.run(target, viewer(), env);
+  const env = { open, openLink, show, copy, whatChiHas };
+  const actionsOf = (target) => refActions(target, refEditor(), REF_ACTIONS, env);
+  const run = (action, target) => action.run(target, refEditor(), env);
   const items = (actions, target) => actions.map((action) => ({
     id: action.id, label: action.label(target), hint: action.hint?.(target) || "", run: () => run(action, target),
   }));
@@ -497,14 +514,14 @@ export function installRefClicks(root, viewer, {
   // the link's own click); Tab works out the tab stops before it moves.
   root.addEventListener("keydown", (e) => {
     pointer = "keyboard";
-    if (e.key === "Tab") syncRefTabs(root, viewer());
+    if (e.key === "Tab") syncRefTabs(root, refEditor());
   }, true);
 
   root.addEventListener("click", (e) => {
     if (e.button !== 0 || e.defaultPrevented) return;
     const target = refTarget(e.target);
     if (!target) return;
-    const actions = refActions(target, viewer());
+    const actions = actionsOf(target);
     if (!actions.length) return;
     if (selectingIn(target.owner, selection())) return;
     if (pointer === "touch" && !target.isLine && actions.length > 1) {
@@ -529,7 +546,7 @@ export function installRefClicks(root, viewer, {
     if (e.key === "Escape") menu.hideMore();
     if (e.key !== "Enter" && e.key !== "ArrowDown") return;
     const target = refTarget(el);
-    const actions = refActions(target, viewer());
+    const actions = actionsOf(target);
     if (!actions.length) return;
     if (e.key === "Enter") {
       if (actions[0].id === "link") return;
@@ -547,13 +564,13 @@ export function installRefClicks(root, viewer, {
   const mark = (e) => {
     const target = refTarget(e.target);
     if (!target) return;
-    const actions = refActions(target, viewer());
+    const actions = actionsOf(target);
     const el = target.el;
     if (actions.length) el.dataset.refMain = actions[0].id;
     else delete el.dataset.refMain;
     if (!target.isLine) setRefRole(el, actions);
     hint(el, target, actions[0]);
-    if (!target.isLine && actions.length > 1 && pointer !== "touch") menu.showMore(el, () => openMenu(refTarget(el), refActions(refTarget(el), viewer()), { focus: true }));
+    if (!target.isLine && actions.length > 1 && pointer !== "touch") menu.showMore(el, () => openMenu(refTarget(el), actionsOf(refTarget(el)), { focus: true }));
   };
   root.addEventListener("mouseover", mark);
   root.addEventListener("focusin", mark);
@@ -565,12 +582,12 @@ export function installRefClicks(root, viewer, {
   root.addEventListener("focusout", leave);
 }
 
-// The tab stops under +root+ for +viewer+: a ref is one (a button, with
+// The tab stops under +root+ for +refEditor+: a ref is one (a button, with
 // aria-haspopup when it has a menu) only while it has a target, so a
 // phone's or an editorless viewer's row titles aren't. Worked out before a
 // Tab moves the focus and on a ref's hover or focus; a line never is one.
-export function syncRefTabs(root, viewer) {
-  for (const el of root.querySelectorAll("[data-ref-kind]")) setRefRole(el, refActions(refTarget(el), viewer));
+export function syncRefTabs(root, refEditor) {
+  for (const el of root.querySelectorAll("[data-ref-kind]")) setRefRole(el, refActions(refTarget(el), refEditor));
 }
 
 function setRefRole(el, actions) {

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

@@ -13,11 +13,20 @@
 // fallback, data-undrawn): 0 unless chi web missed one. Fire-and-forget: no toast, no
 // store write, a failure is dropped.
 //
-// Cards and answered question cards are left out on both sides: a reload
-// places them after the render (CardStore's stamps and the snapshot's
-// questions, cards_place.js placeResolvedQuestion), which the offscreen
-// render doesn't run; the e2e reload checks compare them.
+// Compared: the turn's own cards and questions too. A drawn turn already
+// renders its plugin cards (turn_block.js), and the snapshot's questions and
+// an undrawn turn's entries are placed into the offscreen holder by
+// cards_offscreen.js, the same placer the page uses with inert hooks. Only
+// entries CardStore attributes to this turn (of_turn) are compared; a card
+// the turn doesn't own (another turn's, a between-turn notice) is dropped on
+// both sides, and a question the read attributes to no turn and stamps to no
+// opening (an older worker) is dropped as well, since nothing places it.
+// What a card's equality means: its id and title, or a question's summary line
+// — not its body, its buttons, its fold or the tag it is drawn in.
+// Between-turn cards and notices are out of scope (the e2e reload checks
+// cover them).
 import { compareShapes, historyShape } from "./history_shape.js";
+import { isCard, splitSnapshotCards } from "./card.js";
 import { turnElements } from "./turn_range.js";
 
 // The opening of a turn: its prompt, a wake's note, /continue no's line.
@@ -29,8 +38,42 @@ function openingId(el) {
   return el?.dataset?.turnId || el?.dataset?.openingId || null;
 }
 
-function withoutCards(shape) {
-  return shape.filter((item) => item.kind !== "card" && item.kind !== "question");
+// The snapshot entries this turn owns (CardStore's of_turn): a drawn turn
+// already renders its cards, so only its questions come from the placer; an
+// undrawn turn has all of them placed, as a reload places them. Entries the
+// page shows elsewhere, the running turn's and the ones that came during it
+// are out (splitSnapshotCards), as in session_view.js.
+function turnEntries(cards, capabilities, turnId, drawn) {
+  const placed = splitSnapshotCards(cards, capabilities).placed.filter((entry) => entry?.of_turn === turnId);
+  return drawn ? placed.filter((entry) => entry?.type === "question") : placed;
+}
+
+// A question the read attributes to no turn (an older worker: no of_turn, and
+// no opening it came after, or one stamped to this very turn) has nothing to
+// place it from, so its card is left out of the compare. Only entries that
+// could belong to this turn count: one stamped to another turn does not
+// silence questions here.
+function looseQuestions(cards, turnId) {
+  return (Array.isArray(cards) ? cards : []).some((entry) => entry?.type === "question"
+    && entry?.of_turn == null && (entry?.opening_id == null || String(entry.opening_id) === String(turnId)));
+}
+
+// The ids of the snapshot's cards that are not this turn's.
+function foreignIds(cards, turnId) {
+  return new Set((Array.isArray(cards) ? cards : [])
+    .filter((entry) => isCard(entry) && entry?.of_turn !== turnId)
+    .map((entry) => String(entry.id ?? "")));
+}
+
+// This turn's items only: a card of another turn or between turns is dropped
+// by id; a question the worker didn't attribute to a turn (an older worker)
+// has nothing to place it from, so questions are dropped on both sides.
+function turnOnly(shape, foreign, questions) {
+  return shape.filter((item) => {
+    if (item.kind === "card") return !foreign.has(item.id);
+    if (item.kind === "question") return questions;
+    return true;
+  });
 }
 
 // @param enabled () => whether the check is on (the body's attribute)
@@ -39,8 +82,13 @@ function withoutCards(shape) {
 //   turn started streaming)
 // @param read (id) => the session as a reload reads it (the full GET)
 // @param render (data) => that read drawn as a reload draws it (a fragment)
+// @param place (holder, entries) puts the turn's snapshot entries into that
+//   holder as a reload's placement would (cards_offscreen.js); without it,
+//   cards and questions are dropped from both sides
+// @param capabilities () => the page's capabilities (which notices it shows
+//   elsewhere)
 // @param post (id, body) => the counts to chi web
-export function createReloadCheck({ enabled, sessionId, running, read, render, post }) {
+export function createReloadCheck({ enabled, sessionId, running, read, render, place = null, capabilities = () => null, post }) {
   // The hand-off's pieces (stage_view.js onHandedOff), in their order;
   // +immediate+: another turn took the stage at once.
   async function handedOff({ pieces = [], immediate = false } = {}) {
@@ -56,15 +104,24 @@ export function createReloadCheck({ enabled, sessionId, running, read, render, p
       // failed turn hands off at once, and its timing line takes the turn
       // record's figure when its own re-read lands (refreshTimingFromSession),
       // which started at the turn's end, before this one.
-      const live = withoutCards(historyShape(rest.filter((el) => !el.matches?.(NOT_THE_TURNS))));
+      // Whether the read had a drawing for the turn (turn drawings, P2): a
+      // drawn one already renders its own cards, an undrawn one has them
+      // placed after the render.
+      const drawn = !!data?.turn_drawings?.[turnId];
+      const entries = place ? turnEntries(data.cards, capabilities(), turnId, drawn) : [];
+      // A question the read can't place for this turn (see looseQuestions) is
+      // left out of the compare on both sides.
+      const questions = !!place && !looseQuestions(data.cards, turnId);
+      const shapeOf = (shape) => turnOnly(shape, foreignIds(data.cards, turnId), questions);
+      const live = shapeOf(historyShape(rest.filter((el) => !el.matches?.(NOT_THE_TURNS))));
       const holder = document.createElement("div");
       holder.append(render(data));
+      // The turn's own cards and questions, where a reload would put them.
+      if (place) place(holder, entries);
       const reopened = [...holder.querySelectorAll(OPENING)].find((el) => openingId(el) === turnId);
-      const reloaded = reopened ? withoutCards(historyShape(turnElements(reopened, { container: holder }))) : [];
+      const reloaded = reopened ? shapeOf(historyShape(turnElements(reopened, { container: holder }))) : [];
       const { same, kinds, excused, explained } = reopened ? compareShapes(live, reloaded)
         : { same: false, kinds: ["prompt"], excused: [], explained: false };
-      // Whether the read had a drawing for the turn (turn drawings, P2).
-      const drawn = !!data?.turn_drawings?.[turnId];
       const undrawn = holder.querySelectorAll("[data-undrawn]").length;
       await post(id, { turn_id: turnId, same, kinds, excused, explained, drawn, undrawn });
     } catch (_) {

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

@@ -16,7 +16,9 @@
 //   answer's place (revise_switch.js; view only, not stored);
 // - the final answer of an ended turn (verify_target.js's rule, a delegate
 //   report's reply excluded), unstacked or a stack's top, and not a Verify
-//   turn's, gets a Revise button: it arms the composer (app.js).
+//   turn's, gets a Revise button: it arms the composer (app.js). A
+//   participant's page asks mayRevise too (participant_revise.js: their own
+//   answers only); the stubs, the chip and the switcher are everyone's.
 //
 // The stamps live on the history's prompt bubbles (data-revises: a reload's
 // render, a live turn_completed's revises), so the stacks are read from the
@@ -111,7 +113,8 @@ export function versionChipText(count, at = count - 1) {
 }
 
 // The composer's chip: "Revising: ‹label›", or the refusal (+unavailable+:
-// the worker predates Revise turns).
+// the worker predates Revise turns; +text+ its words, a participant's page
+// gives its own: participant_revise.js).
 export const REVISE_UNAVAILABLE = "restart this session to use Revise";
 
 // The feature gate (app.js featureGates): a live worker without the "revise"
@@ -121,16 +124,16 @@ export const REVISE_UNAVAILABLE = "restart this session to use Revise";
 export function reviseWorkerUnavailable(workerFeatures, bridgeUp) {
   return workerPredates(workerFeatures, bridgeUp, "revise");
 }
-export function reviseChipText(label, { unavailable = false } = {}) {
-  if (unavailable) return `Revise: ${REVISE_UNAVAILABLE}`;
+export function reviseChipText(label, { unavailable = false, text = REVISE_UNAVAILABLE } = {}) {
+  if (unavailable) return `Revise: ${text}`;
   return label ? `Revising: ${label}` : "Revising the answer";
 }
 
 // The composer's chip (app.js renders it into its own element): the armed
 // Revise's words and ✕ (+onClear+), or nothing when +anchor+ is null.
-export function reviseChipTemplate(anchor, { unavailable = false, onClear } = {}) {
+export function reviseChipTemplate(anchor, { unavailable = false, text = REVISE_UNAVAILABLE, onClear } = {}) {
   if (!anchor) return nothing;
-  return html`<span class=${unavailable ? "revise-chip refused" : "revise-chip"} title=${unavailable ? REVISE_UNAVAILABLE : `This message rewrites that answer: ${anchor.label || ""}`}><span class="revise-chip-text">${reviseChipText(anchor.label, { unavailable })}</span><button type="button" class="revise-chip-clear" aria-label="Don't revise" title="Don't revise (send as a plain message)" @click=${onClear}>✕</button></span>`;
+  return html`<span class=${unavailable ? "revise-chip refused" : "revise-chip"} title=${unavailable ? text : `This message rewrites that answer: ${anchor.label || ""}`}><span class="revise-chip-text">${reviseChipText(anchor.label, { unavailable, text })}</span><button type="button" class="revise-chip-clear" aria-label="Don't revise" title="Don't revise (send as a plain message)" @click=${onClear}>✕</button></span>`;
 }
 
 // An answer's label (the stub's, the chip's): its first line.
@@ -190,12 +193,18 @@ export function historyTurns(historyEl) {
 // @param verifyTurn (turnId) => whether that turn was a Verify turn (beyond
 //   its prompt's data-verify: a verdict's check_turn_id)
 // @param unavailable () => the worker predates Revise (the feature gate)
+// @param unavailableText the button's title while +unavailable+ (a
+//   participant's page: its own words, participant_revise.js)
 // @param armed () => the turn id the composer's Revise is armed with, or null
 // @param onRevise ({turn_id, label}) the Revise button
+// @param mayRevise (turn, turns) => whether this viewer may revise +turn+
+//   (one of historyTurns' +turns+): false draws no button, the stack's
+//   switcher and chip stay
 // @return {decorate()} (the observer runs it; app.js after a change it reads)
 export function installReviseStacks({
   historyEl, sessionId, projectRoot = () => null, running = () => null, verifyTurn = () => false,
-  unavailable = () => false, armed = () => null, onRevise = () => {},
+  unavailable = () => false, unavailableText = REVISE_UNAVAILABLE, armed = () => null, onRevise = () => {},
+  mayRevise = () => true,
 }) {
   const stubs = new Map();
   const rows = new Map();
@@ -244,14 +253,14 @@ export function installReviseStacks({
     return row;
   }
 
-  function drawRow(row, { id, answer, chain, openings }) {
+  function drawRow(row, { id, answer, chain, openings, may }) {
     const off = unavailable();
     const isArmed = armed() === id;
     const at = chain ? (shown.get(id) ?? chain.length - 1) : 0;
     const versions = chain
       ? html`<details class="stack-versions"><summary>${versionChipText(chain.length, at)}</summary><div class="stack-versions-list" role="list">${chain.map((vid, k) => html`<button type="button" role="listitem" class=${vid === id ? "stack-version current" : "stack-version"} data-stack-pick=${vid} ?disabled=${vid === id}><span class="stack-version-n">v${k + 1}</span> ${promptLabel(openings.get(vid))}</button>`)}</div></details>`
       : nothing;
-    const button = html`<button type="button" class=${isArmed ? "revise-btn armed" : "revise-btn"} data-revise=${id} ?disabled=${off} title=${off ? REVISE_UNAVAILABLE : "Rewrite this answer: your next message revises it, and the earlier version folds away"}>${isArmed ? "Revising…" : "Revise"}</button>`;
+    const button = may ? html`<button type="button" class=${isArmed ? "revise-btn armed" : "revise-btn"} data-revise=${id} ?disabled=${off} title=${off ? unavailableText : "Rewrite this answer: your next message revises it, and the earlier version folds away"}>${isArmed ? "Revising…" : "Revise"}</button>` : nothing;
     row.classList.toggle("stacked", !!chain);
     render(html`${chain ? switcherTemplate(id, at, chain.length) : nothing}${versions}${button}`, row);
     rowAnswer.set(row, answer);
@@ -302,9 +311,11 @@ export function installReviseStacks({
       if (!turn.id || turn.wake || !answer || answer.matches(UNFINISHED) || turn.stopped) continue;
       if (turn.prompt?.hasAttribute("data-verify") || verifyTurn(turn.id)) continue;
       if (run && (turn === lastOpening || (run.turnId && run.turnId === turn.id))) continue;
+      const may = !!mayRevise(turn, turns);
+      if (!may && !tops.has(turn.id)) continue;
       const row = rowFor(turn.id, answer);
       keepRows.add(turn.id);
-      drawRow(row, { id: turn.id, answer, chain: tops.get(turn.id) || null, openings });
+      drawRow(row, { id: turn.id, answer, chain: tops.get(turn.id) || null, openings, may });
     }
     syncViews(tops, keepRows, new Map(turns.filter((t) => t.id).map((t) => [t.id, t.answer])));
     // A divider between two folded stubs folds into the later one.

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

@@ -26,15 +26,22 @@ import { composerAfterAck, dropEarlyRestores, restoreOnAck } from "./restore.js"
 // +addCommandBubble(view)+; +addCreatedSession(created)+, +select(id)+,
 // +showNotice(text)+,
 // +followWokenWorker()+, +refreshHistory()+, +leaveGoneSession(id, why)+,
-// +runCommand(command)+ (composer.js send), +toast(text, action, options)+;
+// +runCommand(command)+ (composer.js send; null: a viewer without session commands, the line goes as a turn), +toast(text, action, options)+;
+// +closesOn(error)+: a participant's page takes a refusal that closes its
+// composer (participant_main.js; true: taken, the line stays typed); null else;
 // +alert+: the browser's.
+// The refused Revise sends whose text and chip stay (a failed line says why):
+// a worker from before Revise turns, and a participant's of an answer that
+// isn't theirs or that someone else's turn came after.
+const REVISE_REFUSALS = ["revise_unavailable", "revise_not_own", "revise_overtaken"];
+
 export function createSendTurn({
   session, store, running, clientId, sentIds, earlyRestores, api, dir, startPage, takeDelivery, composer,
   verify = () => null, clearVerify = () => {}, restoreVerify = () => {},
   revise = () => null, clearRevise = () => {}, restoreRevise = () => {},
   historyEl, turnDom, makeUserBubble, bubbleById, addCommandBubble,
   addCreatedSession, select, showNotice, followWokenWorker, refreshHistory,
-  leaveGoneSession, runCommand, toast, alert = (text) => globalThis.alert(text),
+  leaveGoneSession, runCommand, toast, closesOn = null, alert = (text) => globalThis.alert(text),
 }) {
   const promptEl = composer.el;
   const actionBtn = composer.button;
@@ -64,6 +71,10 @@ export function createSendTurn({
     alert(e.message);
   }
 
+  // The line being sent ({to, line}) until its /turn answers: a second
+  // Enter on a slow link (the text still in the box) doesn't send it again.
+  let inFlight = null;
+
   async function send({ delivery: chosen = null } = {}) {
     if (store.current.owner === "tui") return;
     // A fresh link's pick first: its /model is queued in the worker once
@@ -110,8 +121,10 @@ export function createSendTurn({
       composer.clear();
       return;
     }
-    if (route.command) return runCommand(route.command);
-    prompt = route.send;
+    if (route.command && runCommand) return runCommand(route.command);
+    // A viewer without session commands (viewer.js): the line goes as a turn, and the worker decides.
+    prompt = route.command ?? route.send;
+    if (inFlight && inFlight.to === session() && inFlight.line === line) return;
     const isRunning = running() && !!session();
     const delivery = route.delivery || (isRunning ? chosen || armed : null);
     const hint = historyEl.querySelector(".hint");
@@ -134,6 +147,8 @@ export function createSendTurn({
     // The session the line goes to: the page may switch to another while an
     // image uploads or the turn is sent, and what follows stays with this one.
     const sentTo = session();
+    const flight = { to: sentTo, line };
+    inFlight = flight;
     try {
       await uploadChips(sending, sentTo, { upload: api.uploadImage });
       const verifyAnchor = verify();
@@ -208,13 +223,16 @@ export function createSendTurn({
       // A stale tab sent into a session deleted meanwhile: the start page
       // says so, and the line stays in the composer.
       if (e.code === "not_found") return leaveGoneSession(sentTo, "not_found");
+      if (sentTo === session() && closesOn?.(e)) return;
       // A /queue to a worker that can't queue (it would steer): its words, the text kept.
       if (e.code === "delivery_unavailable" && sentTo === session()) return addCommandBubble({ label: null, line, text: e.body?.detail || e.message, failed: true });
       // A Revise to a worker from before Revise turns (the page's gate saw
-      // none yet): its words, the text and the chip kept.
-      if (e.code === "revise_unavailable" && sentTo === session()) return addCommandBubble({ label: null, line, text: e.body?.detail || e.message, failed: true });
+      // none yet), or a participant's of an answer not theirs or overtaken
+      // since the tap: the server's words, the text and the chip kept.
+      if (REVISE_REFUSALS.includes(e.code) && sentTo === session()) return addCommandBubble({ label: null, line, text: e.body?.detail || e.message, failed: true });
       toast(cantText("send", e), null, { sticky: true });
     } finally {
+      if (inFlight === flight) inFlight = null;
       actionBtn.disabled = store.current.owner === "tui";
       composer.focus();
     }

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

@@ -54,7 +54,7 @@ export const FIELDS = {
     writers: "owner_verify.js placeVerdict (settleRunning); verdict_fresh.js startFresh pushes in place (D8)",
   },
   createdAt: { redraws: ["infoBar"], writers: "the payload" },
-  ctxPct: { redraws: ["infoBar"], writers: "stream_handlers.js (generation_chunk, context_status)" },
+  ctxPct: { redraws: ["infoBar"], writers: "session_state.js sessionStateFrom (the payload's context_status, else the saved fill), stream_handlers.js (generation_chunk, context_status)" },
   ctxWindow: { redraws: ["infoBar"], writers: "stream_handlers.js (generation_started, context_status)" },
   ctxWindowSource: { redraws: ["infoBar"], writers: "stream_handlers.js (generation_started, context_status)" },
   ctxUnknownAfterSwitch: { redraws: ["infoBar"], writers: "stream_handlers.js (generation_started, context_status)" },

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

@@ -109,10 +109,18 @@ export function sessionStateFrom(data) {
     bridgeUp: s.bridge_up === true,
     timing: normalizeTiming(data.timing),
   };
-  // The saved fill, so a reloaded or stopped session shows it before its
-  // next turn.
-  const savedPct = savedCtxPct(data.timing?.context, s.llm_context?.budget_tokens);
-  if (savedPct !== null) state.ctxPct = savedPct;
+  // The ctx fill: the live worker's newest estimate (shown in the session
+  // JSON as context_status, kept per request by the Engine) beats the saved
+  // fill, which is only the last counted turn's; without it, the saved fill.
+  const livePct = s.context_status?.est_pct;
+  if (typeof livePct === "number" && Number.isFinite(livePct)) {
+    state.ctxPct = livePct;
+  } else {
+    // The saved fill, so a reloaded or stopped session shows it before its
+    // next turn.
+    const savedPct = savedCtxPct(data.timing?.context, s.llm_context?.budget_tokens);
+    if (savedPct !== null) state.ctxPct = savedPct;
+  }
   if (data.timing?.context?.window_tokens) {
     state.ctxWindow = data.timing.context.window_tokens;
     state.ctxWindowSource = data.timing.context.window_source || null;

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

@@ -16,6 +16,7 @@
 //   historyEl, emptyEl    the history and the start page's empty box
 //   getSession(id, opts), openStream(id, fromSeq, handlers, opts)  data.js
 //   liveTurn, turnDom, questionCards, contextChips, participantsControl  the page's views
+//                         (contextChips, participantsControl: null for a viewer without them, viewer.js)
 //   view: {forgetSession(opts), renderSessionView(data, opts), endTurnView(kind, endText, opts)}
 //                         the session view (session_view.js)
 //   page: {clearNotice(), setSessionHash(id), setTurnRunning(running), setLiveStatus(status),
@@ -37,6 +38,8 @@ import { withoutWorker } from "./format.js";
 import { resyncRetry, streamDropEnd } from "./turn_events.js";
 import { createResyncReach } from "./resync_reach.js";
 import { keptCommandBubbles } from "./commands.js";
+import { foldKey } from "./stage_waiting.js";
+import { removeSession } from "./storage.js";
 
 // +opened+ false: the stream never delivered a frame (the proxy answered
 // 503, or the bridge refused it), so a retry waits a moment rather than
@@ -83,6 +86,10 @@ export function createSessionSync(deps) {
   async function select(id) {
     page.clearNotice();
     const same = store.selected === id;
+    // Leaving for another session: the fold this tab kept for the one left
+    // has no page to come back to (stage_waiting.js). A reselect of the same
+    // session keeps it: the page is redrawn, not left.
+    if (!same) removeSession(foldKey(store.selected));
     // 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(() => {
@@ -93,8 +100,8 @@ export function createSessionSync(deps) {
       emptyEl.classList.add("hidden");
       resyncAttempts = 0; // this session has its own re-read budget
       deps.view.forgetSession({ keepVerify: same });
-      contextChips.load(id);
-      participantsControl.load(id);
+      contextChips?.load(id);
+      participantsControl?.load(id);
     });
     await resync();
     // A folded composer stays folded: typing on the page opens it.