samagotchi 0.61.0 → 0.62.0

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

@@ -152,6 +152,20 @@ export function notice(turn, { hook, text, level } = {}) {
   return { gen };
 }
 
+// The whole text of the reply that asked the user (a question or an
+// approval blocks its call): the last gen's text, trimmed, while one of its
+// calls runs and the turn goes on; else "". Only that step's text: a hook's
+// question (asked before its call's row, or between steps) has no running
+// row there, so it gets none rather than another step's (or the answer's)
+// text. The stage shows it while the card waits; the card keeps it once
+// answered.
+export function askingText(turn) {
+  if (!turn || turn.ended) return "";
+  const gen = turn.gens[turn.gens.length - 1];
+  if (!gen?.text || !gen.tools.some((row) => row.status === "running")) return "";
+  return gen.text.trim();
+}
+
 // The turn is over (completed, canceled, failed, the worker gone).
 export function turnEnded(turn) {
   const closed = closeCurrent(turn);
@@ -215,6 +229,41 @@ export function genLabelParts(gen) {
   return { head: "thinking", calls: "", repeats: false };
 }
 
+// A step that said something (its text is not the turn's answer): a row of
+// its own in a finished block's outline.
+export function isNarrated(gen) {
+  return !gen.answer && !!String(gen.text || "").trim();
+}
+
+// A finished block's outline (+gens+: its steps in order, as the block holds
+// them): each narrated step a row, each run of the others between (tool-only,
+// thinking-only) one fold ({fold: [indices]}), so every mid-turn text's first
+// line reads without a click and the steps that said nothing take one line.
+// [] when no step said anything: the block stays closed, as before.
+// A last run of one thinking-only step stays a row (no "· 1 step" at the end).
+export function outlineRuns(gens) {
+  if (!gens.some(isNarrated)) return [];
+  const runs = [];
+  gens.forEach((gen, i) => {
+    if (isNarrated(gen)) return runs.push({ step: i });
+    const last = runs[runs.length - 1];
+    if (last?.fold) last.fold.push(i);
+    else runs.push({ fold: [i] });
+  });
+  // A turn doesn't end on a "1 step" fold for a lone thinking-only step
+  // (the answer's own thinking): it stays a row, its "thinking" label.
+  const last = runs[runs.length - 1];
+  const lone = last.fold?.length === 1 && gens[last.fold[0]];
+  if (lone && lone.tools.length === 0) runs[runs.length - 1] = { step: last.fold[0] };
+  return runs;
+}
+
+// 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).
+export function blockGens(turn) {
+  return turn.gens.filter((gen) => !(gen.answer && !gen.thinking && gen.tools.length === 0));
+}
+
 // The block's summary line: "working · 3 steps · 8 tool calls · execute ×7 · …"
 // while it runs, without the prefix after; the tally (tally.js) from 3 calls.
 export function blockSummary(turn, { running = false } = {}) {

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

@@ -22,6 +22,7 @@
 // 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";
@@ -116,6 +117,67 @@ function rawNodes(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;
+}
+
+// Reloaded tool rows (turn_html.js toolRowHtml) as nodes, each row's
+// plugin refs bound to its title (refs.js bindRowRefs).
+function rowNodes(rows, thumbs) {
+  const nodes = rawNodes(rows.map((r) => toolRowHtml(r, { thumbs })).join(""));
+  [...nodes.children].forEach((el, i) => bindRowRefs(el, rows[i]));
+  return nodes;
+}
+
 // ---- The live view ----
 
 // The parts of a drawn tool row a user may have changed (the command's
@@ -445,12 +507,16 @@ export function createTurnView({
     const inner = toolRowInnerHtml(r.row, { thumbs: rowThumbs });
     if (!el) {
       el = htmlElement(toolRowHtml(r.row, { thumbs: rowThumbs }));
+      bindRowRefs(el, r.row);
       rowHtml.set(el, inner);
       entry.rows.set(r.row.key, el);
       addItem(entry, el);
     } else {
       if (!r.gen.text) entry.placeholder = false;
-      if (rowHtml.get(el) !== inner) redrawRow(el, inner);
+      if (rowHtml.get(el) !== inner) {
+        redrawRow(el, inner);
+        bindRowRefs(el, r.row);
+      }
       rowHtml.set(el, inner);
       // A late result in a closed step: its label and failed mark.
       draw(entry);
@@ -603,7 +669,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 +685,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 +796,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,6 +818,14 @@ 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,
@@ -806,6 +895,8 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
   };
   const steerHtml = (i, bubble) => steerRowHtml({ 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; }
@@ -827,9 +918,10 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
       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(""))] : [],
+        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.
@@ -856,6 +948,8 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
     parts.push(failedLineHtml(group.record));
   }
   const out = fragmentOf(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/worker.rb

@@ -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

data/lib/samagotchi/worker_inbound.rb

@@ -201,9 +201,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.61.0
+  version: 0.62.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -416,6 +416,7 @@ files:
 - lib/samagotchi/reminder_queue.rb
 - lib/samagotchi/reminder_store.rb
 - lib/samagotchi/reply_wait.rb
+- lib/samagotchi/row_refs.rb
 - lib/samagotchi/sampling_settings.rb
 - lib/samagotchi/self_report.rb
 - lib/samagotchi/send_command.rb
@@ -557,6 +558,7 @@ files:
 - lib/samagotchi/web/public/index.html
 - lib/samagotchi/web/public/info_bar.js
 - lib/samagotchi/web/public/init_row.js
+- lib/samagotchi/web/public/keep_focus.js
 - lib/samagotchi/web/public/kept_commands.js
 - lib/samagotchi/web/public/level_chip.js
 - lib/samagotchi/web/public/lists_view.js