samagotchi 0.134.0 → 0.136.0

data/lib/samagotchi/web/public/{turn_view.js → turn_block.js}

@@ -1,6 +1,6 @@
-// The turn view of a running turn (web.view: turn, and the stage's block):
-// one <details class="turn-work"> per turn holding one <details
-// class="gen"> per generation, the current one live (open, at the bottom),
+// The turn block of a running turn (the stage's cloud, stage_view.js): one
+// <details class="turn-work"> per turn holding one <details class="gen">
+// per generation, the current one live (open, on top while the turn runs),
 // the earlier ones collapsed to one line each. At the turn's end the last
 // generation's narration moves out of the block as the answer bubble, so
 // markdown, annotate and the turn output dedupe work on a plain bubble.
@@ -38,7 +38,6 @@ import { 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 { createHold } from "./hold.js";
 import { linkedLine } from "./notice_links.js";
 import { taskCommand, taskStopButton } from "./task_stop.js";
 import { footprintTemplate, groupItems, stampHistory } from "./working_set_view.js";
@@ -188,32 +187,23 @@ function rowNodes(rows, thumbs) {
   return nodes;
 }
 
-// ---- The live view ----
+// ---- The live block ----
 
-// The container seams (the stage view composes this view, stage_view.js):
-//   blockHost(el)  puts the turn's block in the page (default: the history);
-//   follow()       keeps the live part in view (default: the history's
-//                  tail), called only when isNearBottom() said so before
-//                  the change;
+// The container seams (the stage composes the block, stage_view.js):
+//   blockHost(el)  puts the turn's block in the page (the cloud);
+//   follow()       keeps the live part in view, called only when
+//                  isNearBottom() said so before the change;
 //   placeAnswer(pieces, { plain, blockEl }) puts the promoted answer (a
-//                  plain answer's thinking, cards, bubble) in the page
-//                  (default: in the block's place for a plain answer,
-//                  else after it in the history);
-//   useHold        the answer's pop at the narration box's height (hold.js);
-//   newestFirst    a new step goes on top of the block while the turn runs
-//                  (chronological() restores the order);
+//                  plain answer's thinking, cards, bubble) in the page;
 //   onChange()     after anything in the turn changed (the stage redraws
 //                  its slots from current());
 //   onThinkingLine(sentence) the live step's ticker showed a new line;
 //   taskStop       the page's stopper (task_stop.js): a running task_wait
 //                  row gets its stop-task button (none: no button).
-export function createTurnView({
-  historyEl, appendToHistory, isNearBottom, sawText, sessionId,
-  blockHost = appendToHistory,
-  follow = () => { historyEl.scrollTop = historyEl.scrollHeight; },
-  placeAnswer = defaultPlaceAnswer(appendToHistory),
-  useHold = true,
-  newestFirst = false,
+// A new step goes on top of the block while the turn runs (chronological()
+// restores the order at its end).
+export function createTurnBlock({
+  historyEl, isNearBottom, sawText, sessionId, blockHost, follow, placeAnswer,
   onChange = () => {},
   onThinkingLine = () => {},
   taskStop = null,
@@ -229,9 +219,6 @@ export function createTurnView({
   let pendingSteers = [];
   const dirty = new Set();
   let rafPending = false;
-  // The promoted answer bubble while it is held at the box's height (the
-  // pop, D6).
-  const hold = createHold({ isNearBottom, follow });
 
   function removeHint() {
     const hint = historyEl.querySelector(".hint");
@@ -256,8 +243,8 @@ export function createTurnView({
   }
 
   // The step rendered again from its state (stepTemplate). Each live step
-  // is its own lit root, not an item of one block template: newestFirst
-  // puts a new step on top and chronological() reorders them, and lit
+  // is its own lit root, not an item of one block template: a new step
+  // goes on top and chronological() reorders them, and lit
   // (without the keyed repeat directive, not vendored) matches list items
   // by index, so a block-wide render would hand step N's <details> (and
   // its hand toggle) to another gen. The root's part lives on entry.end
@@ -319,8 +306,7 @@ export function createTurnView({
     draw(entry);
     entry.el = entry.end.previousElementSibling || entry.frag.querySelector("details.gen");
     const stick = isNearBottom();
-    if (newestFirst) blockEl.insertBefore(entry.frag, blockSummaryEl.nextSibling);
-    else blockEl.appendChild(entry.frag);
+    blockEl.insertBefore(entry.frag, blockSummaryEl.nextSibling);
     if (stick) follow();
     return entry;
   }
@@ -447,25 +433,8 @@ export function createTurnView({
     if (k) sawText(k);
   }
 
-  // A step that closes mid-turn (the next one starts) collapses: a warn card
-  // in it would go out of sight until the turn ends. It moves out of the
-  // step, right after it in the block (open while the turn runs), where
-  // turnEnded still finds it and takes it out of the block (leavesBlock).
-  // The card stays in entry.items while it sits outside the step: safe only
-  // because the step's items are never removed or reordered after this (a
-  // late row is appended, a no-op for the parts before it). A render whose
-  // items shifted would make lit insert the card back into the step (or
-  // another item into its slot).
-  function liftWarnCards(gen) {
-    const entry = genEls.get(gen);
-    if (!entry) return;
-    const cards = [...entry.el.querySelectorAll(".plugin-card.warn")];
-    if (cards.length) entry.end.after(...cards);
-  }
-
   function apply(r) {
     if (!r) return;
-    if (r.closed && r.opened) liftWarnCards(r.closed);
     if (r.closed) closeGenEl(r.closed);
     if (r.opened) createGenEl(r.gen);
     if (r.closed || r.opened) updateBlockSummary();
@@ -579,14 +548,11 @@ export function createTurnView({
     return true;
   }
 
-  // The answer: the gen's narration leaves the block as a bubble. With
-  // +heldHeight+ (the live box's height, measured before the step closed) the
-  // bubble is held at that height, scrolled to its tail, until answerReady()
-  // (the rendered markdown landed) or 1.5 s reveals it.
+  // The answer: the gen's narration leaves the block as a bubble.
   // +endNote+: the notice of a turn that ended with no answer (app.js
   // builds it), placed where the answer bubble would go. +turnId+: a
   // completed turn's id, the bubble's data-answer-turn as a reload's.
-  function promote(gen, { heldHeight = 0, endNote = null, turnId = null } = {}) {
+  function promote(gen, { endNote = null, turnId = null } = {}) {
     const entry = genEls.get(gen);
     // No text (an empty answer): no bubble.
     let bubble = null;
@@ -596,8 +562,6 @@ export function createTurnView({
       bubble.textContent = gen.text;
       if (turnId) bubble.dataset.answerTurn = turnId;
     }
-    // A hidden tab gets no pop: nobody sees it, and its timers are throttled.
-    const holding = useHold && heldHeight > 0 && !!bubble && !document.hidden;
     model.takeAnswer(turn, gen);
     draw(entry);
     // Cards and hook notices in a step that goes (below, or with the whole
@@ -627,14 +591,6 @@ export function createTurnView({
     } else {
       placeAnswer(bubble ? [...cards, bubble] : [...cards, ...(endNote ? [endNote] : [])], { plain: false, blockEl });
     }
-    if (holding) {
-      // Bubbles are border-box: the box's height plus the bubble's own
-      // padding and border keeps the same three lines in view.
-      const cs = getComputedStyle(bubble);
-      const chrome = ["paddingTop", "paddingBottom", "borderTopWidth", "borderBottomWidth"]
-        .reduce((sum, k) => sum + (parseFloat(cs[k]) || 0), 0);
-      hold.start(bubble, heldHeight + chrome);
-    }
   }
 
   // Returns the cards that left the block (card.js leavesBlock), detached:
@@ -652,16 +608,9 @@ export function createTurnView({
     // 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));
-    // The box's height, measured while it is still in the DOM and the step
-    // still open: the apply below swaps it for the full text and collapses
-    // the step. Only a completed turn's answer pops; a canceled or failed
-    // one shows at once.
-    const lastEntry = promoting && kind === "completed" ? genEls.get(last) : null;
-    const box = lastEntry ? narrationEl(lastEntry) : null;
-    const heldHeight = box ? box.getBoundingClientRect().height : 0;
     if (pendingSteers.length) flushSteers();
     apply(model.turnEnded(turn));
-    if (promoting) promote(last, { heldHeight, endNote, turnId: kind === "completed" ? turnId : null });
+    if (promoting) promote(last, { endNote, turnId: kind === "completed" ? turnId : null });
     else if (endNote) placeAnswer([endNote], { plain: false, blockEl });
     const kept = [];
     if (blockEl) {
@@ -669,7 +618,7 @@ export function createTurnView({
       blockEl.classList.add("done");
       // The outline (turn_model.js outlineRuns): open on its narrated steps'
       // rows, as a reload draws it; a block with nothing said closes.
-      if (newestFirst) chronological();
+      chronological();
       const outlined = outlineBlock(blockEl, model.blockGens(turn));
       if (!blockToggled) blockEl.open = outlined;
       for (const el of blockEl.querySelectorAll(".plugin-card")) {
@@ -683,8 +632,8 @@ export function createTurnView({
     return kept;
   }
 
-  // The steps back in chronological order after newestFirst (a no-op
-  // otherwise); a fold (outlineBlock) stays before its run's first step.
+  // The steps back in chronological order (they ran newest first); a fold
+  // (outlineBlock) stays before its run's first step.
   function chronological() {
     if (!blockEl || !turn) return;
     for (const gen of turn.gens) {
@@ -698,7 +647,6 @@ export function createTurnView({
   }
 
   function reset() {
-    hold.finish();
     turn = null;
     blockEl = null;
     blockSummaryEl = null;
@@ -777,9 +725,6 @@ export function createTurnView({
     steer,
     card,
     flush,
-    // The rendered answer landed (or the re-read failed): let the held
-    // bubble pop. A no-op with nothing held.
-    answerReady() { hold.reveal(); },
     // The live gen's narration box shows complete sentences, its thinking is
     // appended by delta (the ticker); a selection in either is refused while
     // the step is live — the quote lands once it closes (then on the full
@@ -792,9 +737,8 @@ export function createTurnView({
       return !!text?.contains(el) || !!entry.thinkingText?.parentNode?.contains(el);
     },
     reset,
-    // For a view that composes this one (the stage): the turn's model and
-    // block, a step's elements by index, and the steps back in
-    // chronological order after newestFirst.
+    // For the stage that composes the block: the turn's model and block, a
+    // step's elements by index, and the steps back in chronological order.
     current() { return { turn, blockEl }; },
     // The running turn's asking reply (turn_model.js askingText): what a
     // question or approval card keeps once answered.
@@ -811,15 +755,6 @@ export function createTurnView({
   };
 }
 
-// The turn view's answer placement: a plain answer's pieces in its block's
-// place (the block goes), else after the block in the history.
-function defaultPlaceAnswer(appendToHistory) {
-  return (pieces, { plain, blockEl }) => {
-    if (plain) blockEl.replaceWith(...pieces);
-    else pieces.forEach((el) => appendToHistory(el));
-  };
-}
-
 // ---- A reload ----
 
 // The text of a reloaded block's step +iteration+ (1-based, as the snapshot's
@@ -842,15 +777,15 @@ function failedLineTemplate(record) {
   return html`<div class="bubble cancel">${failedTurnText(failure)}</div>`;
 }
 
-// A reloaded history in the turn view (renderHistory's object path), as
+// 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
 // the thinking, params and output, from the saved messages; status and
 // duration from the timing's tool records), then the answer and the turn's
 // timing line under it.
 // +thumbs(images)+ draws a prompt's or a tool row's image thumbs (a
-// template, images.js thumbsTemplate). +workingSet+ (the stage view's
-// web.working_set, never the turn view's): each block stamped with its
+// template, images.js thumbsTemplate). +workingSet+ (the stage's
+// 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 line after it.
 export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, now = Date.now() }) {
@@ -905,6 +840,8 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
     if (group.kind === "note") { parts.push(noteBubbleTemplate(items[group.i])); continue; }
     if (group.kind === "steer") { parts.push(steerTemplate(group.i, true)); continue; }
     if (group.kind === "answer") { parts.push(answerTemplate(group.answer, nothing)); continue; }
+    // A `!cmd`'s record: its command bubble, no steps, no timing.
+    if (group.kind === "command") { parts.push(userTemplate(items[group.i])); continue; }
     turnOrdinal += 1;
     const prompt = items[group.user];
     // A context wake turn starts with its note.
@@ -946,8 +883,11 @@ export function turnHistoryNodes(items, timing, { thumbs, workingSet = false, no
     // followed by the text that answered it when that isn't the answer: a
     // small model tells its user about a report before its next tool call,
     // and that step's text would stay folded in the block.
+    // 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 })}${reportReplyTemplate(i, group)}`));
+      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)}`);

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

@@ -21,7 +21,7 @@ export function workerGoneText({ turnRunning, stopped = false }) {
   return stopped ? "\u25A0 canceled (session stopped)" : "\u2715 canceled (worker exited)";
 }
 
-// Whether the turn view ends now, or waits for the session re-read: a stream
+// Whether the running turn's DOM ends now, or waits for the session re-read: a stream
 // that was open and dropped with no stop (a phone briefly offline) says
 // nothing about the worker, and `resync` re-renders the turn and adds the end
 // line only when no worker took it — ending the view first is a wrong flash.
@@ -328,7 +328,7 @@ export function promptOps(event, { myId, known, unmatchedMerge = false, wakeStar
     case "pending_input_merged":
       if (!unmatchedMerge || !event.content) return [];
       if (unmatchedMerge === "report") {
-        return [{ op: "add", enqueuedId: null, prompt: event.content, state: wakeStart ? null : "steered", label: clientLabel(REPORT_CLIENT) }];
+        return [{ op: "add", enqueuedId: null, prompt: event.content, state: wakeStart ? null : "steered", label: clientLabel(REPORT_CLIENT), source: "delegate_report" }];
       }
       return [{ op: "add", enqueuedId: null, prompt: event.content, state: "steered", label: null }];
     default:
@@ -380,7 +380,7 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], queued_
           closeText();
           events.push({ type: "generation_started", iteration: part.iteration ?? null });
           break;
-        // The chunks carry the part's iteration, so the turn view groups a
+        // The chunks carry the part's iteration, so the turn block groups a
         // join like the live stream (turn_model.js).
         case "thinking":
           events.push({ type: "generation_chunk", text: "", thinking: part.text, iteration: part.iteration ?? null });

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

@@ -141,7 +141,7 @@ function tailClip(text) {
 // edit's collapsed diff, and a reloaded row's ✂ mark above its output. A
 // part with nothing to say is left out. A reload renders toolRowTemplate;
 // the live view renders toolRowInnerTemplate into its own row element
-// (turn_view.js), again on each event: lit writes only what changed, so a
+// (turn_block.js), again on each event: lit writes only what changed, so a
 // part the user toggled (the raw command, the diff, the read lines) stays.
 // +stop+: the live row's stop-task button (a node), after the title.
 export function toolRowTemplate(row, opts = {}) {
@@ -214,18 +214,8 @@ export function stateBadgeTemplate(state, delivery = null) {
   return html`<span class="state-badge">${text}${remove}</span>`;
 }
 
-// A `!cmd`'s saved user message (the worker appends "!(<command>)\n<output>"
-// for the next turn): its command line and its output, or null when the
-// content is any other message. The command sits on the first line inside
-// `!(` `)`; the output is everything after that first newline. A message
-// that merely starts with "!" or "!(" without the newline shape is a plain
-// message.
-export function shellCommandMessage(content) {
-  const text = String(content ?? "");
-  const match = text.match(/^!\((.*)\)\n([\s\S]*)$/);
-  if (!match) return null;
-  return { line: `!${match[1]}`, text: match[2] };
-}
+// A `!cmd`'s saved user message as its line and output (shell_command.js).
+export { shellCommandMessage } from "./shell_command.js";
 
 // A `!cmd`'s history bubble: the same markup the live page draws for a
 // command (app.js's drawCommandBubble): the line, the output in a
@@ -313,13 +303,27 @@ export function steerRowTemplate({ source, text } = {}, { bubble = false } = {})
 // +delivery+: how it was sent into a running turn (next_step, cut, queue):
 // its data-delivery and its queued badge's words. +author+: a
 // participant's badge (participant_names.js authorBadge: their name and
-// colour) in place of +label+.
-export function userBubbleTemplate(message, { label = null, state = null, step = null, thumbs = nothing, own = false, enqueuedId = null, key = null, delivery = null, author = null } = {}) {
+// colour) in place of +label+. A turn's opening carries its Revise stamp
+// (+message.revises+: data-revises, revise_stack.js) and whether it was a
+// Verify turn (+message.verify+: data-verify, no Revise on its answer).
+// +message.source+ (a delegate report's "delegate_report") is its
+// data-source; +lineKey+, a merged line's fold key (answer_fold.js:
+// data-line-key, the reload's "<turn id>:input:<place>").
+export function userBubbleTemplate(message, { label = null, state = null, step = null, thumbs = nothing, own = false, enqueuedId = null, key = null, delivery = null, author = null, lineKey = null } = {}) {
   const named = BADGES[state] ? state : null;
   const from = author
     ? html`<span class="origin-label author-badge" title=${authorBadgeTitle(author.name, author.mode)} data-unnamed=${author.unnamed ? "1" : nothing}>${authorBadgeText(author.name, author.mode)}</span>`
     : label ? html`<span class="origin-label">${label}</span>` : nothing;
-  return html`<div class=${`bubble user${named ? ` ${named}` : ""}${author ? " by-participant" : ""}`} title=${timeTitle(message?.at)} style=${author ? `--author-color:${author.color}` : nothing} data-author=${author?.author || nothing} data-participant-mode=${author?.mode || nothing} data-user-state=${named || nothing} data-step=${step ? Number(step) : nothing} data-copy-source=${copySource({ ...message, role: "user" })} data-user-content=${key !== null ? key : nothing} data-turn-id=${message?.turn_id || nothing} data-own=${own ? "1" : nothing} data-enqueued-id=${enqueuedId || nothing} data-delivery=${delivery || nothing}>${from}<div class="user-message">${userBodyTemplate(message?.content)}${thumbs}</div>${stateBadgeTemplate(named, delivery)}</div>`;
+  return html`<div class=${`bubble user${named ? ` ${named}` : ""}${author ? " by-participant" : ""}`} title=${timeTitle(message?.at)} style=${author ? `--author-color:${author.color}` : nothing} data-author=${author?.author || nothing} data-participant-mode=${author?.mode || nothing} data-user-state=${named || nothing} data-step=${step ? Number(step) : nothing} data-copy-source=${copySource({ ...message, role: "user" })} data-user-content=${key !== null ? key : nothing} data-turn-id=${message?.turn_id || nothing} data-revises=${(message?.turn_id && message?.revises?.turn_id) || nothing} data-verify=${message?.turn_id && message?.verify ? "1" : nothing} data-own=${own ? "1" : nothing} data-enqueued-id=${enqueuedId || nothing} data-delivery=${delivery || nothing} data-source=${message?.source || nothing} data-line-key=${lineKey || nothing}>${from}${userMessageTemplate(message, thumbs)}${stateBadgeTemplate(named, delivery)}</div>`;
+}
+
+// A user line's text: plain (its quotes set apart), or the server's
+// rendered markdown when the line has it (a delegate report's,
+// message_display.rb; a live line has none until a reload). Its copy
+// source stays the raw text either way (data-copy-source).
+function userMessageTemplate(message, thumbs) {
+  if (typeof message?.html === "string") return html`<div class="user-message markdown" .innerHTML=${message.html}></div>`;
+  return html`<div class="user-message">${userBodyTemplate(message?.content)}${thumbs}</div>`;
 }
 
 // The notice of a turn that ended with no answer (the server's

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

@@ -1,8 +1,8 @@
-// The generations of one turn, as the turn view shows them: a list of gens
+// The generations of one turn, as the turn block shows them: a list of gens
 // (one per model generation: its thinking, its narration, its tool rows),
 // the last one live until the next opens or the turn ends. Pure: fed by the
 // same events live and on a join (turn_events.js snapshotEvents), no DOM, so
-// `node --test` covers the grouping rules. turn_view.js draws it.
+// `node --test` covers the grouping rules. turn_block.js draws it.
 //
 // Rules:
 // - turn_started opens the first gen (no iteration yet).
@@ -177,7 +177,7 @@ export function askingText(turn) {
 // A plugin's refs on the reply that asks (a question's refs, from its
 // pending question): kept on the asking step's gen, the last one, while
 // the turn goes on, for the stage's asking slot (askingRefs) and the
-// step's closed text (turn_view.js). A non-array or an empty list keeps
+// step's closed text (turn_block.js). A non-array or an empty list keeps
 // what the gen has. The gen, or null.
 export function questionRefs(turn, refs) {
   if (!turn || turn.ended || !Array.isArray(refs) || !refs.length) return null;
@@ -202,7 +202,7 @@ export function turnEnded(turn) {
   return { gen: null, opened: false, closed };
 }
 
-// The turn's answer is +gen+'s text, moved out of the block (turn_view.js
+// The turn's answer is +gen+'s text, moved out of the block (turn_block.js
 // promote): a gen left with no thinking and no tool rows is no step then,
 // as it is no row, and as a reload counts it (turnGroups).
 export function takeAnswer(turn, gen) {
@@ -244,7 +244,7 @@ export function genLabel(gen) {
 // genLabel in its parts: +head+, +calls+ ("3 tool calls (1 failed)", or ""
 // without calls) and +repeats+: the head is words the open step's body
 // starts with (its narration, its first call's title), so an open step's
-// summary can say only its calls (turn_view.js labelHtml).
+// summary can say only its calls (turn_block.js labelHtml).
 export function genLabelParts(gen) {
   const line = String(gen.text || "").split("\n").map(plainLine).find(Boolean) || "";
   const calls = gen.tools.length ? toolCallsText(gen.tools) : "";
@@ -299,7 +299,7 @@ export function outlineRuns(gens) {
 }
 
 // A finished turn's steps as its block holds them: the answer's step left it
-// when the answer was all it had (turn_view.js promote).
+// when the answer was all it had (turn_block.js promote).
 export function blockGens(turn) {
   return turn.gens.filter((gen) => !(gen.answer && !gen.thinking && gen.tools.length === 0));
 }

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

@@ -132,6 +132,8 @@ async function startFresh(card, button, fresh) {
   }
   if (result?.ok) {
     if (fresh.errors) delete fresh.errors[of];
+    // In place, on purpose: on the owner page fresh.running is the session
+    // store's verifyFresh (session_fields.js, D8).
     if (fresh.running && !fresh.running.some((entry) => runningOf(entry) === of)) {
       fresh.running.push(result.child_id ? { of, child_id: result.child_id } : of);
     }

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

@@ -39,6 +39,7 @@
 // finds the row by them, never by a row key.
 import { html, nothing, render, svg } from "./vendor/lit-html.js";
 import { createChipPopover } from "./chip_popover.js";
+import { stillOn } from "./latest.js";
 import { showRow } from "./refs.js";
 import {
   addedItems, addLine, BUDGETS, dropRefusal, fold, footprint, footprintText, forgetOn, GLYPHS, INVERSE, isFresh, itemsOfTurn, labelText,
@@ -487,9 +488,10 @@ export function createWorkingSet({ historyEl, stageRoot = () => null, state, ses
     const id = session();
     if (!getWorkingSet || !id) return;
     const asked = events;
+    const still = stillOn(session, id);
     Promise.resolve()
       .then(() => getWorkingSet(id))
-      .then((snapshot) => { if (session() === id) takeServer(snapshot, { overtaken: events !== asked }); })
+      .then((snapshot) => { if (still()) takeServer(snapshot, { overtaken: events !== asked }); })
       .catch(() => {});
   }
 

data/lib/samagotchi/web/server.rb

@@ -92,7 +92,7 @@ module Samagotchi
       #   on while the server runs
       # @return [Integer] the exit status
       def self.launch(port: nil, host: nil, scope: "project", start_dir: nil, open_browser: false, markdown: false,
-                      view: Config::BY_KEY["web.view"].default, annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
+                      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,
                       restarted: false, restart_argv: ["web"], exec: nil)
@@ -152,7 +152,7 @@ module Samagotchi
           # would refuse, or a key store others can read, stops it here,
           # before any tunnel goes up.
           Push.preflight!(public_url)
-          options = { port: port, host: host, url: url, open_browser: open_browser, markdown: markdown, view: view,
+          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 }
           started = if plan
@@ -345,7 +345,7 @@ module Samagotchi
       # @return [Boolean, :restart] false when the port was taken (said so on stderr);
       #   :restart when the owner requested an in-place process replacement
       def self.start(port: nil, host: nil, url: nil, open_browser: false, state_dir: nil, manager: nil, markdown: false,
-                     view: Config::BY_KEY["web.view"].default, annotate_presets: Config::BY_KEY["web.annotate_presets"].default, hub: nil, lan: nil,
+                     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: [],
                      on_bound: nil, start_dir: Dir.pwd, update_check: nil)
@@ -362,7 +362,7 @@ module Samagotchi
         lan_option = { ip: lan.ip, token: Token::Source.new(token_path) } if lan
         public_token = Token::Source.new(token_path) if public_url
         push = push_runtime(public_url, state_dir)
-        app = App.new(manager: manager, state_dir: state_dir, markdown: markdown, view: view,
+        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)
         webrick = nil

data/lib/samagotchi/web/session_control.rb

@@ -196,11 +196,11 @@ module Samagotchi
 
         # no_interrupt: an attached TUI's --no-interrupt (chi --remote --attach).
         # author: the principal's (nil for the owner), never the body's.
-        verify = VerifyAnchor.from(body["verify"])
+        # anchors: a Verify turn's claim, a Revise turn's draft (TurnAnchors).
         result = SessionManager.deliver_turn(id, prompt: prompt.to_s, client_id: client_id, images: images,
                                                  delivery: delivery, no_interrupt: body["no_interrupt"] == true,
                                                  author: principal(req).author,
-                                                 verify: verify,
+                                                 anchors: TurnAnchors.from(body),
                                                  state_dir: @state_dir, manager: @manager,
                                                  bridge: -> { live_bridge_client(id) })
         case result.status

data/lib/samagotchi/web/session_create.rb

@@ -69,7 +69,7 @@ module Samagotchi
         return error if error
 
         # llm_context: the session's own LLM context values before its first
-        # turn (the start page's llm ctx chip; chi --llm-context), read
+        # turn (the start page's ⚙ panel; chi --llm-context), read
         # before anything spawns so a bad one spawns nothing.
         llm_context, error = request_llm_context(body["llm_context"])
         return error if error

data/lib/samagotchi/web/session_show.rb

@@ -13,6 +13,7 @@ require_relative "../session_commands"
 require_relative "../session_metrics"
 require_relative "../session_setting"
 require_relative "../system_one/log"
+require_relative "../toolkit"
 
 module Samagotchi
   module Web
@@ -151,14 +152,16 @@ module Samagotchi
         else
           session_json = session_json.merge(saved_served_model(session, persisted))
         end
-        # The per-session settings' chips (the info bar's llm ctx, think,
-        # reasoning and tools): the worker's, else worked out here from the
+        # The per-session settings' chips (the info bar's ⚙ chip: llm ctx, think
+        # and reasoning; the tools chip): the worker's, else worked out here from the
         # session file (SessionSetting#snapshot_value, #saved_summary).
         SessionSetting::ALL.each do |setting|
           chip = setting.snapshot_value(snapshot) { setting.saved_summary(session, registry: host_registry) }
           session_json = session_json.merge(setting.key => chip)
         end
-        session_json
+        # The 🧰 chip reads the session's toolkit against config's default:
+        # on it, the chip is 🧰 alone (a toolkit summary is nil on full only).
+        session_json.merge(toolkit_default: Toolkit.configured.name)
       end
 
       # ?cards=1: the page's re-read when a card arrives, for its rendered

data/lib/samagotchi/worker.rb

@@ -678,7 +678,7 @@ module Samagotchi
       @initial_turn = true
       fresh = @session.verify_fresh
       run_prompt(WorkerInbound::Prompt.new(text: prompt, origin: TurnOrigin.new(enqueued_id: @session.first_turn_id),
-                                           verify: fresh&.anchor))
+                                           anchors: { verify: fresh&.anchor }))
     ensure
       @initial_turn = false
     end
@@ -705,10 +705,10 @@ module Samagotchi
       @continue_offer.drop(origin)
       @turn_flow.before_prompt_turn
       run_engine_turn(prompt.text, origin: origin, max_iterations: max_iterations(prompt.no_interrupt),
-                                   images: prompt.images, **(prompt.verify ? { verify: prompt.verify } : {})) do |result, error|
+                                   images: prompt.images, **prompt.anchors.kwargs) do |result, error|
         if error
           # The Engine announced :turn_failed (with the error's one line).
-          restore_failed_turn([[prompt.text, origin, prompt.images, prompt.verify], *@merged_this_turn], error: error)
+          restore_failed_turn([[prompt.text, origin, prompt.images, prompt.anchors], *@merged_this_turn], error: error)
         else
           @continue_offer.after_turn(result, no_interrupt: prompt.no_interrupt)
         end
@@ -1395,10 +1395,10 @@ module Samagotchi
     # or the restored ones, never the one without the other. A turn that
     # got somewhere stays instead (TurnFlow#prompt_turn_failed), with the
     # prompts it took: nothing goes back.
-    # @param prompts [Array<Array(String, TurnOrigin|nil, Array|nil, VerifyAnchor|nil)>]
-    #   [prompt, origin, images, verify] (a web client gets its image chips
-    #   back, and a Verify turn's claim, so sending it again still records
-    #   a verdict)
+    # @param prompts [Array<Array(String, TurnOrigin|nil, Array|nil, TurnAnchors|nil)>]
+    #   [prompt, origin, images, anchors] (a web client gets its image chips
+    #   back, a Verify turn's claim, so sending it again still records a
+    #   verdict, and a Revise turn's draft, so it still stacks)
     # @param error [Exception, nil] what failed: its one line stays in the
     #   conversation as a turn note
     # Not saved here: run_engine_turn saves after its block.
@@ -1406,10 +1406,10 @@ module Samagotchi
       @engine.synchronize_events do
         next if @turn_flow.prompt_turn_failed(error: error) == :kept
 
-        prompts.each do |prompt, origin, images, verify|
+        prompts.each do |prompt, origin, images, anchors|
           restored = { type: :prompt_restored, prompt: prompt, origin: origin.wire }
           restored[:images] = images unless Array(images).empty?
-          restored[:verify] = verify.to_h if verify
+          restored.merge!(anchors.to_h) if anchors
           @engine.announce(restored)
         end
       end

data/lib/samagotchi/worker_inbound.rb

@@ -39,10 +39,11 @@ module Samagotchi
     # +no_interrupt+: an offer its turn makes keeps it for its continue
     # turn; +images+: its image refs ({file:, name:}); +delivery+: the wire
     # value the sender asked for ("queue", or nil for the default
-    # next_step); +origin+: a TurnOrigin (a Hash is read as one).
-    Prompt = Data.define(:text, :origin, :no_interrupt, :images, :delivery, :verify) do
-      def initialize(text:, origin: nil, no_interrupt: false, images: [], delivery: nil, verify: nil)
-        super(text:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:, verify: VerifyAnchor.from(verify))
+    # next_step); +origin+: a TurnOrigin (a Hash is read as one); +anchors+:
+    # a Verify turn's claim, a Revise turn's draft (TurnAnchors).
+    Prompt = Data.define(:text, :origin, :no_interrupt, :images, :delivery, :anchors) do
+      def initialize(text:, origin: nil, no_interrupt: false, images: [], delivery: nil, anchors: nil)
+        super(text:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:, anchors: TurnAnchors.from(anchors))
       end
     end
 
@@ -215,7 +216,7 @@ module Samagotchi
         return if input.images.empty? && queue_as_command(input.prompt, input.origin, File.basename(input_file))
 
         yield Prompt.new(text: input.prompt, origin: input.origin, no_interrupt: input.no_interrupt, images: input.images,
-                         delivery: input.delivery, verify: input.verify)
+                         delivery: input.delivery, anchors: input.anchors)
       ensure
         FileUtils.rm_f(claimed_file)
       end