samagotchi 0.61.0 → 0.63.0

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

@@ -22,14 +22,17 @@
 // removed at the end: the answer bubble takes its place.
 import { html, nothing, render } from "./vendor/lit-html.js";
 import { setAnswerRefs } from "./answer_refs.js";
+import { bindRowRefs } from "./refs.js";
 import { leavesBlock } from "./card.js";
-import { copySourceAttr } from "./copy.js";
-import { escapeHtml, failedTurnText, messageBodyHtml, noteHtml, normalize, sourceLabel, steerRowHtml } from "./format.js";
-import { thumbsHtml } from "./images.js";
+import { failedTurnText, normalize, sourceLabel } from "./format.js";
+import { thumbsTemplate } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { hookNoticeLabel } from "./turn_events.js";
-import { commandBubbleHtml, emptyAnswerHtml, htmlElement, shellCommandMessage, toolRowHtml, toolRowInnerHtml, userBubbleHtml } from "./turn_html.js";
-import { cancelLineHtml, formatDuration, turnGroups, turnTimingText } from "./timing.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 { createSentenceFeed } from "./sentences.js";
 import { createTicker } from "./thinking_ticker.js";
 import * as model from "./turn_model.js";
@@ -109,41 +112,68 @@ function nodesOf(template) {
   return frag;
 }
 
-// +markup+ (any HTML string) as nodes.
-function rawNodes(markup) {
-  const t = document.createElement("template");
-  t.innerHTML = markup;
-  return t.content;
+// ---- A finished block's outline ----
+
+// A finished block as its outline (turn_model.js outlineRuns of +gens+, its
+// steps in order): open, each narrated step a one-line row as before, each
+// run of steps that said nothing hidden behind one "N steps" fold that
+// shows them. The live turn's end and a reload call it alike. The folds sit
+// between the steps, not in them (`:scope > .gen` still counts steps), each
+// before its run's first step and before that step's lit marker comment, so
+// a later render of the step leaves it alone. False when there is nothing
+// to outline (no step said anything): the block stays as it is.
+export function outlineBlock(blockEl, gens) {
+  const runs = model.outlineRuns(gens);
+  const steps = blockEl ? [...blockEl.querySelectorAll(":scope > .gen")] : [];
+  if (!runs.length || steps.length !== gens.length) return false;
+  blockEl.classList.add("outline");
+  // A folded step → its fold's opener: a ref's "show in turn" (refs.js
+  // showInTurn dispatches ref:reveal on the row before it scrolls) unfolds
+  // the run its row is in, or the row stays hidden.
+  const unfold = new Map();
+  for (const { fold } of runs) {
+    if (!fold) continue;
+    const folded = fold.map((i) => steps[i]);
+    folded.forEach((el) => el.classList.add("folded"));
+    const marker = document.createElement("div");
+    marker.className = "outline-fold";
+    marker.setAttribute("role", "button");
+    marker.tabIndex = 0;
+    marker.setAttribute("aria-expanded", "false");
+    marker.textContent = `${fold.length} step${fold.length === 1 ? "" : "s"}`;
+    const toggle = () => {
+      const open = marker.classList.toggle("open");
+      marker.setAttribute("aria-expanded", String(open));
+      folded.forEach((el) => el.classList.toggle("unfolded", open));
+    };
+    folded.forEach((el) => unfold.set(el, () => { if (!marker.classList.contains("open")) toggle(); }));
+    marker.addEventListener("click", toggle);
+    marker.addEventListener("keydown", (e) => {
+      if (e.key !== "Enter" && e.key !== " ") return;
+      e.preventDefault();
+      toggle();
+    });
+    const first = folded[0];
+    const anchor = first.previousSibling?.nodeType === 8 ? first.previousSibling : first;
+    anchor.before(marker);
+  }
+  blockEl.addEventListener("ref:reveal", (e) => {
+    const step = e.target.closest?.(".gen.folded");
+    if (step?.parentElement === blockEl) unfold.get(step)?.();
+  });
+  blockEl.open = true;
+  return true;
 }
 
-// ---- The live view ----
-
-// The parts of a drawn tool row a user may have changed (the command's
-// raw toggle, an opened diff) or that never change once there (the
-// thumbs): a redraw keeps them as they are.
-const KEPT_PARTS = ["activity-command", "activity-diff", "activity-read", "thumbs"];
-
-const childWith = (el, cls) => [...el.children].find((c) => c.classList.contains(cls));
-
-// A live tool row drawn again from its activity row (status, title,
-// output): the reloaded row's markup (toolRowInnerHtml), the kept parts
-// and the stop-task button carried over. +html+ is that markup.
-function redrawRow(el, markup) {
-  const fresh = htmlElement(`<div>${markup}</div>`);
-  for (const cls of KEPT_PARTS) {
-    const old = childWith(el, cls);
-    const drawn = childWith(fresh, cls);
-    if (old && drawn) drawn.replaceWith(old);
-  }
-  const stop = childWith(el, "task-stop");
-  el.replaceChildren(...fresh.childNodes);
-  if (stop) rowAnchor(el).after(stop);
+// Reloaded tool rows (turn_html.js toolRowTemplate) as nodes, each row's
+// plugin refs bound to its title (refs.js bindRowRefs).
+function rowNodes(rows, thumbs) {
+  const nodes = nodesOf(rows.map((r) => toolRowTemplate(r, { thumbs })));
+  [...nodes.children].forEach((el, i) => bindRowRefs(el, rows[i]));
+  return nodes;
 }
 
-// Where a row's stop-task button goes: after its title (else its tool).
-function rowAnchor(el) {
-  return childWith(el, "activity-params") || childWith(el, "activity-tool");
-}
+// ---- The live view ----
 
 // 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);
@@ -423,10 +453,11 @@ export function createTurnView({
     onChange();
   }
 
-  // A tool row is the reloaded row's markup (turn_html.js toolRowHtml),
-  // drawn again when an event changed it.
-  const rowHtml = new WeakMap();
-  const rowThumbs = (images) => thumbsHtml(sessionId(), images);
+  // 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);
+  // A row element → its stop-task button (syncTaskStop).
+  const rowStops = new WeakMap();
 
   // A row, notice or card into the step's activity; a step that wrote no
   // narration before it drops the "…".
@@ -442,39 +473,48 @@ export function createTurnView({
     apply(r);
     const entry = genEls.get(r.gen);
     let el = entry.rows.get(r.row.key);
-    const inner = toolRowInnerHtml(r.row, { thumbs: rowThumbs });
     if (!el) {
-      el = htmlElement(toolRowHtml(r.row, { thumbs: rowThumbs }));
-      rowHtml.set(el, inner);
+      el = document.createElement("div");
+      el.className = "activity-row";
+      el.dataset.key = r.row.key;
       entry.rows.set(r.row.key, el);
+      drawRow(el, r.row);
       addItem(entry, el);
     } else {
       if (!r.gen.text) entry.placeholder = false;
-      if (rowHtml.get(el) !== inner) redrawRow(el, inner);
-      rowHtml.set(el, inner);
+      drawRow(el, r.row);
       // A late result in a closed step: its label and failed mark.
       draw(entry);
     }
-    syncTaskStop(el, r.row);
     updateBlockSummary();
     onChange();
   }
 
-  // The stop-task button after a running task_wait's params; gone once the
-  // row completes.
+  // The row rendered again (lit writes only what changed: a toggled raw
+  // command, an opened diff or read and the thumbs stay), its stop-task
+  // button in its slot, its plugin refs bound to its title (refs.js).
+  function drawRow(el, row) {
+    render(toolRowInnerTemplate(row, { thumbs: rowThumbs, stop: syncTaskStop(el, row) }), el);
+    bindRowRefs(el, row);
+  }
+
+  // The stop-task button of a running task_wait's row (after its title),
+  // nothing once the row completes.
   function syncTaskStop(el, row) {
     const taskId = taskStop?.target(row);
-    const btn = el.querySelector(":scope > .task-stop");
+    let btn = rowStops.get(el);
     if (!taskId) {
-      btn?.remove();
-      return;
+      rowStops.delete(el);
+      return nothing;
     }
     if (btn) {
       btn.disabled = taskStop.busy(taskId);
-      return;
+      return btn;
     }
     const command = () => taskCommand(turn?.gens, taskId);
-    rowAnchor(el).after(taskStopButton(taskStop, taskId, { command }));
+    btn = taskStopButton(taskStop, taskId, { command });
+    rowStops.set(el, btn);
+    return btn;
   }
 
   // A hook's line (hook_notice) as a row of the current step, above the row
@@ -494,7 +534,7 @@ export function createTurnView({
   // that ends first puts it in its last step). False with no running turn.
   function steer(data) {
     if (!turn || turn.ended) return false;
-    pendingSteers.push(htmlElement(steerRowHtml(data)));
+    pendingSteers.push(elementOf(steerRowTemplate(data)));
     return true;
   }
 
@@ -603,7 +643,11 @@ export function createTurnView({
     if (blockEl) {
       updateBlockSummary();
       blockEl.classList.add("done");
-      if (!blockToggled) blockEl.open = false;
+      // 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();
+      const outlined = outlineBlock(blockEl, model.blockGens(turn));
+      if (!blockToggled) blockEl.open = outlined;
       for (const el of blockEl.querySelectorAll(".plugin-card")) {
         if (leavesBlock({ warn: el.classList.contains("warn"), kind })) kept.push(el);
       }
@@ -615,6 +659,20 @@ 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.
+  function chronological() {
+    if (!blockEl || !turn) return;
+    for (const gen of turn.gens) {
+      const entry = genEls.get(gen);
+      if (entry?.el.parentNode !== blockEl) continue;
+      const nodes = stepNodes(entry);
+      const fold = nodes[0].previousSibling;
+      if (fold?.classList?.contains("outline-fold")) nodes.unshift(fold);
+      blockEl.append(...nodes);
+    }
+  }
+
   function reset() {
     hold.finish();
     turn = null;
@@ -712,17 +770,14 @@ export function createTurnView({
     // block, a step's elements by index, and the steps back in
     // chronological order after newestFirst.
     current() { return { turn, blockEl }; },
+    // The running turn's asking reply (turn_model.js askingText): what a
+    // question or approval card keeps once answered.
+    askingText: () => model.askingText(turn),
     step(i) {
       const entry = turn && genEls.get(turn.gens[i]);
       return entry ? { el: entry.el, summary: entry.el.querySelector(":scope > summary"), thinkingWrap: thinkingWrap(entry) } : null;
     },
-    chronological() {
-      if (!blockEl || !turn) return;
-      for (const gen of turn.gens) {
-        const entry = genEls.get(gen);
-        if (entry?.el.parentNode === blockEl) blockEl.append(...stepNodes(entry));
-      }
-    },
+    chronological,
   };
 }
 
@@ -737,29 +792,23 @@ function defaultPlaceAnswer(appendToHistory) {
 
 // ---- A reload ----
 
+// The text of a reloaded block's step +iteration+ (1-based, as the snapshot's
+// cards count), "" when it has none: a reloaded question card's asking
+// reply.
+export function stepText(block, iteration) {
+  const step = block?.querySelectorAll(":scope > .gen")[Number(iteration) - 1];
+  return step?.querySelector(":scope > .gen-text")?.textContent || "";
+}
+
 // A re-rendered failed turn's line (a .bubble.cancel, as live's
 // addEndBubble), in turn_failed's words (failedTurnText) from what the turn
 // record kept of it (SessionMetrics' failure: summary, message,
-// error_class, kept_steps); "" for any other record, or a failed one saved
-// before records kept that.
-function failedLineHtml(record) {
+// error_class, kept_steps); nothing for any other record, or a failed one
+// saved before records kept that.
+function failedLineTemplate(record) {
   const failure = record?.status === "failed" ? record.failure : null;
-  if (!failure || typeof failure !== "object") return "";
-  return `<div class="bubble cancel">${escapeHtml(failedTurnText(failure))}</div>`;
-}
-
-// Parts (HTML strings and templates, in order) as one fragment.
-function fragmentOf(parts) {
-  const out = document.createDocumentFragment();
-  let markup = "";
-  for (const part of parts) {
-    if (typeof part === "string") { markup += part; continue; }
-    if (markup) out.append(rawNodes(markup));
-    markup = "";
-    out.append(nodesOf(part));
-  }
-  if (markup) out.append(rawNodes(markup));
-  return out;
+  if (!failure || typeof failure !== "object") return nothing;
+  return html`<div class="bubble cancel">${failedTurnText(failure)}</div>`;
 }
 
 // A reloaded history in the turn view (renderHistory's object path), as
@@ -768,51 +817,51 @@ function fragmentOf(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.
+// +thumbs(images)+ draws a prompt's or a tool row's image thumbs (a
+// template, images.js thumbsTemplate).
 export function turnHistoryNodes(items, timing, { thumbs }) {
-  const timingHtml = (group) => {
+  const timingTemplate = (group) => {
     const record = group.record;
     // Numbered by its place in the turn records, as live (a failed turn
     // whose prompt went back still counts).
     const at = (timing?.turnRecords || []).indexOf(record);
     return record && formatDuration(record.duration_ms)
-      ? `<div class="turn-timing">${escapeHtml(turnTimingText(at >= 0 ? at + 1 : group.turnIndex + 1, record.duration_ms, { canceled: record.status === "canceled" }))}</div>`
-      : "";
+      ? html`<div class="turn-timing">${turnTimingText(at >= 0 ? at + 1 : group.turnIndex + 1, record.duration_ms, { canceled: record.status === "canceled" })}</div>`
+      : nothing;
   };
-  // The timing line after the bubble, not in it: where the live view
-  // leaves it at the turn's end. +at+: the message's index, for its refs
+  // An answer's bubble; +at+, the message's index, is for its refs
   // (data-answer-at, gone before the nodes are returned).
-  const answerHtml = (at, timing) => {
-    const m = items[at];
-    const { body, renderedMarkdown } = messageBodyHtml(m);
-    return `<div class="bubble output${renderedMarkdown ? " markdown" : ""}" data-answer-at="${at}"${copySourceAttr(m, renderedMarkdown)}>${body}</div>${timing}`;
-  };
+  const answerBubble = (at, cls = "") => answerBubbleTemplate(items[at], { cls, at });
+  // The timing line after the bubble, not in it: where the live view
+  // leaves it at the turn's end.
+  const answerTemplate = (at, timing) => html`${answerBubble(at)}${timing}`;
   // A user's line, labelled when chi brought it in (a delegate report). A
   // `!cmd`'s saved message (the worker's "!(<command>)\n<output>") renders
   // as its command bubble, as live does — not as a user bubble.
-  const userHtml = (m, opts = {}) => {
+  const userTemplate = (m, opts = {}) => {
     const shell = shellCommandMessage(m?.content);
-    if (shell) return commandBubbleHtml(shell);
-    return userBubbleHtml(m, { label: sourceLabel(m?.source), thumbs: thumbs(m.images), ...opts });
+    if (shell) return commandBubbleTemplate(shell);
+    return userBubbleTemplate(m, { label: sourceLabel(m?.source), thumbs: thumbs(m.images), ...opts });
   };
   // The first text after a delegate report merged mid-turn, unless it is
   // the turn's answer (shown anyway).
-  const reportReplyHtml = (i, group) => {
-    if (items[i]?.source !== "delegate_report") return "";
+  const reportReplyTemplate = (i, group) => {
+    if (items[i]?.source !== "delegate_report") return nothing;
     const j = items.findIndex((m, k) => k > i && m?.role === "assistant" && String(m.content ?? "").trim());
-    if (j < 0 || j === group.answer || items.slice(i + 1, j).some((m) => m?.role === "user" && !m.merged)) return "";
-    const { body, renderedMarkdown } = messageBodyHtml(items[j]);
-    return `<div class="bubble output report-reply${renderedMarkdown ? " markdown" : ""}" data-answer-at="${j}"${copySourceAttr(items[j], renderedMarkdown)}>${body}</div>`;
+    if (j < 0 || j === group.answer || items.slice(i + 1, j).some((m) => m?.role === "user" && !m.merged)) return nothing;
+    return answerBubble(j, " report-reply");
   };
-  const steerHtml = (i, bubble) => steerRowHtml({ source: items[i].source, text: items[i].content }, { bubble });
+  const steerTemplate = (i, bubble) => steerRowTemplate({ source: items[i].source, text: items[i].content }, { bubble });
   const parts = [];
+  // Each block's steps, in order: its outline once the nodes exist.
+  const outlines = [];
   for (const group of turnGroups(items, timing)) {
-    if (group.kind === "note") { parts.push(`<div class="bubble note">${noteHtml(items[group.i])}</div>`); continue; }
-    if (group.kind === "steer") { parts.push(steerHtml(group.i, true)); continue; }
-    if (group.kind === "answer") { parts.push(answerHtml(group.answer, "")); continue; }
+    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; }
     const prompt = items[group.user];
     // A context wake turn starts with its note.
-    parts.push(prompt.role === "note" ? `<div class="bubble note">${noteHtml(prompt)}</div>` : userHtml(prompt));
+    parts.push(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 ?? ""));
@@ -826,36 +875,38 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
       const gens = group.steps.map((step) => ({ text: step.i === null ? "" : String(items[step.i].content ?? ""), thinking: step.thinking || "", tools: step.tools }));
       const steps = gens.map((gen, k) => stepTemplate(gen, {
         // The steers the step answered first, where the live rows went.
-        steers: (group.steps[k].steers || []).map((i) => rawNodes(steerHtml(i, false))),
-        items: gen.tools.length ? [rawNodes(gen.tools.map((r) => toolRowHtml(r, { thumbs })).join(""))] : [],
+        steers: (group.steps[k].steers || []).map((i) => steerTemplate(i, false)),
+        items: gen.tools.length ? [rowNodes(gen.tools, thumbs)] : [],
       }));
       parts.push(html`<details class="turn-work done"><summary>${model.blockSummary({ gens, ended: true })}</summary>${steps}</details>`);
+      outlines.push(gens);
     }
     // 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) => steerHtml(i, true)).join(""));
+    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
     // small model tells its user about a report before its next tool call,
     // and that step's text would stay folded in the block.
     parts.push((group.merged || []).map((i) =>
-      userHtml(items[i], { state: "steered", step: items[i].step }) +
-      reportReplyHtml(i, group)).join(""));
+      html`${userTemplate(items[i], { state: "steered", step: items[i].step })}${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(`${emptyAnswerHtml(items[group.emptyAnswer])}${timingHtml(group)}`);
+    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(timingHtml(group));
-    else parts.push(answerHtml(group.answer, timingHtml(group)));
+    else if (group.answer === null) parts.push(timingTemplate(group));
+    else parts.push(answerTemplate(group.answer, timingTemplate(group)));
     // 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(cancelLineHtml(group.record, escapeHtml));
-    parts.push(failedLineHtml(group.record));
+    parts.push(cancelLineTemplate(group.record));
+    parts.push(failedLineTemplate(group.record));
   }
-  const out = fragmentOf(parts);
+  const out = nodesOf(parts);
+  // A finished turn's block as the live end leaves it: its outline, open.
+  [...out.children].filter((el) => el.matches(".turn-work")).forEach((block, i) => outlineBlock(block, outlines[i] || []));
   // Each answer bubble knows its message's refs (answer_refs.js; the
   // page pairs them after the render), the index stays out of the DOM.
   for (const bubble of out.querySelectorAll("[data-answer-at]")) {

data/lib/samagotchi/web/public/vendor/directive.js

@@ -0,0 +1,8 @@
+// lit-html 3.3.3 (npm tarball lit-html-3.3.3.tgz, directive.js: the minified production
+// build, unmodified but for this line and the dropped sourceMappingURL). BSD-3-Clause.
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const t={ATTRIBUTE:1,CHILD:2,PROPERTY:3,BOOLEAN_ATTRIBUTE:4,EVENT:5,ELEMENT:6},e=t=>(...e)=>({_$litDirective$:t,values:e});class i{constructor(t){}get _$AU(){return this._$AM._$AU}_$AT(t,e,i){this._$Ct=t,this._$AM=e,this._$Ci=i}_$AS(t,e){return this.update(t,e)}update(t,e){return this.render(...e)}}export{i as Directive,t as PartType,e as directive};

data/lib/samagotchi/web/public/vendor/directives/unsafe-html.js

@@ -0,0 +1,8 @@
+// lit-html 3.3.3 (npm tarball lit-html-3.3.3.tgz, directives/unsafe-html.js: the minified
+// production build, unmodified but for this line and the dropped sourceMappingURL). BSD-3-Clause.
+import{nothing as t,noChange as i}from"../lit-html.js";import{directive as r,Directive as s,PartType as n}from"../directive.js";
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */class e extends s{constructor(i){if(super(i),this.it=t,i.type!==n.CHILD)throw Error(this.constructor.directiveName+"() can only be used in child bindings")}render(r){if(r===t||null==r)return this._t=void 0,this.it=r;if(r===i)return r;if("string"!=typeof r)throw Error(this.constructor.directiveName+"() called with a non-string value");if(r===this.it)return this._t;this.it=r;const s=[r];return s.raw=s,this._t={_$litType$:this.constructor.resultType,strings:s,values:[]}}}e.directiveName="unsafeHTML",e.resultType=1;const o=r(e);export{e as UnsafeHTMLDirective,o as unsafeHTML};

data/lib/samagotchi/worker.rb

@@ -468,10 +468,10 @@ module Samagotchi
     # would keep the hub's "needs you" badge on for good. Dropped and saved
     # before the Engine and the Bridge exist (no question lock, no events).
     def drop_dead_question
-      return unless @session.pending_question
+      id = @session.drop_dead_question
+      return unless id
 
-      Log.info(:worker, "dead_question_dropped", id: @session.pending_question[:id])
-      @session.pending_question = nil
+      Log.info(:worker, "dead_question_dropped", id: id)
       save_or_log(:dead_question) { @session.save(state_dir: @state_dir) }
     end
 
@@ -1077,8 +1077,9 @@ module Samagotchi
         # A wake turn starts with its first line, whoever sent it.
         lines[0] = lines[0].with(mark: mark) if mark && lines.any?
         # The turn so far, with what this boundary merges (its input files
-        # are gone now), on disk at most every TurnCheckpoint::INTERVAL.
-        @checkpoint.boundary(@engine.live_conversation, merging: lines, turn_id: @turn_id)
+        # are gone now), on disk at most every TurnCheckpoint::INTERVAL;
+        # its metrics so far with it, so a turn a KILL ends keeps them.
+        @engine.checkpoint_metrics if @checkpoint.boundary(@engine.live_conversation, merging: lines, turn_id: @turn_id)
         lines
       end
     end
@@ -1102,22 +1103,36 @@ module Samagotchi
     end
 
     # Check again with the event log held, which the Bridge holds while it
-    # queues a POST /turn, then close the Bridge so no client can queue one
-    # after the check, and stop the idle jobs (reminder callback, recap).
+    # queues a POST /turn, then close the Bridge's intake so no client can
+    # queue one after the check, and stop the idle jobs (reminder callback,
+    # recap). The Bridge stops after the log is let go (#stop_bridge_after).
     # A client connecting from here on finds no worker: `chi --attach` fails
     # and the web stream answers 503 (a small window, left as is).
     # @return [Boolean] false when something came in since #due?
     def leave_idle
-      @engine.synchronize_events do
-        next false unless @idle_exit.due?
-
-        @bridge&.stop
-        @engine.stop_idle
-        log_idle_exit
-        true
+      stop_bridge_after do
+        @engine.synchronize_events do
+          next false unless @idle_exit.due?
+
+          @bridge&.close_intake
+          @engine.stop_idle
+          log_idle_exit
+          true
+        end
       end
     end
 
+    # The Bridge stops once the block (which closed its intake with the
+    # event log held) answers true, outside the log: Bridge#stop waits for
+    # the requests it is answering, and one waiting on the log would hold
+    # it for the whole grace before being killed.
+    # @return [Boolean] what the block answered
+    def stop_bridge_after
+      leaving = yield
+      @bridge&.stop if leaving
+      leaving
+    end
+
     # Bridge POST /exit, on a Bridge thread with the event log held.
     # +delete+: the session is deleted after (/exit --delete), so no recap.
     # +restart+: a new worker takes over (on the newest chi installed), so
@@ -1139,29 +1154,31 @@ module Samagotchi
     end
 
     # #leave_idle for an exit a client asked for: check again with the event
-    # log held (a prompt may have come in since), then close the Bridge and
-    # stop the idle jobs. Other clients' streams no longer hold: the asker's
+    # log held (a prompt may have come in since), then close the Bridge's
+    # intake and stop the idle jobs (the Bridge stops after the log). Other clients' streams no longer hold: the asker's
     # may not have closed yet, and a UI joining now finds the worker gone
     # (:stream_closed), the window #leave_idle has too.
     # @return [Boolean] false when something came in since the request
     def leave_on_request
-      @engine.synchronize_events do
-        hold = if @exit_restart
-                 @idle_exit.hold_for_restart
-               else
-                 @idle_exit.hold_for_request(requester: @exit_requested_by, streams: false)
-               end
-        if hold
-          @exit_requested = nil
-          @exit_restart = false
-          Log.info(:worker, "exit_held", reason: hold)
-          next false
-        end
+      stop_bridge_after do
+        @engine.synchronize_events do
+          hold = if @exit_restart
+                   @idle_exit.hold_for_restart
+                 else
+                   @idle_exit.hold_for_request(requester: @exit_requested_by, streams: false)
+                 end
+          if hold
+            @exit_requested = nil
+            @exit_restart = false
+            Log.info(:worker, "exit_held", reason: hold)
+            next false
+          end
 
-        @bridge&.stop
-        @engine.stop_idle
-        Log.info(:worker, @exit_restart ? "restart_requested" : "exit_requested", by: @exit_requested_by || "a client")
-        true
+          @bridge&.close_intake
+          @engine.stop_idle
+          Log.info(:worker, @exit_restart ? "restart_requested" : "exit_requested", by: @exit_requested_by || "a client")
+          true
+        end
       end
     end
 

data/lib/samagotchi/worker_inbound.rb

@@ -106,9 +106,10 @@ module Samagotchi
     # run): auto-attached context alone doesn't make a session worth
     # keeping. Saved, then the subscriptions written (a crash between the
     # two re-delivers; the note ids dedupe).
-    # +wake+: the session is idle with nothing queued, so an update whose
-    # source asked to wake may start a turn (#context_wake_for): its note
-    # goes in as the turn's first message.
+    # +wake+: the session is idle with nothing queued, so a delivery with a
+    # wake note (an update whose source asked to wake, or a session push
+    # source's first text that asked) may start a turn (#context_wake_for):
+    # its wake note goes in as the turn's first message.
     # @return [ContextWake, nil] the wake turn to run now
     # @raise [SystemCallError, IOError] the caller logs it (context_failed)
     def absorb_context(before_turn: false, wake: false)
@@ -134,7 +135,7 @@ module Samagotchi
       waking && ContextWake.new(delivery: waking, turn_id: turn_id)
     end
 
-    # A failed wake turn kept nothing but its note: the update goes back to
+    # A failed wake turn kept nothing but its note: the note goes back to
     # a plain note (no turn start, the background wording), so a reload
     # draws no empty turn for it.
     def unmark_wake(context_wake)
@@ -201,9 +202,11 @@ module Samagotchi
 
     private
 
-    # +unless_stopped+: not when the session was stopped meanwhile: the stop
-    # (chi stop, from another process) saved its status, and this save
-    # would write the worker's over it.
+    # +unless_stopped+: skipped when the session was stopped meanwhile (chi
+    # sessions stop, from another process: its marker file,
+    # Session.mark_stopped, which a load reads over the saved status). The
+    # save couldn't hide the stop; it is left out so the file stays as the
+    # stop found it, the worker's idle status unwritten.
     def save(at, unless_stopped: false)
       self.class.save_or_log(at) do
         @session.save(state_dir: @state_dir) unless unless_stopped && @stopped.call
@@ -222,13 +225,13 @@ module Samagotchi
       true
     end
 
-    # The update in +batch+ that may start a wake turn now: its source
-    # asked (wake: true), context.wake is on, the wake budget is open
-    # (WorkerWakes#context_open?: no continue offer, not paused, under
-    # session.max_wakes, past the start grace) and the source hasn't woken
-    # the session in the last CONTEXT_WAKE_WINDOW. The others stay plain
-    # notes. Within the start grace a change is a note: it came while the
-    # session was away.
+    # The delivery in +batch+ that may start a wake turn now: it has a wake
+    # note (ContextAbsorber decides: its source asked, wake: true),
+    # context.wake is on, the wake budget is open (WorkerWakes#context_open?:
+    # no continue offer, not paused, under session.max_wakes, past the start
+    # grace) and the source hasn't woken the session in the last
+    # CONTEXT_WAKE_WINDOW. The others stay plain notes. Within the start
+    # grace a change is a note: it came while the session was away.
     def context_wake_for(batch, now: Time.now)
       candidates = batch.deliveries.select(&:wake_note)
       return nil if candidates.empty? || !context_wakes_on?