samagotchi 0.156.0 → 0.158.0

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

@@ -28,19 +28,24 @@ import { html, nothing, render } from "./vendor/lit-html.js";
 import { answerRefsOf, setAnswerRefs } from "./answer_refs.js";
 import { bindRowRefs } from "./refs.js";
 import { openAfterEnd } from "./block_open.js";
-import { leavesBlock } from "./card.js";
-import { failedTurnText, normalize, sourceLabel } from "./format.js";
+import { drawCard, isNoticeCard, leavesBlock, shownElsewhere } from "./card.js";
+import { routeChunk } from "./chunk_router.js";
+import { drawCommandBubble } from "./commands.js";
+import { endBubbleTemplate } from "./bubbles.js";
+import { drawnKind } from "./turn_drawing.js";
+import { failedTurnText, fullTime, normalize, sourceLabel } from "./format.js";
 import { thumbsTemplate } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
-import { hookNoticeLabel } from "./turn_events.js";
+import { emptyRetryLine, hookNoticeLabel, llmContextNotice, reminderText, steerCutLine } from "./turn_events.js";
 import {
   answerBubbleTemplate, cancelLineTemplate, commandBubbleTemplate, elementOf, emptyAnswerTemplate, noteBubbleTemplate, shellCommandMessage,
   steerRowTemplate, toolRowInnerTemplate, toolRowTemplate, userBubbleTemplate,
 } from "./turn_html.js";
-import { formatDuration, turnGroups, turnTimingText } from "./timing.js";
+import { cancelLineText, formatDuration, turnGroups, turnTimingText } from "./timing.js";
 import { createSentenceFeed } from "./sentences.js";
 import { createTicker } from "./thinking_ticker.js";
 import * as model from "./turn_model.js";
+import { answerGen, turnPieces } from "./turn_pieces.js";
 import { linkedLine } from "./notice_links.js";
 import { taskCommand, taskStopButton } from "./task_stop.js";
 import { footprintTemplate, groupItems, stampHistory } from "./working_set_view.js";
@@ -212,6 +217,7 @@ export function createTurnBlock({
   onChange = () => {},
   onThinkingLine = () => {},
   taskStop = null,
+  thumbs = null,
 }) {
   let turn = null;
   let blockEl = null;
@@ -482,7 +488,7 @@ export function createTurnBlock({
 
   // A live tool row is its own element, the reloaded row's template
   // (turn_html.js toolRowInnerTemplate) rendered into it on each event.
-  const rowThumbs = (images) => thumbsTemplate(sessionId(), images);
+  const rowThumbs = thumbs || ((images) => thumbsTemplate(sessionId(), images));
   // A row element → its stop-task button (syncTaskStop).
   const rowStops = new WeakMap();
 
@@ -643,14 +649,13 @@ export function createTurnBlock({
   function turnEnded({ kind, endNote = null, turnId = null }) {
     // Once per turn: a second end (a re-dispatched event) would promote again.
     if (!turn || turn.ended) return [];
-    const last = model.currentGen(turn);
     // A completed turn's answer is its last generation's text; a one-step
     // turn without tools leaves the block in any case (canceled, it is the
-    // partial text bubble).
-    const promoting = last && (kind === "completed" || (turn.gens.length === 1 && last.tools.length === 0));
+    // partial text bubble): turn_pieces.js answerGen.
+    const last = answerGen(turn, kind);
     if (pendingSteers.length) flushSteers();
     apply(model.turnEnded(turn));
-    if (promoting) promote(last, { endNote, turnId: kind === "completed" ? turnId : null });
+    if (last) promote(last, { endNote, turnId: kind === "completed" ? turnId : null });
     else if (endNote) placeAnswer([endNote], { plain: false, blockEl });
     const kept = [];
     if (blockEl) {
@@ -819,6 +824,140 @@ function failedLineTemplate(record) {
   return html`<div class="bubble cancel">${failedTurnText(failure)}</div>`;
 }
 
+// ---- A drawn turn ----
+
+// A drawn turn's card: the snapshot's card of its id when the page has it
+// (+cards+: CardStore's, its latest version, an update after the turn too,
+// as live shows it), else the drawing's with its buttons off. Where it
+// goes is the drawing's (drawnTurnNodes).
+function drawnCardEl(event, cards) {
+  const stored = (cards || []).find((c) => c?.type === "card" && String(c.id) === String(event.id));
+  const card = stored ? { ...stored, in_turn: true } : event;
+  const el = drawCard(document.createElement(isNoticeCard(card) ? "details" : "div"), card);
+  // The drawing's own copy (no CardStore card: capped out, or its file
+  // gone) can't tell whether its buttons still mean anything: off. A
+  // CardStore card's buttons are as CardStore lists them (it drops the
+  // dead ones itself: an earlier worker's, a turn that left nothing), as
+  // live leaves them.
+  if (!stored) el.querySelectorAll(".card-action").forEach((button) => { button.disabled = true; });
+  return el;
+}
+
+// A drawn turn's pieces (+group+: turnGroups' drawn group, its drawing
+// {events, end}), drawn by the live turn block itself: its events go
+// through the block's own handlers as the stream handlers send them live
+// (stream_handlers.js, the stage's view), so the steps, their rows,
+// notices, steers and in-turn cards are where live put them, then the
+// turn ends as live ended it. What live put beside the block (the stage's
+// extras: a reminder's bubble, a merged line's, a card that asks or
+// warns) comes back in arrival order. A merged line and the answer are
+// drawn from their saved items (their markdown, refs, keys), the steps'
+// texts take their items' markdown and refs.
+// @return {block, extras: [{el} | {merged: index}], answer: [nodes], end, kept: [nodes]}
+function drawnTurnNodes(group, items, { thumbs, capabilities = {}, cards = null }) {
+  const { events = [], end = {} } = group.drawing || {};
+  const kind = drawnKind(end);
+  let blockEl = null;
+  const answer = [];
+  const extras = [];
+  const view = createTurnBlock({
+    historyEl: document.createElement("div"), isNearBottom: () => false, sawText: () => {}, sessionId: () => null,
+    thumbs: (images) => thumbs(images), follow: () => {},
+    blockHost: (el) => { blockEl = el; },
+    placeAnswer: (pieces, { plain }) => {
+      if (plain) blockEl = null;
+      answer.push(...pieces);
+    },
+  });
+  const merged = [...(group.merged || [])];
+  // The ✂ marks a strategy saved on the turn's outputs since (its items'
+  // marks, by output id): an overlay on the rows, as a reload's.
+  const marks = Object.assign({}, ...items.filter((it) => it?.drawn === group.drawn && it.marks).map((it) => it.marks));
+  for (const event of events) {
+    switch (event?.type) {
+      case "turn_started": view.turnStarted(event); break;
+      case "generation_started": view.generationStarted(event, null); break;
+      case "generation_chunk": view.chunk({ ...routeChunk(event), iteration: event.iteration ?? null }); break;
+      case "generation_completed": view.generationCompleted(); break;
+      case "tool_call_started": view.toolStarted(event); break;
+      case "tool_call_completed": view.toolCompleted(marks[event.tool_id] ? { ...event, edit: marks[event.tool_id] } : event); break;
+      case "hook_notice": if (!shownElsewhere(event, capabilities)) view.notice(event); break;
+      case "empty_answer_retry": view.notice({ line: emptyRetryLine(event) }); break;
+      case "steer_cut": view.notice({ line: steerCutLine(event), cls: "steer-cut" }); break;
+      case "llm_context_edited": view.notice(llmContextNotice(event)); break;
+      case "pending_input_merged": (event.steers || []).forEach((steer) => view.steer(steer)); break;
+      case "merged_input": extras.push({ merged: merged.shift() ?? null }); break;
+      case "reminder_injected": {
+        const el = document.createElement("div");
+        drawCommandBubble(el, { label: null, line: reminderText(event), text: "" });
+        const when = fullTime(event.at);
+        if (when) el.title = when;
+        extras.push({ el });
+        break;
+      }
+      case "card": {
+        // Live: a card that asks (its actions run commands) or warns stays
+        // in sight beside the block (cards_place.js upsertCard, the
+        // stage's card); any other is a row of its step.
+        const el = drawnCardEl(event, cards);
+        const asks = (event.actions || []).some((a) => a && a.command);
+        const warn = el.classList.contains("warn");
+        if (asks || warn || !view.card(el)) extras.push({ el, warn });
+        break;
+      }
+      default: break;
+    }
+  }
+  const empty = kind === "completed" && (group.emptyAnswer != null || end.turn_summary?.empty_answer);
+  const endNote = empty ? elementOf(emptyAnswerTemplate(group.emptyAnswer != null ? items[group.emptyAnswer] : end.turn_summary.empty_answer)) : null;
+  const kept = view.turnEnded({ kind, endNote, turnId: end.turn_id || group.drawn }) || [];
+  if (endNote && !answer.includes(endNote)) answer.push(endNote);
+  // The stage's turn end: the warn cards beside the block leave with the
+  // block's, after the end line.
+  kept.push(...extras.filter((x) => x.warn).map((x) => x.el));
+  const steps = blockEl ? [...blockEl.querySelectorAll(":scope > .gen > .gen-text")] : [];
+  pairStepTexts(steps, group, items);
+  return {
+    block: blockEl,
+    extras: extras.filter((x) => !x.warn),
+    answer: answer.map((el) => (el.matches?.(".bubble.output") ? savedAnswer(el, group, items, kind) : el)),
+    end: kind === "canceled" ? endBubbleTemplate(cancelLineText(end.cancellation_reason || "", end.cancelled_by), { stopped: true })
+      : kind === "failed" ? endBubbleTemplate(failedTurnText(end)) : null,
+    kept,
+  };
+}
+
+// The live answer bubble as the reload draws it from its saved message
+// (its markdown, refs, display: answerBubbleTemplate), when one of the
+// turn's texts says what it says; else as live drew it.
+function savedAnswer(el, group, items, kind) {
+  const text = el.textContent.trim();
+  const at = [group.answer, ...[...(group.texts || [])].reverse()].find((i) => i != null && String(items[i]?.content ?? "").trim() === text);
+  if (at == null) return el;
+  return nodesOf(answerBubbleTemplate(items[at], { at, turnId: kind === "completed" ? group.turnId : null })).firstElementChild;
+}
+
+// The steps' texts paired with the turn's saved texts in order: each its
+// message's index (data-answer-at: its refs) and its rendered markdown,
+// as a reloaded step's (textTemplate).
+function pairStepTexts(els, group, items) {
+  const texts = (group.texts || []).filter((i) => i !== group.answer);
+  let k = 0;
+  for (const el of els) {
+    const text = el.textContent.trim();
+    const found = texts.slice(k).findIndex((i) => String(items[i]?.content ?? "").trim() === text);
+    if (found < 0) continue;
+    const at = texts[k + found];
+    k += found + 1;
+    const rendered = items[at]?.html;
+    if (typeof rendered === "string" && rendered) {
+      el.replaceWith(nodesOf(textTemplate(String(items[at].content), { live: false, at, rendered })).firstElementChild);
+    } else {
+      el.dataset.answerAt = String(at);
+    }
+  }
+}
+
 // A reloaded history as turn blocks (renderHistory's object path), as
 // nodes: per turn the prompt, a collapsed block of its steps when it had
 // any (stepTemplate, the live page's: texts, and with the server's parts
@@ -830,7 +969,11 @@ function failedLineTemplate(record) {
 // web.working_set): each block stamped with its
 // turn's ordinal and its rows with theirs (working_set_view.js), and the
 // turn's footprint on its summary line.
-export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, now = Date.now() }) {
+// +drawings+ (chi web's turn_drawings): a turn stamped with a drawn id is
+// drawn from its drawing (drawnTurnNodes), its pieces marked data-drawn;
+// +cards+ the snapshot's cards (a drawn card's body), +capabilities+ the
+// page's (a notice shown elsewhere).
+export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, now = Date.now(), drawings = null, cards = null, capabilities = {} }) {
   const timingTemplate = (group) => {
     const record = group.record;
     // Numbered by its place in the turn records, as live (a failed turn
@@ -868,6 +1011,38 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
     return answerBubble(j, " report-reply", null, replyKey);
   };
   const steerTemplate = (i, bubble) => steerRowTemplate({ source: items[i].source, text: items[i].content }, { bubble });
+  // A drawn turn's pieces (drawnTurnNodes), in the hand-off's order, each
+  // top-level element marked with its turn (data-drawn: cards_place.js
+  // leaves its in-turn entries alone, the reminder dedupe finds it).
+  const drawnGroupPieces = (group, ordinal) => {
+    const prompt = group.user != null ? items[group.user] : null;
+    const drawn = drawnTurnNodes(group, items, { thumbs, capabilities, cards });
+    if (drawn.block) {
+      if (workingSet) drawn.block.querySelector(":scope > summary > .tw-sum")?.prepend(nodesOf(footprintTemplate(groupItems(group, ordinal), ordinal)));
+      outlines.push(null);
+      blockEnds.push(null);
+      blockTurns.push(ordinal);
+    }
+    const lineKey = (i) => (items[i]?.source === "delegate_report" ? `${group.turnId}:input:${i - (group.user ?? i)}` : null);
+    const reviewer = group.answer !== null && prompt?.turn_id && prompt.participant_mode !== PAIR ? authorBadge(prompt.author, prompt.author_name) : null;
+    const pieces = turnPieces({
+      prompt: prompt ? (prompt.role === "note" ? noteBubbleTemplate(prompt) : userTemplate(prompt)) : null,
+      block: drawn.block,
+      merged: drawn.extras.map((x) => (x.el ? x.el : x.merged != null
+        ? html`${userTemplate(items[x.merged], { state: items[x.merged].merged ? "steered" : null, step: items[x.merged].step, lineKey: lineKey(x.merged) })}${reportReplyTemplate(x.merged, group)}`
+        : null)),
+      answer: drawn.answer,
+      timing: timingTemplate(group),
+      apply: reviewer ? applyRowTemplate(prompt.turn_id, reviewer) : null,
+      end: drawn.end,
+      kept: drawn.kept,
+    });
+    return pieces.flatMap((piece) => {
+      const els = piece?.nodeType === 1 ? [piece] : [...nodesOf(piece).children];
+      els.forEach((el) => { el.dataset.drawn = group.drawn; });
+      return els;
+    });
+  };
   const parts = [];
   // Each block's steps, in order: its outline once the nodes exist; how its
   // turn ended (whether it stays open); and its turn's place among the turns
@@ -876,7 +1051,7 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
   const blockEnds = [];
   const blockTurns = [];
   let turnOrdinal = -1;
-  const groups = turnGroups(items, timing);
+  const groups = turnGroups(items, timing, { drawings });
   // A quiet stretch before a group: its divider first (time_gaps.js).
   const gaps = groupGaps(groups, items, now);
   for (const [k, group] of groups.entries()) {
@@ -887,9 +1062,13 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
     // A `!cmd`'s record: its command bubble, no steps, no timing.
     if (group.kind === "command") { parts.push(userTemplate(items[group.i])); continue; }
     turnOrdinal += 1;
+    if (group.drawn) {
+      parts.push(drawnGroupPieces(group, turnOrdinal));
+      continue;
+    }
     const prompt = items[group.user];
     // A context wake turn starts with its note.
-    parts.push(prompt.role === "note" ? noteBubbleTemplate(prompt) : userTemplate(prompt));
+    const promptPiece = prompt.role === "note" ? noteBubbleTemplate(prompt) : userTemplate(prompt);
     const [only] = group.steps;
     const ended = group.answer !== null || group.emptyAnswer != null;
     const textless = only && (only.i === null || !String(items[only.i].content ?? ""));
@@ -897,8 +1076,9 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
     // none): no block, the plain answer's collapsed thinking block.
     const plainThinking = group.steps.length === 1 && ended && textless && !only.tools.length && only.thinking;
     const noBlock = !group.steps.length || plainThinking;
+    let block = null;
     if (plainThinking) {
-      parts.push(thinkingTemplate({ body: only.thinking, cls: "bubble thinking" }));
+      block = thinkingTemplate({ body: only.thinking, cls: "bubble thinking" });
     } else if (group.steps.length) {
       // A step's text with its message's rendered markdown (html: web.markdown on).
       const gens = group.steps.map((step) => ({
@@ -916,7 +1096,7 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
       // Its summary line: the working set's footprint, when the turn touched
       // something, then the steps (the live block's, stage_view.js handOff).
       const foot = workingSet ? footprintTemplate(groupItems(group, turnOrdinal), turnOrdinal) : nothing;
-      parts.push(html`<details class="turn-work done"><summary><span class="tw-sum">${foot}<span class="turn-steps">${model.blockSummary({ gens, ended: true })}</span></span></summary>${steps}</details>`);
+      block = html`<details class="turn-work done"><summary><span class="tw-sum">${foot}<span class="turn-steps">${model.blockSummary({ gens, ended: true })}</span></span></summary>${steps}</details>`;
       outlines.push(gens);
       // No record: a turn saved before them, or running at the reload.
       blockEnds.push(group.record?.status ?? "completed");
@@ -925,7 +1105,6 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
     // Steers with no step to sit in, or in a turn that shows no block: on
     // their own after the prompt.
     const loose = noBlock ? [...group.steps.flatMap((step) => step.steers || []), ...(group.steers || [])] : group.steers || [];
-    parts.push(loose.map((i) => steerTemplate(i, true)));
     // The user's lines merged into the turn: the live "steered" bubbles,
     // after its steps and before its answer. A delegate report's is
     // followed by the text that answered it when that isn't the answer: a
@@ -934,31 +1113,37 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
     // A report's fold key (answer_fold.js), as its reply's: the turn's id
     // and its place after the opening; none in a turn saved before turn ids.
     const lineKey = (i) => (group.turnId && items[i]?.source === "delegate_report" ? `${group.turnId}:input:${i - group.user}` : null);
-    parts.push((group.merged || []).map((i) =>
-      html`${userTemplate(items[i], { state: "steered", step: items[i].step, lineKey: lineKey(i) })}${reportReplyTemplate(i, group)}`));
-    // A turn that ended with no answer: chi's muted notice where the answer
-    // would be, before the timing, as live.
-    if (group.emptyAnswer != null) parts.push(html`${emptyAnswerTemplate(items[group.emptyAnswer])}${timingTemplate(group)}`);
-    // A turn with no answer (canceled, or running: no record yet) shows its
-    // timing after its prompt and steps, where the live view leaves it.
-    else if (group.answer === null) parts.push(timingTemplate(group));
-    else parts.push(answerTemplate(group.answer, timingTemplate(group), group.turnId));
+    const merged = (group.merged || []).map((i) =>
+      html`${userTemplate(items[i], { state: "steered", step: items[i].step, lineKey: lineKey(i) })}${reportReplyTemplate(i, group)}`);
     // A participant's review turn with a reply: Apply under it (the owner's
     // page only: the participant page has its own view). Not under a pair
     // turn: it acted itself.
     const reviewer = group.answer !== null && prompt.turn_id && prompt.participant_mode !== PAIR
       ? authorBadge(prompt.author, prompt.author_name) : null;
-    if (reviewer) parts.push(applyRowTemplate(prompt.turn_id, reviewer));
-    // A canceled turn ends with its cancel line, a failed one whose steps
-    // stayed with its failure line, as the live view left them.
-    parts.push(cancelLineTemplate(group.record));
-    parts.push(failedLineTemplate(group.record));
+    // The live hand-off's order (turn_pieces.js): a turn that ended with no
+    // answer has chi's muted notice where the answer would be, before the
+    // timing; a turn with no answer (canceled, or running: no record yet)
+    // its timing after its prompt and steps. A canceled turn ends with its
+    // cancel line, a failed one whose steps stayed with its failure line, as
+    // the live view left them.
+    parts.push(turnPieces({
+      prompt: promptPiece,
+      block,
+      steers: loose.map((i) => steerTemplate(i, true)),
+      merged,
+      answer: group.emptyAnswer == null && group.answer !== null ? [answerBubble(group.answer, "", group.turnId)] : [],
+      emptyNote: group.emptyAnswer != null ? emptyAnswerTemplate(items[group.emptyAnswer]) : null,
+      timing: timingTemplate(group),
+      apply: reviewer ? applyRowTemplate(prompt.turn_id, reviewer) : null,
+      end: html`${cancelLineTemplate(group.record)}${failedLineTemplate(group.record)}`,
+    }));
   }
   const out = nodesOf(parts);
   // A finished turn's block as the live end leaves it: its outline, closed
   // unless the turn was cut short.
   const blocks = [...out.children].filter((el) => el.matches(".turn-work"));
-  blocks.forEach((block, i) => { block.open = openAfterEnd(blockEnds[i], outlineBlock(block, outlines[i] || [])); });
+  // A drawn block is outlined and opened as its live end left it.
+  blocks.forEach((block, i) => { if (outlines[i] !== null) block.open = openAfterEnd(blockEnds[i], outlineBlock(block, outlines[i] || [])); });
   if (workingSet) stampHistory(blocks, blockTurns);
   // Each answer bubble and step text knows its message's refs
   // (answer_refs.js; the page pairs them after the render), the index

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

@@ -0,0 +1,43 @@
+// A finished turn's drawing (chi web's turn_drawings: {events, end}, the
+// Bridge's TurnDrawings unfolded once, in Ruby): what the live page drew for
+// the turn, which a reload draws again (turn_block.js drawnTurnNodes feeds
+// these events to a live turn block) instead of rebuilding the turn from its
+// saved messages. Pure, no DOM: timing.js folds a drawing into its steps
+// here (the working set's rows, the footprint), and a new module, so a
+// cached older page never imports a name its modules lack.
+import * as model from "./turn_model.js";
+
+const END_KINDS = Object.freeze({ turn_completed: "completed", turn_canceled: "canceled", turn_failed: "failed" });
+
+// How the drawn turn ended ("completed", "canceled", "failed"), from its end
+// event's type.
+export function drawnKind(end) {
+  return END_KINDS[end?.type] || "completed";
+}
+
+// The drawing's events folded as turn_model.js folds a live turn (the same
+// exports the turn block calls), ended: its gens, each with its tool rows.
+export function drawingTurn(drawing) {
+  const turn = model.newTurn();
+  for (const event of drawing?.events || []) {
+    switch (event?.type) {
+      case "turn_started": model.turnStarted(turn); break;
+      case "generation_started": model.generationStarted(turn, event.iteration ?? null); break;
+      case "generation_chunk":
+        if (event.text || event.thinking) model.chunk(turn, { text: event.text || "", thinking: event.thinking || "", iteration: event.iteration ?? null });
+        break;
+      case "tool_call_started": model.toolStarted(turn, event); break;
+      case "tool_call_completed": model.toolCompleted(turn, event); break;
+      default: break;
+    }
+  }
+  model.turnEnded(turn);
+  return turn;
+}
+
+// The ids of the drawn turns among +items+ (their `drawn` stamps, a
+// drawing for each in +drawings+).
+export function drawnIds(items, drawings) {
+  if (!drawings) return new Set();
+  return new Set((items || []).map((item) => item?.drawn).filter((id) => typeof id === "string" && drawings[id]));
+}

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

@@ -346,6 +346,10 @@ export function replaysDrawnTurn(event, turnRecords = []) {
   return turnRecords.some((record) => record.id === event.turn_id);
 }
 
+// REMOVE one release after chi web sends replay (see
+// ~/.claude/plans/arch-turn-records.md): chi web's show sends these events
+// itself (`replay`, TurnAccumulator.join_events); kept exported meanwhile, as
+// an old cached app.js imports it from this module.
 // A session view from the server (GET /api/sessions/:id on a live worker)
 // as the live events that would have drawn it: the turn in progress (its
 // parts in order), then the prompts queued behind it. app.js feeds these to
@@ -441,6 +445,10 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], queued_
           closeText();
           events.push({ type: "pending_input_merged", count: 0, content: null, steers: [{ source: part.source, text: part.text }] });
           break;
+        // A join draws the turn's cards from the snapshot's (CardStore), as
+        // TurnAccumulator.replay_events leaves them out.
+        case "card":
+          break;
         default:
           break;
       }
@@ -453,7 +461,8 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], queued_
   }
   // Commands waiting for the turn's end: their bubbles, as live.
   for (const entry of commands || []) {
-    events.push({ type: "command_queued", command_id: entry.command_id, client_id: entry.client_id, line: entry.line, waits: "turn_end" });
+    const author = entry.author ? { author: entry.author } : {};
+    events.push({ type: "command_queued", command_id: entry.command_id, client_id: entry.client_id, line: entry.line, waits: "turn_end", ...author });
   }
   return events;
 }

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

@@ -0,0 +1,29 @@
+// A finished turn's pieces in one order, and which step's text is its
+// answer: the one rule the live hand-off (stage_model.js handOffOrder, the
+// turn block's turnEnded) and a reload (turn_block.js turnHistoryNodes)
+// both follow, so the two can't place a piece differently. Pure: the pieces
+// are whatever the caller draws (nodes, lit templates); a missing one is
+// skipped.
+
+// The turn's pieces in order: its prompt (none for a reminder turn), its
+// block of steps, the steers no step holds, the lines merged into it in
+// arrival order (live: every extra, cards too), the answer's pieces or the
+// notice of a turn with none, the timing line, a participant's review Apply,
+// the end line (cancel, failure), the kept cards, then the lines queued for
+// after the turn (they run next).
+export function turnPieces({ prompt = null, block = null, steers = [], merged = [], answer = [], emptyNote = null, timing = null,
+  apply = null, end = null, kept = [], queued = [] } = {}) {
+  return [prompt, block, ...steers, ...merged, ...answer, emptyNote, timing, apply, end, ...kept, ...queued].filter(Boolean);
+}
+
+// The generation whose text is +turn+'s answer when it ended as +kind+
+// ("completed", "canceled", "failed"), else null: its current (last, still
+// open) generation, for a completed turn always, for any turn of one step
+// without tools too (canceled, it is the partial text). +turn+: turn_model.js's
+// {gens: [{tools, closed}]}.
+export function answerGen(turn, kind) {
+  const gens = turn?.gens || [];
+  const last = gens[gens.length - 1];
+  if (!last || last.closed) return null;
+  return kind === "completed" || (gens.length === 1 && last.tools.length === 0) ? last : null;
+}

data/lib/samagotchi/web/reload_check_route.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "../log"
+require_relative "../worker_link"
+
+module Samagotchi
+  module Web
+    # POST /api/sessions/:id/reload_check, mixed into App: the opt-in reload
+    # check's report (web.reload_check; the page's reload_check.js compares a
+    # finished turn as it was drawn live with a reload of it, history_shape.js).
+    # One log line per check, counts only, never content: reload_checked,
+    # and reload_mismatch with the kinds that differed and the ACCEPTED
+    # entries that would excuse them (the page's check is strict). The pod count is
+    # `grep -c reload_mismatch` over `grep -c reload_checked`, split by
+    # kinds, drawn and worker_version. See docs/configuration.md.
+    module ReloadCheckRoute
+      # history_shape.js KINDS: the only tokens a kinds list may carry
+      # (spec/web/reload_check_route_spec.rb reads the JS list).
+      KINDS = %w[prompt steered note command recap block step steer row notice card question thinking answer
+                 empty-answer timing cancel failed other].freeze
+      # history_shape.js ACCEPTED's ids: the only tokens an excused list may
+      # carry (the same spec reads the JS list).
+      ACCEPTED_IDS = %w[command-bubble edit-mark].freeze
+      # A turn id the line may name (a uuid, a test's id); anything else is
+      # dropped.
+      TURN_ID = /\A[0-9A-Za-z_-]{1,64}\z/
+
+      # The turns already checked, by session and turn id: every open owner
+      # tab runs the check, and only the first one's report is logged (a
+      # second tab's is answered 204 and dropped). Bounded: the oldest go
+      # first past LIMIT; a restarted chi web starts over.
+      class Seen
+        LIMIT = 2000
+
+        def initialize
+          @mutex = Mutex.new
+          @keys = {}
+        end
+
+        # Whether +key+ is new (and now seen).
+        def first?(key)
+          @mutex.synchronize do
+            next false if @keys.key?(key)
+
+            @keys[key] = true
+            @keys.shift while @keys.size > LIMIT
+            true
+          end
+        end
+      end
+
+      private
+
+      # {turn_id, same, kinds, excused, explained, drawn} from the page: 204,
+      # whatever it said
+      # (fire-and-forget); 400 for a body that isn't a JSON object.
+      # worker_version is chi web's own view of the session's worker (its
+      # sidecar), never the body's.
+      def handle_reload_check(req, id)
+        body = parse_json(request_body(req, 4096))
+        return error_response(400, "invalid_json", "invalid JSON body") unless body.is_a?(Hash)
+
+        turn_id = body["turn_id"].to_s.match?(TURN_ID) ? body["turn_id"] : nil
+        # Another tab's report of a turn already counted.
+        return [204, { "Cache-Control" => "no-store" }, []] if turn_id && !@reload_checks.first?([id, turn_id])
+
+        same = body["same"] == true
+        drawn = body["drawn"] == true
+        fields = { sid: id, turn_id: turn_id, same: same, drawn: drawn, worker_version: checked_worker_version(id) }
+        Log.info(:web, "reload_checked", **fields)
+        unless same
+          Log.info(:web, "reload_mismatch", **fields.except(:same), kinds: checked_tokens(body["kinds"], KINDS),
+                                                                   excused: checked_tokens(body["excused"], ACCEPTED_IDS),
+                                                                   explained: body["explained"] == true)
+        end
+        [204, { "Cache-Control" => "no-store" }, []]
+      end
+
+      # +tokens+ as a sorted comma list of +known+'s, the rest dropped.
+      def checked_tokens(tokens, known)
+        Array(tokens).map(&:to_s).select { |token| known.include?(token) }.uniq.sort.join(",")
+      end
+
+      # The version of the chi the session's live worker runs (its
+      # sidecar), nil without one.
+      def checked_worker_version(id)
+        dir = @session_class.session_dir(id, state_dir: default_state_dir)
+        link = WorkerLink.resolve(dir, unlink: false)
+        link.live? ? link.sidecar&.version : nil
+      rescue StandardError
+        nil # degrade-ok: a line without the version is still counted
+      end
+    end
+  end
+end

data/lib/samagotchi/web/server.rb

@@ -100,6 +100,7 @@ module Samagotchi
                       annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
                       editor: Config::BY_KEY["web.editor"].default, new_token: false,
                       working_set: Config::BY_KEY["web.working_set"].default, tunnel: nil, start_dir_from: :flag,
+                      reload_check: Config::BY_KEY["web.reload_check"].default,
                       restarted: false, restart_argv: ["web"], exec: nil)
         handed_on = false # a :restart leaves Serve to the next process, a run turns it off itself
         start_given = !start_dir.to_s.strip.empty?
@@ -159,7 +160,7 @@ module Samagotchi
           Push.preflight!(public_url)
           options = { port: port, host: host, url: url, open_browser: open_browser, markdown: markdown,
                       annotate_presets: annotate_presets, editor: editor, lan: lan, working_set: working_set,
-                      public_url: public_url, start_dir: start_dir }
+                      reload_check: reload_check, public_url: public_url, start_dir: start_dir }
           started = if plan
                       with_tunnel(provider, plan) do |up|
                         start(**options, public_notes: provider.start_lines(plan, restarted: restarted), on_bound: up)
@@ -388,6 +389,7 @@ module Samagotchi
                      annotate_presets: Config::BY_KEY["web.annotate_presets"].default, hub: nil, lan: nil,
                      editor: Config::BY_KEY["web.editor"].default, token_path: Token.path,
                      working_set: Config::BY_KEY["web.working_set"].default, public_url: nil, public_notes: [],
+                     reload_check: Config::BY_KEY["web.reload_check"].default,
                      on_bound: nil, start_dir: Dir.pwd, update_check: nil, auto_update: nil)
         config_restart_unsubscribe = ConfigFile.watch_restart_settings!(process: :web) do |message|
           Samagotchi::Log.warn(:config, "restart_required", echo: "Warning: config: #{message}")
@@ -404,7 +406,7 @@ module Samagotchi
         push = push_runtime(public_url, state_dir)
         app = App.new(manager: manager, state_dir: state_dir, markdown: markdown,
                       annotate_presets: annotate_presets, editor: editor, hub: hub, lan: lan_option, working_set: working_set,
-                      public_url: public_url, public_token: public_token, push: push, start_dir: start_dir)
+                      reload_check: reload_check, public_url: public_url, public_token: public_token, push: push, start_dir: start_dir)
         # update.auto: install; a stand-in app (a spec's) has no operations to run.
         auto_update ||= AutoUpdate.new(hub: hub, ops: app.update_ops, check: update_check, preflight: method(:restart_preflight)) if app.respond_to?(:update_ops)
         webrick = nil

data/lib/samagotchi/web/session_access_routes.rb

@@ -109,8 +109,8 @@ module Samagotchi
       end
 
       # GET /api/sessions/summaries: the rows chi sessions list prints
-      # (SessionManager.session_summaries: status, live, busy, owner, recap,
-      # ctx_pct, waiting, …), filtered as its flags filter. Params: dir (a
+      # (SessionRow#to_summary_h, its 28 keys: status, live, busy, owner,
+      # recap, ctx_pct, waiting, …), filtered as its flags filter. Params: dir (a
       # folder: its project's sessions; none: every project's), cwd (in that
       # folder or below), live=1, archived=1, tests=0 (leave test runs out),
       # sort, order, limit. An array, newest first by default.
@@ -128,7 +128,7 @@ module Samagotchi
           project_root: dir && ProjectScope.root_for(dir), include_archived: truthy_param?(req.params["archived"]),
           sort: sanitize_sort(req.params["sort"]), order: sanitize_order(req.params["order"])
         )
-        json_response(200, rows)
+        json_response(200, rows.map(&:to_summary_h))
       end
 
       # POST /api/sessions/:id/wait/prepare: what chi send --wait and chi

data/lib/samagotchi/web/session_control.rb

@@ -207,7 +207,7 @@ module Samagotchi
         when :accepted
           record_history(body, prompt)
           # via: bridge or file (the worker was gone: its input file), which
-          # names the turn a remote chi send --wait follows (WaitTarget).
+          # names the turn a remote chi send --wait follows (ReplyWait::Target).
           json_response(202, result.ack.merge("via" => result.via.to_s))
         when :refused then json_response(result.code, result.ack)
         when :timeout then error_response(504, "worker_timeout", result.detail)