samagotchi 0.2.0

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

@@ -0,0 +1,185 @@
+export function formatDuration(milliseconds) {
+  const ms = Number(milliseconds);
+  if (!Number.isFinite(ms) || ms < 0) return "";
+
+  if (ms < 500) return `${Math.round(ms)}ms`;
+
+  const seconds = ms / 1000;
+  if (seconds < 60) return `${seconds < 10 ? seconds.toFixed(1) : Math.round(seconds)}s`;
+
+  const totalSeconds = Math.round(seconds);
+  const minutes = Math.floor(totalSeconds / 60);
+  return `${minutes}m ${String(totalSeconds % 60).padStart(2, "0")}s`;
+}
+
+// A turn's timing line: "turn 3 · 4.1s", or "turn 3 running · 1.0s" while
+// it runs. The number is the turn's place in the session's turn records,
+// the one a reloaded history shows.
+export function turnTimingText(number, durationMs, { running = false, canceled = false } = {}) {
+  const turn = Number.isInteger(number) && number > 0 ? `turn ${number}` : "turn";
+  return `${turn}${running ? " running" : ""} · ${formatDuration(durationMs)}${canceled ? " · canceled" : ""}`;
+}
+
+// The line a canceled turn ends with: "✕ canceled (user)", live from
+// turn_canceled's reason and after a re-render from the turn record's
+// cancellation_reason (records saved before it existed: no reason).
+export function cancelLineText(reason) {
+  return "\u2715 canceled" + (reason ? ` (${reason})` : "");
+}
+
+// A re-rendered turn's cancel line (a .bubble.cancel), or "" when the turn
+// record is not a canceled one.
+export function cancelLineHtml(record, escape) {
+  if (record?.status !== "canceled") return "";
+  return `<div class="bubble cancel">${escape(cancelLineText(record.cancellation_reason))}</div>`;
+}
+
+export function elapsedSince(startedAt, now = Date.now()) {
+  const started = Date.parse(startedAt);
+  const current = Number(now);
+  if (!Number.isFinite(started) || !Number.isFinite(current)) return null;
+  return Math.max(0, current - started);
+}
+
+export function normalizeTiming(data = {}) {
+  return {
+    startedAt: typeof data.started_at === "string" ? data.started_at : null,
+    sessionDurationMs: finiteOrNull(data.session_duration_ms),
+    turnRecords: Array.isArray(data.turn_records) ? data.turn_records.filter(validRecord) : [],
+    toolRecords: Array.isArray(data.tool_records) ? data.tool_records.filter(validRecord) : [],
+    activeTurn: validRecord(data.active_turn) ? data.active_turn : null,
+  };
+}
+
+export function turnRecordAt(timing, index) {
+  const records = timing?.turnRecords;
+  return Array.isArray(records) ? records[index] || null : null;
+}
+
+// For each history item, the turn index its timing shows under, or null. A
+// turn with tool calls holds several assistant messages; only the last one
+// before the next user message carries the turn's timing. A turn with none
+// (canceled before an answer, or still running: no record yet) has it on
+// its user message.
+export function timedTurnIndexes(items) {
+  const result = items.map(() => null);
+  let turnIndex = -1;
+  let carrier = null;
+  items.forEach((item, i) => {
+    if (item?.role === "user") {
+      if (carrier !== null) result[carrier] = turnIndex;
+      turnIndex += 1;
+      carrier = i;
+    } else if (item?.role === "assistant") {
+      carrier = i;
+    }
+  });
+  if (carrier !== null) result[carrier] = turnIndex;
+  return result;
+}
+
+// The history as turns, for the turn view's reload: notes on their own, and
+// per prompt a turn with its record, its steps (one per iteration: the
+// turn's tool records grouped by iteration, and the assistant messages but
+// the last, in order; a text-less iteration leaves no message, so a text
+// can sit one step early: inspection, not truth) and its answer (the last
+// assistant message). Assistant messages before any prompt are answers on
+// their own. The turn index counts prompts, as timedTurnIndexes does.
+export function turnGroups(items, timing) {
+  const groups = [];
+  let turnIndex = -1;
+  let turn = null;
+  items.forEach((item, i) => {
+    if (item?.role === "note") {
+      groups.push({ kind: "note", i });
+    } else if (item?.role === "user") {
+      turnIndex += 1;
+      turn = { kind: "turn", turnIndex, user: i, texts: [] };
+      groups.push(turn);
+    } else if (item?.role === "assistant") {
+      if (turn) turn.texts.push(i);
+      else groups.push({ kind: "answer", answer: i });
+    }
+  });
+  return groups.map((g) => {
+    if (g.kind !== "turn") return g;
+    const record = turnRecordAt(timing, g.turnIndex);
+    const tools = record ? (timing?.toolRecords || []).filter((r) => r.turn_id === record.id) : [];
+    const stepsOnly = canceledSteps(g, record, tools);
+    if (g.texts.some((i) => items[i].parts)) return partsTurn(g, items, record, tools, stepsOnly);
+    const maxIteration = tools.reduce((m, r) => Math.max(m, Number(r.iteration) || 0), 0);
+    const stepTexts = stepsOnly ? g.texts : g.texts.slice(0, -1);
+    const steps = [];
+    for (let k = 0; k < Math.max(stepTexts.length, maxIteration); k += 1) {
+      const iteration = k + 1;
+      steps.push({ i: stepTexts[k] ?? null, iteration, tools: recordRows(tools, iteration) });
+    }
+    const answer = g.texts.length && !stepsOnly ? g.texts[g.texts.length - 1] : null;
+    return { kind: "turn", turnIndex: g.turnIndex, user: g.user, answer, record, steps };
+  });
+}
+
+// A canceled turn that ran more than one step or any call has no answer:
+// its partial text stays in the block, as it does live (turn_view.js
+// turnEnded promotes only a completed turn or a lone step with no tools).
+function canceledSteps(g, record, tools) {
+  return record?.status === "canceled" && (g.texts.length > 1 || tools.length > 0);
+}
+
+function recordRows(tools, iteration) {
+  return tools.filter((r) => Number(r.iteration) === iteration).map((r) => ({
+    key: `${iteration}:${r.call_index ?? 0}`, tool: r.tool, status: r.status, duration_ms: r.duration_ms,
+  }));
+}
+
+// A turn whose saved messages carry their parts (the server's ?parts=1):
+// every assistant message is one generation, so the k-th is iteration k
+// and its calls pair with that iteration's records by position. The last
+// message is the answer when it has text and made no call (and the turn
+// is no canceled multi-step one); its thinking stays behind as a step, as
+// it does live.
+function partsTurn(g, items, record, tools, stepsOnly = false) {
+  const last = g.texts[g.texts.length - 1];
+  const lastItem = items[last];
+  const answer = !stepsOnly && String(lastItem.content ?? "") !== "" && !lastItem.parts?.tools?.length ? last : null;
+  const steps = g.texts.map((i, k) => {
+    const iteration = k + 1;
+    const parts = items[i].parts || {};
+    const records = recordRows(tools, iteration);
+    const rows = Array.isArray(parts.tools)
+      ? parts.tools.map((call, j) => {
+        const r = records.find((row) => row.key === `${iteration}:${j + 1}`);
+        return { key: `${iteration}:${j + 1}`, status: r?.status || "ok", duration_ms: r?.duration_ms, ...call };
+      })
+      : records;
+    const thinking = String(parts.thinking || "");
+    if (i === answer) return thinking ? { i: null, iteration, thinking, tools: [] } : null;
+    return { i, iteration, thinking, tools: rows };
+  }).filter(Boolean);
+  // Records past the saved messages (a generation that saved nothing).
+  const maxIteration = tools.reduce((m, r) => Math.max(m, Number(r.iteration) || 0), 0);
+  for (let iteration = g.texts.length + 1; iteration <= maxIteration; iteration += 1) {
+    steps.push({ i: null, iteration, thinking: "", tools: recordRows(tools, iteration) });
+  }
+  return { kind: "turn", turnIndex: g.turnIndex, user: g.user, answer, record, steps };
+}
+
+// Append +el+ to the history, above +timingEl+ while it is a running turn's
+// live timing line, so that line stays under the turn's activity, thinking
+// and answer.
+export function appendAboveLiveTiming(parent, el, timingEl) {
+  if (timingEl && timingEl.parentNode === parent && timingEl.classList.contains("live")) {
+    parent.insertBefore(el, timingEl);
+  } else {
+    parent.appendChild(el);
+  }
+}
+
+function validRecord(record) {
+  return record && typeof record === "object";
+}
+
+function finiteOrNull(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : null;
+}

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

@@ -0,0 +1,209 @@
+// Pure helpers for the Bridge's turn events (no DOM), so app.js's handlers
+// stay thin and the logic runs under `node --test`.
+
+// The answer text of a :turn_completed event. `turn_summary.output` is the
+// contract; `result` is the KernelLoop result, which reaches the wire as its
+// string form (older servers, other clients' fixtures).
+export function turnOutput(data) {
+  if (!data) return "";
+  const summary = data.turn_summary?.output;
+  const result = typeof data.result === "string" ? data.result : data.result?.output;
+  const out = [summary, result, data.content, data.output].find((v) => typeof v === "string" && v.trim());
+  return out ? out.trim() : "";
+}
+
+// The end line for a turn whose worker went away mid-turn (the footer's
+// stop, a crash): no turn_canceled comes, so the page ends the turn itself.
+// null when no turn was running.
+export function workerGoneText({ turnRunning, stopped = false }) {
+  if (!turnRunning) return null;
+  return `\u2715 canceled (${stopped ? "session stopped" : "worker exited"})`;
+}
+
+// This tab's id in the events (`origin.client_id`, turn_enqueued's
+// client_id): new per page load, like the TUI's `tui:<pid>`.
+export function newClientId() {
+  return `web:${Math.random().toString(36).slice(2, 10).padEnd(8, "0")}`;
+}
+
+export function isOwn(clientId, myId) {
+  return clientId != null && clientId === myId;
+}
+
+const CLIENT_LABELS = Object.freeze({ tui: "tui", web: "web", system: "reminder", delegate: "delegate" });
+
+// The label on another client's prompt, by its client_id prefix.
+export function clientLabel(clientId) {
+  if (!clientId) return null;
+  return CLIENT_LABELS[String(clientId).split(":", 1)[0]] || "user";
+}
+
+// The note for reminders a turn got (a reminder turn has no prompt).
+export function reminderText(event) {
+  const names = (event?.reminders || []).map((r) => (r && typeof r === "object" ? r.name : r)).filter(Boolean);
+  return names.length ? `reminder: ${names.join(", ")}` : "reminder";
+}
+
+// Who a hook's notice is from: the bundle's name for a bundle hook
+// ("known_names.rb (bundle known-names)"), else "hook".
+export function hookNoticeLabel(hook) {
+  const m = /\(bundle (.+)\)$/.exec(String(hook || ""));
+  return m ? m[1] : "hook";
+}
+
+// A composer line for the worker's command route rather than a prompt.
+export function isCommandLine(text) {
+  return /^[/!]/.test(String(text || "").trim());
+}
+
+// The continue card's answers, as the terminal's continue prompt reads them.
+export function continueLine(choice, reason = "") {
+  const why = String(reason || "").trim();
+  if (choice === "no" && why) return `/continue no, ${why}`;
+  return `/continue ${choice}`;
+}
+
+// How to show a command_ran: `label` names another client (null for this
+// tab's own), `resync` says the conversation changed (!rollback, !cmd, a
+// continue answered no) and must be read again. An anytime command's
+// (`anytime`, D8) bubble is drawn at its command_queued, before the cards
+// it shows; its command_ran fills that bubble in (`commandId`).
+export function commandView(event, myId) {
+  const own = isOwn(event.client_id, myId);
+  return {
+    label: own ? null : clientLabel(event.client_id),
+    line: event.line || "",
+    text: event.output || "",
+    busy: event.status === "busy",
+    failed: event.status === "error",
+    resync: (event.changed || []).includes("messages"),
+    modelName: event.model_name || null,
+    anytime: event.anytime === true,
+    commandId: event.command_id || null,
+  };
+}
+
+// What a prompt_restored (the worker rolled a failed turn back and handed its
+// prompt back) does in this tab: `refill` is the text for an empty composer,
+// only for a prompt this page sent (`sentIds`, its acks' enqueued_ids), so a
+// replay after a reload never refills stale text; `own`/`label` mark the
+// failed bubble shown again after the resync.
+export function restoreAction(event, { myId, sentIds, composerEmpty }) {
+  const origin = event?.origin || {};
+  const own = isOwn(origin.client_id, myId);
+  const sent = own && !!origin.enqueued_id && sentIds.has(origin.enqueued_id);
+  // The images go back as chips with the text.
+  return withImages({
+    refill: sent && composerEmpty ? event.prompt : null,
+    own,
+    label: own ? null : clientLabel(origin.client_id),
+  }, sent && composerEmpty ? event.images : null);
+}
+
+// What an event does to the prompt bubbles, as a list of ops for app.js:
+//   add   — a bubble for a prompt this tab hasn't shown (state queued /
+//           started / steered, labelled by its sender)
+//   tag   — this tab's own local echo gets its enqueued_id
+//   start — the bubble's turn started (drops the "queued" badge)
+//   steer — the bubble was merged into the running turn
+// `known(enqueuedId)` says whether a bubble carries that id already;
+// `unmatchedMerge` whether the last input_merged had an origin with no bubble.
+export function promptOps(event, { myId, known, unmatchedMerge = false }) {
+  if (!event) return [];
+  switch (event.type) {
+    case "turn_enqueued": {
+      const id = event.enqueued_id;
+      if (isOwn(event.client_id, myId)) return [withImages({ op: "tag", enqueuedId: id, prompt: event.prompt }, event.images)];
+      if (id && known(id)) return [];
+      return [withImages({ op: "add", enqueuedId: id, prompt: event.prompt, state: "queued", label: clientLabel(event.client_id) }, event.images)];
+    }
+    case "turn_started": {
+      if (event.continue || !event.prompt) return [];
+      const origin = event.origin || {};
+      const id = origin.enqueued_id || null;
+      if ((id && known(id)) || isOwn(origin.client_id, myId)) {
+        // Images too: a resync can have wiped the own echo, and the page then
+        // draws the bubble from this.
+        return [withImages({ op: "start", enqueuedId: id, prompt: event.prompt }, event.images)];
+      }
+      return [withImages({ op: "add", enqueuedId: id, prompt: event.prompt, state: "started", label: clientLabel(origin.client_id) }, event.images)];
+    }
+    case "input_merged":
+      return (event.origins || []).filter((o) => o && o.enqueued_id).map((o) =>
+        known(o.enqueued_id) ? { op: "steer", enqueuedId: o.enqueued_id } : { op: "steer", enqueuedId: o.enqueued_id, unmatched: true },
+      );
+    case "pending_input_merged":
+      if (!unmatchedMerge || !event.content) return [];
+      return [{ op: "add", enqueuedId: null, prompt: event.content, state: "steered", label: null }];
+    default:
+      return [];
+  }
+}
+
+// A session view from the server (GET /api/sessions/:id on a live worker)
+// as the live events that would have drawn it: the turn in progress (its
+// parts in order), then the prompts queued behind it. app.js feeds these to
+// its stream handlers, so a join renders exactly like watching live.
+// `merged_input` is the one synthetic type: a prompt merged into the turn.
+export function snapshotEvents({ current_turn: turn = null, queued = [], started_at = undefined } = {}) {
+  const events = [];
+  if (turn) {
+    events.push(withImages({ type: "turn_started", prompt: turn.prompt, origin: turn.origin, continue: !!turn.continue, started_at }, turn.images));
+    let textIteration = null; // a text bubble is open for this iteration
+    const closeText = () => {
+      if (textIteration !== null) events.push({ type: "generation_completed" });
+      textIteration = null;
+    };
+    for (const part of turn.parts || []) {
+      switch (part.kind) {
+        // The chunks carry the part's iteration, so the turn view 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 });
+          break;
+        case "text":
+          if (textIteration !== null && textIteration !== part.iteration) closeText();
+          textIteration = part.iteration;
+          events.push({ type: "generation_chunk", text: part.text, thinking: "", iteration: part.iteration ?? null });
+          break;
+        case "tool": {
+          closeText();
+          const call = { iteration: part.iteration, call_index: part.call_index, tool: part.tool };
+          if (part.label) call.label = part.label;
+          events.push({ type: "tool_call_started", ...call, params: part.params });
+          if (part.status !== "running") {
+            events.push(withImages({
+              type: "tool_call_completed", ...call, output: part.output, output_truncated: !!part.output_truncated,
+              activity: { status: part.status, params: part.params },
+            }, part.images));
+          }
+          break;
+        }
+        case "input":
+          closeText();
+          events.push({ type: "merged_input", content: part.text, origins: part.origins || [] });
+          break;
+        case "reminder":
+          closeText();
+          events.push({ type: "reminder_injected", reminders: part.reminders || [] });
+          break;
+        case "hook_notice":
+          closeText();
+          events.push({ type: "hook_notice", hook: part.hook, text: part.text, level: part.level });
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  for (const entry of queued || []) {
+    events.push(withImages({ type: "turn_enqueued", enqueued_id: entry.enqueued_id, client_id: entry.client_id, prompt: entry.prompt }, entry.images));
+  }
+  return events;
+}
+
+// +object+ with `images` when there are any (the shapes stay as they were
+// for a turn without).
+function withImages(object, images) {
+  return images?.length ? { ...object, images } : object;
+}

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

@@ -0,0 +1,204 @@
+// The generations of one turn, as the turn view 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.
+//
+// Rules:
+// - turn_started opens the first gen (no iteration yet).
+// - generation_started(n) opens a new gen unless the current one is still
+//   empty (then it takes n).
+// - a chunk goes to the gen of its iteration (opening one when none has it);
+//   a chunk with no iteration goes to the current gen, unless that one is
+//   textDone or already has tool rows (an older server's replay), which
+//   opens a new gen.
+// - generation_completed marks the current gen textDone; its tool rows
+//   follow it (the kernel emits them after).
+// - tool events go to the gen of their iteration, else to the current gen,
+//   which takes the iteration when it had none.
+// - a hook's notice goes to the current gen (hook_notice has no
+//   iteration; a before_tool_call hook runs before the call's
+//   tool_call_started), none once the turn ended.
+// - the turn's end closes the current gen.
+import { addCompleted, addStarted, newActivity, toolName } from "./activity.js";
+import { tallyText } from "./tally.js";
+import { leadTrimmed } from "./format.js";
+
+const LABEL_MAX = 80;
+const LABEL_TOOLS = 3;
+
+export function newTurn() {
+  return { gens: [], ended: false, plainAnswer: false };
+}
+
+// The gen still open, or null.
+export function currentGen(turn) {
+  const last = turn.gens[turn.gens.length - 1];
+  return last && !last.closed ? last : null;
+}
+
+function isEmpty(gen) {
+  return !gen.thinking && !gen.text && gen.tools.length === 0;
+}
+
+function openGen(turn, iteration) {
+  const closed = closeCurrent(turn);
+  const gen = { iteration: iteration ?? null, thinking: "", text: "", activity: newActivity(), textDone: false, closed: false, notices: [] };
+  gen.tools = gen.activity.rows;
+  turn.gens.push(gen);
+  return { gen, opened: true, closed };
+}
+
+function closeCurrent(turn) {
+  const gen = currentGen(turn);
+  if (!gen) return null;
+  gen.thinking = gen.thinking.replace(/[ \t\r\n]+$/, "");
+  gen.text = gen.text.replace(/[ \t\r\n]+$/, "");
+  gen.closed = true;
+  return gen;
+}
+
+// The current gen, or the one that +iteration+ names (opening one when
+// needed). Returns { gen, opened, closed }.
+function genFor(turn, iteration) {
+  if (iteration != null) {
+    const named = [...turn.gens].reverse().find((g) => g.iteration === iteration);
+    if (named) return { gen: named, opened: false, closed: null };
+  }
+  const current = currentGen(turn);
+  if (current && iteration != null && current.iteration == null) {
+    current.iteration = iteration;
+    return { gen: current, opened: false, closed: null };
+  }
+  if (current && iteration != null && current.iteration !== iteration) return openGen(turn, iteration);
+  if (current) return { gen: current, opened: false, closed: null };
+  return openGen(turn, iteration);
+}
+
+export function turnStarted(turn) {
+  return openGen(turn, null);
+}
+
+export function generationStarted(turn, iteration = null) {
+  const current = currentGen(turn);
+  if (current && isEmpty(current)) {
+    current.iteration = iteration ?? current.iteration;
+    return { gen: current, opened: false, closed: null };
+  }
+  return openGen(turn, iteration);
+}
+
+export function chunk(turn, { text = "", thinking = "", iteration = null } = {}) {
+  let r;
+  if (iteration == null) {
+    const current = currentGen(turn);
+    r = current && (current.textDone || current.tools.length) ? openGen(turn, null) : genFor(turn, null);
+  } else {
+    r = genFor(turn, iteration);
+  }
+  const { gen } = r;
+  // Leading whitespace (the "\n" after <think>, or after a closed
+  // think/tool_call block) would render as an empty first line; trim it at
+  // the start of a gen's thinking and text only.
+  if (thinking) gen.thinking += leadTrimmed(gen.thinking, thinking);
+  if (text) gen.text += leadTrimmed(gen.text, text);
+  return r;
+}
+
+export function generationCompleted(turn) {
+  const gen = currentGen(turn);
+  if (gen) gen.textDone = true;
+  return gen ? { gen, opened: false, closed: null } : null;
+}
+
+function toolEvent(turn, event, add) {
+  const r = genFor(turn, event.iteration ?? null);
+  const row = add(r.gen.activity, event);
+  return { ...r, row };
+}
+
+export function toolStarted(turn, event) {
+  return toolEvent(turn, event, (model, e) => addStarted(model, e).row);
+}
+
+export function toolCompleted(turn, event) {
+  return toolEvent(turn, event, addCompleted);
+}
+
+// A hook's line to the user, in the current step; null with no running
+// turn (the page shows it as a bubble then). Not a tool row: the counts
+// and labels leave it out.
+export function notice(turn, { hook, text, level } = {}) {
+  const gen = turn && !turn.ended ? currentGen(turn) : null;
+  if (!gen) return null;
+  gen.notices.push({ hook, text, level });
+  return { gen };
+}
+
+// The turn is over (completed, canceled, failed, the worker gone).
+export function turnEnded(turn) {
+  const closed = closeCurrent(turn);
+  turn.ended = true;
+  turn.plainAnswer = turn.gens.length === 1 && !turn.gens[0].thinking && turn.gens[0].tools.length === 0;
+  return { gen: null, opened: false, closed };
+}
+
+// The turn's answer is +gen+'s text, moved out of the block (turn_view.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) {
+  if (gen) gen.answer = true;
+  return turn;
+}
+
+function isStep(gen) {
+  return !gen.answer || !!gen.thinking || gen.tools.length > 0;
+}
+
+// One stream event into the model; null for the types it ignores.
+export function applyEvent(turn, event) {
+  switch (event?.type) {
+    case "turn_started": return turnStarted(turn);
+    case "generation_started": return generationStarted(turn, event.iteration ?? null);
+    case "generation_chunk": return chunk(turn, { text: event.text, thinking: event.thinking, iteration: event.iteration ?? null });
+    case "generation_completed": return generationCompleted(turn);
+    case "tool_call_started": return toolStarted(turn, event);
+    case "tool_call_completed": return toolCompleted(turn, event);
+    case "turn_completed": case "turn_canceled": case "turn_failed": return turnEnded(turn);
+    default: return null;
+  }
+}
+
+function toolCallsText(n) {
+  return `${n} tool call${n === 1 ? "" : "s"}`;
+}
+
+// The collapsed row of a gen: its narration's first line, else the tools it
+// worked with, else "thinking"; then its call count.
+export function genLabel(gen) {
+  const line = String(gen.text || "").trim().split("\n")[0].trim();
+  const calls = gen.tools.length;
+  let head;
+  if (line) {
+    head = line.length > LABEL_MAX ? `${line.slice(0, LABEL_MAX).trimEnd()}…` : line;
+  } else if (calls) {
+    const names = [...new Set(gen.tools.map(toolName))];
+    head = `working with ${names.slice(0, LABEL_TOOLS).join(", ")}${names.length > LABEL_TOOLS ? ", …" : ""}`;
+  } else {
+    return "thinking";
+  }
+  return calls ? `${head} · ${toolCallsText(calls)}` : head;
+}
+
+// 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 } = {}) {
+  const rows = turn.gens.flatMap((g) => g.tools);
+  const steps = turn.gens.filter(isStep).length;
+  const fields = [`${steps} step${steps === 1 ? "" : "s"}`];
+  const tally = tallyText(rows, { last: false });
+  if (tally) fields.push(tally);
+  else if (rows.length) fields.push(toolCallsText(rows.length));
+  if (running) fields.unshift("working");
+  return fields.join(" · ");
+}