samagotchi 0.168.0 → 0.169.0

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

@@ -24,6 +24,7 @@ import { clientLabel, isOwn } from "./turn_events.js";
 import { continueLine } from "./commands.js";
 import { plainText } from "./plain_line.js";
 import { noContactFill } from "./no_contact_fill.js";
+import { CONTINUE_KEY, questionKey } from "./stage_waiting.js";
 
 // A card's text fields' name: not a contact field (no_contact_fill.js).
 const CARD_NOTE = "chi-card-note";
@@ -35,8 +36,9 @@ const CARD_NOTE = "chi-card-note";
 // @param isNearBottom () => whether the history follows its end
 // @param scrollToEnd () scrolls the history to its end
 // @param removeHintIfEmpty () drops the history's placeholder hint
-// @param askingText () => the running turn's asking reply (turn_model.js
-//   askingText via the page's view), kept by a question or own approval card
+// @param askingText (pq) => the running turn's reply that asked +pq+
+//   (stage_asking.js askedText via the page's view), kept by a question or
+//   own approval card
 // @param renderMarkdown (text) => Promise<html|null>: the kept reply's
 //   markdown (the page's POST /api/render; null keeps the raw text)
 // @param linkRefs (el, refs) the page's ref pass on it: a plugin's +refs+
@@ -48,6 +50,9 @@ const CARD_NOTE = "chi-card-note";
 // @param onPending (pending|null) called whenever the open question changes:
 //   the page touches the redraws that read pendingQuestion() (the session
 //   bar's waiting chip, docs/internals/web-frontend.md write -> redraw)
+// @param onSettled (key) a card stopped waiting (answered, cancelled,
+//   replaced or removed; the continue card resolved or dropped), by its
+//   stage_waiting.js key: the stage's waiting cards as data
 // @return {renderQuestion(pq, {said}), resolveQuestion(id, opts), removeQuestion(),
 //   questionCard() (the live card or null), pendingQuestion() (or null),
 //   isResolved(id) (this page already saw that question answered),
@@ -56,7 +61,7 @@ export function createQuestionCards({
   sessionId, clientId, place, isNearBottom, scrollToEnd, removeHintIfEmpty, askingText = () => "",
   renderMarkdown = () => Promise.resolve(null), linkRefs = () => {}, pairRefs = () => {},
   api = { sendAnswer, dismissQuestion, sendCommand }, doc = globalThis.document,
-  onPending = () => {},
+  onPending = () => {}, onSettled = () => {},
 }) {
   // Live ask_user_question card, keyed by pending question id. Re-rendered from
   // pending_question on session select so a reload mid-question restores it.
@@ -99,7 +104,9 @@ export function createQuestionCards({
     // stage_view.js): the kind, and a delegate's question relayed here.
     card.dataset.kind = pq.kind || "question";
     if (relayView(pq)) card.dataset.relay = "1";
-    const asked = keepsAskingText(pq) ? String(said ?? askingText() ?? "").trim() : "";
+    // An approval says the tool it approves (the stage's replay rule for its lead-in).
+    if (approval && pq.approval?.tool) card.dataset.tool = String(pq.approval.tool);
+    const asked = keepsAskingText(pq) ? String(said ?? askingText(pq) ?? "").trim() : "";
     if (asked) saidOf.set(card, asked);
     // Open while pending: the question must be actionable.
     card.open = true;
@@ -110,8 +117,10 @@ export function createQuestionCards({
     summary.textContent = summaryText(pq);
     card.appendChild(summary);
     // A hand toggle: the resolve's auto-collapse then leaves it as the user
-    // left it (rememberToggle-style, as turn_block.js does).
-    summary.addEventListener("click", () => { card.dataset.toggled = "1"; });
+    // left it (rememberToggle-style, as turn_block.js does). Not a click whose
+    // toggle was refused: a card that waits in the stage has none of its own
+    // (stage_view.js).
+    summary.addEventListener("click", (e) => { if (!e.defaultPrevented) card.dataset.toggled = "1"; });
 
     // Relayed to the parent: say where else it waits (QuestionDesk#annotate).
     card.appendChild(renderRelayedTo(pq));
@@ -502,6 +511,7 @@ export function createQuestionCards({
     // After the collapse: a card left open by hand renders at once.
     if (full) renderSaidOnOpen(questionEl, full, asked, refs);
     resolvedId = pending.id;
+    onSettled(questionKey(questionEl.dataset.qid));
     setPending(null);
   }
 
@@ -567,8 +577,10 @@ export function createQuestionCards({
   function replaceQuestionCard() {
     if (!questionEl) return;
 
+    const key = questionKey(questionEl.dataset.qid);
     questionEl.remove();
     questionEl = null;
+    onSettled(key);
   }
 
   // ── continue card ──────────────────────────────────────────────────────────
@@ -587,6 +599,7 @@ export function createQuestionCards({
   // The old card goes: the step-limit question asks the same (a worker that
   // posts it announces continue_offered too, for older pages).
   function dropContinueCard() {
+    if (continueEl) onSettled(CONTINUE_KEY);
     continueEl?.remove();
     continueEl = null;
   }
@@ -656,6 +669,7 @@ export function createQuestionCards({
     continueEl = null;
     if (!card) return;
     card.classList.add("resolved");
+    onSettled(CONTINUE_KEY);
     card.querySelectorAll("button, input").forEach((el) => { el.disabled = true; });
     const note = doc.createElement("div");
     note.className = "question-result";

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

@@ -0,0 +1,283 @@
+// The stage's docked card and its fold (stage_view.js wires it): a card that
+// waits for the user (stage_cards.js PENDING but the step limit, or ASKS)
+// opens the running turn in the history (stage_opened.js) and docks alone
+// in the stage; chi's own question or approval after a reply gets that
+// reply as its lead-in bubble. A waiting card has no toggle of its own (the
+// stage's fold is the one); and the fold itself: the user's choice, a ref's
+// reveal, and the docked card's own fold.
+import { handOffOrder, stageCollapsed } from "./stage_model.js";
+import { readStored, writeStored } from "./storage.js";
+import { ASKS, PENDING, waitsInStage } from "./stage_cards.js";
+import { cardIn, waitingKey, waitingKind } from "./stage_waiting.js";
+
+const COLLAPSE_KEY = "chi_stage_collapsed";
+// The cards that get a lead-in bubble when their step wrote text: chi's own
+// question and its own approval (question_cards.js data-kind; not a
+// delegate's relayed one, a hook's question or the step limit).
+const LEAD_IN_CARD = '.bubble.question[data-kind="question"]:not([data-relay]), .bubble.question[data-kind="approval"]:not([data-relay])';
+// The step limit: its card goes under its ended turn (stage_view.js place),
+// it never docks.
+const STEP_LIMIT = '.bubble.continue, .bubble.question.step-limit, .bubble.question[data-kind="continue"]';
+
+function readCollapsed() {
+  return readStored(COLLAPSE_KEY) === "1";
+}
+
+// +stage+, +extras+, +tail+, +scroller+ and +fold+: the stage's root, its
+// two card slots, its scroller and its fold button. +view+: the turn block
+// (turn_block.js); +opener+: the opened turn (stage_opened.js); +frame()+:
+// the stage's frame (stage_frame.js, made after this). +isOpened()+ /
+// +setOpened(v)+: whether the turn is opened in the history; +isEnded()+:
+// the turn has ended; +promptEl()+: the turn's prompt bubble; +setCloud(open)+:
+// the cloud; +scheduleRefresh()+; +pendingCard()+: a card waits in the card
+// slots; +waiting+: the stage's waiting cards as data (stage_waiting.js),
+// which say the asking form's card and hold its fold.
+export function createStageAsking({
+  stage, extras, tail, scroller, fold, view, opener, frame, isOpened, setOpened, isEnded, promptEl, setCloud,
+  scheduleRefresh, pendingCard, waiting,
+}) {
+  // The user's own fold (chi_stage_collapsed), in memory: written on a
+  // hand toggle, never read back from storage to decide (another tab's
+  // write doesn't apply live).
+  let choice = readCollapsed();
+  // A ref's "show in turn" opened a collapsed stage (not kept).
+  let revealed = false;
+  // The docked card's fold is +waiting+'s (fold, trackFold): the waiting
+  // card the user folded, by its key. For that card only, never saved: the
+  // next one arrives open, and when the docked card goes the stage is as the
+  // choice and +revealed+ say. One more card waiting since the fold (an
+  // approval, a relayed or hook question) drops it, so the stage opens on it.
+
+  // ── the docked card ──────────────────────────────────────────────────────
+
+  // The step that asked +what+ ({kind, tool}: the card's data-kind and, for
+  // an approval, the tool it approves): live, the step whose call runs
+  // (turn_model.js askingText). In a replay (a reload, a resync) the asking
+  // call may have completed before its question_requested comes
+  // (TurnAccumulator.join_events: a question's always, an approval's once
+  // it is answered), so the last step when one of its calls is the one
+  // that asks (ask_user_question; the approved tool: a parallel call after
+  // it doesn't hide it) and no card of this page took its reply yet. Live or replayed, a step whose reply a card already
+  // took (+asked+) gives no other card its reply: a second approval or a
+  // question after it in the same step has no lead-in. null: none.
+  function askingGen({ kind = "question", tool = null } = {}) {
+    const { turn } = view.current();
+    const gen = turn && !turn.ended ? turn.gens[turn.gens.length - 1] : null;
+    if (!gen?.text || asked.has(gen)) return null;
+    if (view.askingText()) return gen;
+    const call = kind === "question" ? "ask_user_question" : kind === "approval" ? tool : null;
+    return call && gen.tools.some((row) => row.tool === call) ? gen : null;
+  }
+  // What a card asks, for askingGen.
+  const asksOf = (el) => ({ kind: el?.dataset?.kind || "question", tool: el?.dataset?.tool || null });
+  // The steps whose reply a question card took (place: question_cards.js
+  // reads askingText right before), for askingGen's replay rule.
+  const asked = new WeakSet();
+  function askedFor(el) {
+    const gen = askingGen(asksOf(el));
+    if (gen) asked.add(gen);
+  }
+
+  // The reply that asked +pq+ (a pending question: its kind, an approval's
+  // tool), "" for none.
+  function askedText(pq = null) {
+    return String(askingGen({ kind: pq?.kind || "question", tool: pq?.approval?.tool || null })?.text || "").trim();
+  }
+
+  // +el+ docks: a card that waits for the user (a pending question,
+  // approval, relayed or hook card; an asking card), not the step limit,
+  // placed while the turn runs.
+  function docks(el) {
+    if (isEnded() || !el?.matches) return false;
+    if (el.matches(PENDING)) return !el.matches(STEP_LIMIT);
+    return !!el.querySelector(ASKS);
+  }
+
+  // The lead-in for +el+: the reply that asked it when +el+ is chi's own
+  // question or approval (LEAD_IN_CARD) and its step wrote text; "" otherwise.
+  function leadInText(el) {
+    if (!el.matches?.(LEAD_IN_CARD) || !el.matches(PENDING)) return "";
+    return String(askingGen(asksOf(el))?.text || "").trim();
+  }
+
+  // The turn opens in the history (once): the prompt, the block (closed;
+  // its steps in order from now on) and the rows the extras hold, in the
+  // hand-off's order. What waits stays. +follow+: a reader who was at the
+  // history's end follows it (a docked card with no lead-in; a lead-in's
+  // read follows instead).
+  function openTurn({ follow = false } = {}) {
+    if (isOpened()) return;
+    const { blockEl } = view.current();
+    view.inOrder?.();
+    setCloud(false);
+    if (blockEl) {
+      blockEl.open = false;
+      // A lone step's block keeps its chrome there (index.html): its summary
+      // is the way to the step's text, which no lead-in shows.
+      blockEl.dataset.openedTurn = "";
+    }
+    const rows = [...extras.children].filter((el) => !waitsInStage(el));
+    setOpened(true);
+    opener.open(handOffOrder({ prompt: promptEl(), block: blockEl, extras: rows }), { follow });
+  }
+
+  // The waiting cards as data, checked against the slots (stage_waiting.js
+  // reconcile, its second feed: it only settles): a card gone from the
+  // extras and the tail, or no longer waiting, settles, also one answered
+  // outside question_cards.js's hook.
+  function reconcileWaiting() {
+    waiting.reconcile((key) => !!waitingKind(cardIn(extras, key) || cardIn(tail, key)));
+  }
+
+  // An opened turn's cards that stopped waiting go into the history: one
+  // with a lead-in under it (also after the turn's end, so a card
+  // cancelled by Stop turn sits there), another one at the history's end
+  // while the turn runs.
+  function settleCards() {
+    if (!isOpened()) return;
+    for (const el of [...extras.children]) {
+      if (waitsInStage(el)) continue;
+      // Out of the stage it waits behind nothing (stage_view.js drawDocked).
+      el.classList.remove("ts-behind");
+      const key = waitingKey(el);
+      if (opener.has(key)) opener.settle(key, el);
+      else if (!isEnded()) opener.add(el);
+    }
+  }
+
+  // The docked card the stage shows, by its key (the asking form: one at a
+  // time, stage_waiting.js shown); null: none docked.
+  function askingKey() {
+    return waiting.shown();
+  }
+  function askingCard() {
+    return cardIn(extras, askingKey());
+  }
+
+  // The folded row's text for the docked +card+ (stage_model.js
+  // foldedRowText): a question's text, an approval's summary and its
+  // command's first line, a plugin card's title; "" for none.
+  function foldedText(card) {
+    if (!card) return "";
+    if (card.matches(".plugin-card")) return card.querySelector(".card-title")?.textContent || "";
+    if (card.dataset.kind !== "approval") return card.querySelector(".question-text")?.textContent || "";
+    // The summary's own words, not its "↑ its reason" link.
+    const summary = card.querySelector(":scope > summary");
+    const head = [...(summary?.childNodes || [])].filter((n) => n.nodeType === 3).map((n) => n.textContent).join("").trim();
+    const what = (card.querySelector(".approval-what") || card.querySelector(".approval-tool"))?.textContent || "";
+    return [head, what.trim().split("\n")[0].trim()].filter(Boolean).join(" ");
+  }
+
+  // The stage's card element for +key+ (its extras or its tail), null: none.
+  function cardOf(key) {
+    return cardIn(extras, key) || cardIn(tail, key);
+  }
+
+  // A card that waits in the stage has no toggle of its own: the stage's
+  // fold is the one (a closed card left an empty box). A click on its
+  // summary (Enter and Space on one arrive as a click) doesn't toggle it,
+  // and question_cards.js reads the refusal (defaultPrevented): no
+  // data-toggled. Not stopped: the page's outside-click closers still see
+  // it. A button or link in the summary ("↑ its reason") works as ever.
+  // The test is "waits now", at the click: an answered card toggles.
+  stage.addEventListener("click", (e) => {
+    const summary = e.target.closest?.("summary");
+    if (!summary || summary.contains(e.target.closest("button, a"))) return;
+    if (summary.parentElement?.matches(PENDING)) e.preventDefault();
+  }, true);
+  // Its summary isn't a control meanwhile: out of the tab order (the CSS
+  // drops its mark and pointer). Not aria-disabled: that would disable the
+  // buttons in it too. +inert+: the ones marked, given back once their card
+  // stops waiting or leaves.
+  const inert = new Set();
+  function markOwnToggles() {
+    const waits = new Set();
+    for (const key of waiting.blocking()) {
+      const summary = cardOf(key)?.querySelector(":scope > summary");
+      if (summary) waits.add(summary);
+    }
+    for (const summary of inert) {
+      if (waits.has(summary)) continue;
+      summary.removeAttribute("tabindex");
+      inert.delete(summary);
+    }
+    for (const summary of waits) {
+      if (inert.has(summary)) continue;
+      summary.tabIndex = -1;
+      inert.add(summary);
+    }
+  }
+
+  // ── the fold ─────────────────────────────────────────────────────────────
+
+  // Whether the stage is collapsed now (stage_model.js stageCollapsed).
+  // The registry is checked against the slots first: a card answered since
+  // the last refresh no longer holds the fold.
+  function isCollapsed() {
+    reconcileWaiting();
+    return stageCollapsed({ choice, revealed, asking: askingKey(), askingFold: waiting.folded() });
+  }
+
+  // Its fold is that card's only; the form's start opens a stage saved as
+  // collapsed and its end gives the choice back, in this task (the card's
+  // focus lands right after the start: question_cards.js focusWhenIdle).
+  // Another card that comes to wait meanwhile opens it: nothing waits
+  // unseen behind the folded question.
+  // A card answered meanwhile lowers the mark, so the next one opens it too.
+  function trackFold() {
+    waiting.trackFold(askingKey());
+  }
+
+  // The fold as isCollapsed says, only when it changed (+force+: always):
+  // idempotent, and no refresh of its own (refresh calls it).
+  function drawCollapsed({ force = false } = {}) {
+    const collapsed = isCollapsed();
+    if (!force && fold.textContent && stage.classList.contains("collapsed") === collapsed) return;
+    stage.classList.toggle("collapsed", collapsed);
+    scroller.hidden = collapsed;
+    fold.textContent = collapsed ? "▴" : "▾";
+    fold.setAttribute("aria-label", collapsed ? "Expand the running turn" : "Collapse the running turn to its status");
+    fold.setAttribute("aria-expanded", String(!collapsed));
+    frame().fitCap();
+  }
+
+  function applyCollapsed() {
+    drawCollapsed({ force: true });
+    scheduleRefresh();
+  }
+
+  // A hand toggle (the fold button, a tap on the folded row). In the
+  // asking form it folds that question only and writes nothing; else it is
+  // the user's choice, kept.
+  function setCollapsed(value) {
+    reconcileWaiting();
+    const asking = askingKey();
+    if (asking) {
+      waiting.fold(value ? asking : null);
+    } else {
+      choice = value;
+      revealed = false;
+      writeStored(COLLAPSE_KEY, value ? "1" : "0");
+    }
+    applyCollapsed();
+    // Opened on a waiting card: it shows as it does on arrival.
+    const front = !value && pendingCard() ? cardOf(waiting.front()) : null;
+    if (front) frame().afterGrowth(() => frame().reveal(front.parentElement));
+  }
+
+  return {
+    askingGen, asksOf, askedFor, askedText, docks, leadInText, openTurn, reconcileWaiting, settleCards, askingCard, cardOf, foldedText, markOwnToggles,
+    isCollapsed, trackFold, drawCollapsed, applyCollapsed, setCollapsed,
+    // A ref's "show in turn" opens a collapsed stage for this turn only.
+    reveal() {
+      revealed = true;
+      applyCollapsed();
+    },
+    // The stage cleared: a reveal ends with it.
+    unreveal() {
+      if (!revealed) return;
+      revealed = false;
+      applyCollapsed();
+    },
+  };
+}

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

@@ -4,8 +4,8 @@
 // until the next step), and never above the session panel. The frame: held
 // and grow-only while the stage holds a turn (stage_model.js frameTarget),
 // its growth eased; it lets go in two places only (forgetContent): the
-// asking form (a turn opened in the history: the card alone, stage_view.js
-// place) and the next step after an answered card (releaseHeldWait). The stage's state comes
+// asking form (a card docked, its turn opened in the history: the card
+// alone, stage_view.js place) and the next step after an answered card (releaseHeldWait). The stage's state comes
 // in as getters (+isHolding+, +isCollapsed+, +isCloudOpen+, +isRoomCap+);
 // what the stage changes of the frame's goes through resetHeld and
 // forgetContent. +waitingCard+: the card blocking the turn, or null.
@@ -35,7 +35,7 @@ export function reducedMotion() {
 
 // +observed+: the elements whose size changes refit the frame (the stage's
 // slots, in the order they are observed).
-export function createStageFrame({ stage, scroller, status, cloud, queuedSlot, holdEl, asking, extras, dockEl, centerEl, observed, isHolding, isCollapsed, isCloudOpen, isRoomCap = () => false, waitingCard = () => null }) {
+export function createStageFrame({ stage, scroller, status, cloud, queuedSlot, holdEl, extras, dockEl, centerEl, observed, isHolding, isCollapsed, isCloudOpen, isRoomCap = () => false, waitingCard = () => null }) {
   // The frame (fitFrame): the height held while the turn runs and the
   // tallest content seen.
   let held = null;
@@ -65,16 +65,13 @@ export function createStageFrame({ stage, scroller, status, cloud, queuedSlot, h
   // would push the stage's top out) ──────────────────────────────────────
 
   // Where the stage's scroll goes so +slot+ (the scroller's child) shows:
-  // its end in sight, and the asking text's top too when it and the slot
-  // (a waiting card) fit together (the reply reads from its start, the card
-  // still in sight). A waiting card in +slot+ taller than the
-  // view reads from its top, never from its options: the question and what
-  // it approves are what the answer is about; the options are a scroll away.
+  // its end in sight. A waiting card in +slot+ taller than the view reads
+  // from its top, never from its options: the question and what it
+  // approves are what the answer is about; the options are a scroll away.
   // null: nothing to show.
   function revealTop(slot) {
     if (stage.hidden || slot.hidden) return null;
     let top = Math.max(scroller.scrollTop, slot.offsetTop + slot.offsetHeight - scroller.clientHeight);
-    if (!asking.hidden && asking.offsetTop < top && slot.offsetTop + slot.offsetHeight - asking.offsetTop <= scroller.clientHeight) top = asking.offsetTop;
     const card = waitingCard();
     if (card && slot.contains(card)) top = Math.min(top, Math.max(0, card.offsetTop - CARD_TOP_GAP));
     return top;
@@ -138,8 +135,7 @@ export function createStageFrame({ stage, scroller, status, cloud, queuedSlot, h
     stage.style.setProperty("--stage-max", `${cap}px`);
     fitFrame();
     // A smaller cap (a phone's keyboard came up) keeps a waiting card in
-    // sight: the asking text above it would push it out. A larger one
-    // leaves the reader's scroll alone.
+    // sight. A larger one leaves the reader's scroll alone.
     if (keep) requestAnimationFrame(keepCardInSight);
   }
   // The whole dock, not only its composer card: the info bar under it

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

@@ -6,7 +6,6 @@ import { toolName } from "./activity.js";
 import { splitSentences } from "./sentences.js";
 import { steerSender } from "./format.js";
 import { hookNoticeLabel } from "./turn_events.js";
-import { askingRefs, askingText } from "./turn_model.js";
 import { plainLine } from "./plain_line.js";
 import { turnPieces } from "./turn_pieces.js";
 import { waitsInStage } from "./stage_cards.js";
@@ -120,6 +119,18 @@ export function stepSlotText({ step, ended, chipHidden }) {
   return !ended ? `step ${step}` : chipHidden ? stepsText(step) : "";
 }
 
+// Whether the stage is collapsed to its status row. In the asking form
+// (+asking+: the key of the card that waits there, stage_waiting.js; null:
+// none) only when the user folded that card (+askingFold+: the folded key,
+// null: none), so a
+// question always arrives open and a new one never matches an old fold;
+// else the user's +choice+ (chi_stage_collapsed, as set by hand), unless a
+// ref's "show in turn" opened it for this turn (+revealed+).
+export function stageCollapsed({ choice, revealed, asking = null, askingFold = null }) {
+  if (asking) return askingFold === asking;
+  return revealed ? false : !!choice;
+}
+
 // The collapsed stage's mini tool in the status row: the running call's
 // name and title, its full command as the hover; "" for both otherwise.
 export function miniToolText({ collapsed, tool }) {
@@ -129,6 +140,28 @@ export function miniToolText({ collapsed, tool }) {
   };
 }
 
+// The collapsed stage's status row text: with the asking form folded, what
+// the docked card asks (+question+: a question's text, an approval's
+// summary and command, a plugin card's title; its first line, the whole as
+// the hover, in the UI font: +question+ true), else miniToolText's running
+// call: folded, or with +running+ (check-in docked while nothing blocks:
+// the row says what chi runs now).
+export function foldedRowText({ collapsed, question = "", tool = null, running = false }) {
+  const whole = String(question || "").trim();
+  if (collapsed && whole) return { text: whole.split("\n")[0].trim(), title: whole, question: true };
+  return { ...miniToolText({ collapsed: collapsed || running, tool }), question: false };
+}
+
+// The status row's word while check-in's card is docked and nothing blocks
+// (+asksFront+): "writing" while the live step's text streams (the page
+// can't tell narration before a tool call from the answer), else the
+// phase's own word (+phase+: liveSlots's; it stays "waiting for you").
+// +streaming+: the phase the step would have with no card (liveSlots with
+// pending false).
+export function phaseLabel({ phase, asksFront = false, streaming = "" }) {
+  return asksFront && (streaming === "writing" || streaming === "writing the answer") ? "writing" : phase;
+}
+
 // While the first step has no thinking and no tool rows the turn is plain:
 // its text streams in the stage's answer slot, as the turn block's
 // chrome-less block streams like a bubble.
@@ -156,16 +189,11 @@ const NO_ANSWER = "no answer";
 //            ended (nothing happens now);
 //   trail    the last three finished calls, newest last (a file's title
 //            without its dir; command as for tool);
-//   ticks    one per call: {kind, status, step (the gen's index)};
-//   asking   the whole text of the reply whose call a card blocks
-//            (turn_model.js askingText), "" when none is blocked;
-//   askingRefs a plugin's refs on it (turn_model.js askingRefs), or null.
-// +pending+: a card waits for the user; +blocked+: a card that blocks the
-// turn (a question, an approval; not an action card) waits; +ended+: the
-// turn's end kind;
+//   ticks    one per call: {kind, status, step (the gen's index)}.
+// +pending+: a card waits for the user; +ended+: the turn's end kind;
 // +emptyAnswer+: a completed turn ended with no answer
 // (turn_summary.empty_answer), so it reads "no answer", not "answered".
-export function liveSlots(turn, { narration = "", thinking = "", pending = false, blocked = false, ended = null, emptyAnswer = false } = {}) {
+export function liveSlots(turn, { narration = "", thinking = "", pending = false, ended = null, emptyAnswer = false } = {}) {
   const gens = turn?.gens || [];
   const rows = gens.flatMap((gen, step) => gen.tools.map((row) => ({ row, step })));
   const running = [...rows].reverse().find(({ row }) => row.status === "running")?.row || null;
@@ -193,8 +221,6 @@ export function liveSlots(turn, { narration = "", thinking = "", pending = false
     tool: running ? withTask(withCommand({ name: toolName(running), title: rowTitle(running), kind: toolKind(running.tool) }, running), running) : null,
     trail,
     ticks: rows.map(({ row, step }) => ({ kind: toolKind(row.tool), status: row.status, step })),
-    asking: blocked && !ended ? askingText(turn) : "",
-    askingRefs: blocked && !ended ? askingRefs(turn) : null,
   };
 }
 

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

@@ -1,9 +1,10 @@
-// A running turn opened in the history (stage_view.js). When the model's
-// own question blocks the turn after a reply, the reply that asked it (the
-// reason) becomes a conversation bubble at the history's end, and from then
-// to the turn's end the turn's prompt, its steps block and the rows that
-// arrive are the history's; only what waits for the user (the card), the
-// live slots and the answer stay in the stage. This module draws the reason
+// A running turn opened in the history (stage_view.js). When a card waits
+// for the user (stage_asking.js docks), the turn's prompt, its steps block
+// and the rows that arrive are the history's from then to the turn's end;
+// only what waits for the user (the card), the live slots and the answer
+// stay in the stage. chi's own question or approval after a reply gets that
+// reply (the reason, its lead-in) as a conversation bubble at the history's
+// end. This module draws the reason
 // bubble and moves things into the history (history_end.js), following a
 // reader who was at the history's end (a reader scrolled up is never
 // moved). At the hand-off the reasons go (end): each answered card's own
@@ -32,7 +33,8 @@ export function createOpenedTurn({
   historyEl, atHistoryEnd, renderMarkdown = () => null, linkRefs = () => {}, reduce = () => false,
   afterSettle = (fn) => requestAnimationFrame(() => requestAnimationFrame(fn)),
 }) {
-  // card → its reason bubble, for the turn in the stage.
+  // card key (stage_waiting.js waitingKey) → its reason bubble, for the turn
+  // in the stage.
   const reasons = new Map();
   // The asking steps whose text a reason shows (data-said: their text is
   // hidden in the block meanwhile, index.html), to clear at the end.
@@ -141,18 +143,20 @@ export function createOpenedTurn({
   }
 
   return {
-    // The turn's pieces so far (handOffOrder's order) into the history; the
-    // reason's read (ask) does the follow.
-    open: (pieces) => add(pieces, { follow: false }),
+    // The turn's pieces so far (handOffOrder's order) into the history; a
+    // reason's read (ask) does the follow, else +follow+ (a reader who was at
+    // the end before the move).
+    open: (pieces, { follow = false } = {}) => add(pieces, { follow }),
     // A row of the opened turn: to the history's end.
     add: (el) => add([el]),
     // +card+ blocks the turn: its reason's bubble at the history's end, in
     // the card's task; a reader at the end reads it from its first line.
     // +follow+: the reader was at the end before the turn opened.
-    ask({ card, text, refs = null, step = 0, turnId = null, questionId = null, follow = atHistoryEnd() }) {
+    // +key+: the card's key, the bubble's for has and settle.
+    ask({ card, key, text, refs = null, step = 0, turnId = null, questionId = null, follow = atHistoryEnd() }) {
       const bubble = reasonBubble({ text, refs, step, turnId, questionId });
       moveToHistoryEnd(historyEl, [bubble]);
-      reasons.set(card, bubble);
+      reasons.set(key, bubble);
       // The step's own text is the reason: not twice (and raw while the
       // step runs). data-said, not a class: lit owns the step's class.
       const stepEl = askingStep();
@@ -174,12 +178,18 @@ export function createOpenedTurn({
       }
       return bubble;
     },
-    has: (card) => reasons.has(card),
-    // +card+ no longer waits (answered, cancelled): it goes right under its
-    // reason, which stops saying "asking you"; another card of the turn to
-    // the history's end. A reader at the end follows.
-    settle(card) {
-      const bubble = reasons.get(card);
+    has: (key) => key != null && reasons.has(key),
+    // +card+ drawn again with +key+ (the same question, a new element): its
+    // way back to the reason it already has.
+    relink(key, card) {
+      const bubble = reasons.get(key);
+      if (bubble && !card.querySelector(":scope > summary > .question-reason-link")) reasonLink(card, bubble);
+    },
+    // +card+ (its +key+) no longer waits (answered, cancelled): it goes right
+    // under its reason, which stops saying "asking you"; another card of the
+    // turn to the history's end. A reader at the end follows.
+    settle(key, card) {
+      const bubble = reasons.get(key);
       if (!bubble?.isConnected) return add([card]);
       const follow = atHistoryEnd();
       bubble.classList.remove("pending");