samagotchi 0.28.0 → 0.30.0

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

@@ -11,7 +11,7 @@
 // reload. Slots are patched in place, never rebuilt from HTML: a selection
 // and annotate survive. The rules are pure in stage_model.js.
 import { createTurnView } from "./turn_view.js";
-import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor } from "./stage_model.js";
+import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor, trailMark, trailTone } from "./stage_model.js";
 import { formatDuration } from "./timing.js";
 import { taskCommand, taskStopButton } from "./task_stop.js";
 
@@ -189,20 +189,26 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     stage.dataset.phase = slots.phase;
     mark.textContent = MARKS[slots.phase] || "";
     phaseEl.textContent = slots.phase;
-    stepEl.textContent = endKind ? `${slots.step} step${slots.step === 1 ? "" : "s"}` : `step ${slots.step}`;
+    const steps = `${slots.step} step${slots.step === 1 ? "" : "s"}`;
 
     drawHeadline(slots.headline);
-    drawNow(slots.tool, gen);
+    drawNow(slots.tool, slots.quiet);
     drawTrail(slots.trail);
     drawTicks(slots.ticks);
     const calls = slots.ticks.length;
-    const elapsed = endKind ? formatDuration(endedAt - startedAt) : "";
-    chipLabel.textContent = `${slots.step} step${slots.step === 1 ? "" : "s"} · ${calls} tool call${calls === 1 ? "" : "s"}${elapsed ? ` · ${elapsed}` : ""}`;
+    // An ended turn says each thing once: its steps in the chip (the label
+    // of what the cloud holds), its time in the status row's timing line
+    // (the one that moves into the history). The chip keeps the time when
+    // that line is elsewhere (a turn the stage didn't hold from its start).
+    const elapsed = endKind && !timingSlot.firstChild ? formatDuration(endedAt - startedAt) : "";
+    chipLabel.textContent = `${steps} · ${calls} tool call${calls === 1 ? "" : "s"}${elapsed ? ` · ${elapsed}` : ""}`;
     miniTool.textContent = collapsed && slots.tool ? `${slots.tool.name} ${slots.tool.title}` : "";
     miniTool.title = (collapsed && slots.tool?.command) || "";
 
     live.hidden = plain || !!endKind;
     cloud.hidden = !blockEl || blockEl.parentNode !== cloudBody;
+    // Running: the step it is on. Ended: the count, unless the chip says it.
+    stepEl.textContent = !endKind ? `step ${slots.step}` : cloud.hidden ? steps : "";
     promptSlot.hidden = !promptSlot.firstChild;
     extras.hidden = !extras.firstChild;
     answer.hidden = !answer.firstChild;
@@ -225,8 +231,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     headline.classList.add("fresh");
   }
 
-  function drawNow(tool, gen) {
-    const quiet = gen?.text && !gen.textDone ? "writing…" : "thinking…";
+  function drawNow(tool, quiet) {
     // A task_wait's stop button, as the row's (task_stop.js): in the key
     // with its in-flight state, so a redraw keeps a clicked one disabled.
     const stopId = tool?.taskId && taskStop?.target({ tool: "task_wait", status: "running", view: { task_id: tool.taskId } });
@@ -248,7 +253,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
         const command = () => taskCommand(view.current().turn?.gens, stopId);
         now.appendChild(taskStopButton(taskStop, stopId, { command, onChange: scheduleRefresh }));
       }
-    } else {
+    } else if (quiet) {
       const word = node("span", "ts-title quiet", now);
       word.textContent = quiet;
     }
@@ -262,9 +267,9 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     trail.replaceChildren();
     if (flashing) node("span", `ts-trail-item ${flashing.kind}`, trail).textContent = `${FLASH_MARKS[flashing.kind]} ${flashing.text}`;
     for (const item of items) {
-      const failed = item.status === "error";
-      const el = node("span", `ts-trail-item${failed ? " error" : ""}`, trail);
-      el.textContent = `${failed ? "✕" : "✓"} ${item.name} ${item.title}`.trim();
+      const tone = trailTone(item.status);
+      const el = node("span", `ts-trail-item${tone ? ` ${tone}` : ""}`, trail);
+      el.textContent = `${trailMark(item.status)} ${item.name} ${item.title}`.trim();
       if (item.command) el.title = item.command;
     }
     if (!flashing && !items.length) node("span", "ts-trail-item none", trail).textContent = "no tool calls yet";

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

@@ -19,17 +19,26 @@ export function stopTarget(row, features) {
   return row.view?.task_id || null;
 }
 
+// A task_wait row's title without its wait ("npm test · up to 600s").
+const WAIT_SUFFIX = / · up to \d+s$/;
+
 // The command a task_create of this turn started +taskId+ with (its row's
-// view), or null: a task from an earlier turn has no row here.
+// view), else a task_wait row's title for it (the server titles one by its
+// task's command, also for a task from an earlier turn: ToolActivity.
+// task_title), or null.
 export function taskCommand(gens, taskId) {
+  let titled = null;
   for (const gen of gens || []) {
     for (const row of gen.tools || []) {
+      if (row.tool === "task_wait" && row.view?.task_id === taskId && row.title) {
+        titled ||= row.title.replace(WAIT_SUFFIX, "");
+      }
       if (row.tool !== "task_create") continue;
       const id = /(?:^|\n)task_id: (\S+)/.exec(row.output || "")?.[1];
       if (id === taskId) return row.view?.command || null;
     }
   }
-  return null;
+  return titled;
 }
 
 export function confirmText(taskId, command) {

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

@@ -24,20 +24,25 @@ export function turnTimingText(number, durationMs, { running = false, canceled =
 // CANCEL_REASONS); anything else as it is. Both sides: spec/shared/labels_matrix.json.
 const CANCEL_REASONS = { ctrl_c: "Ctrl-C", user: "stopped", hook: "by a hook" };
 
-// The line a canceled turn ends with: "✕ canceled (stopped)", live from
+// The line a canceled turn ends with: "■ canceled (stopped)", 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). A
-// hook's stop that names who (+by+, cancelled_by): "✕ stopped by loop-guard".
+// hook's stop that names who (+by+, cancelled_by): "■ stopped by loop-guard".
+// Every cancel is a stop someone chose (the user, Ctrl-C, a hook), not a
+// failure: the ■ mark and the stopped colours of a call the Stop cut
+// (STOPPED_LINE_CLASS), not the ✕ of an error.
+export const STOP_MARK = "\u25A0";
+export const STOPPED_LINE_CLASS = "bubble cancel stopped";
 export function cancelLineText(reason, by) {
-  if (reason === "hook" && by) return `\u2715 stopped by ${by}`;
-  return "\u2715 canceled" + (reason ? ` (${CANCEL_REASONS[reason] || reason})` : "");
+  if (reason === "hook" && by) return `${STOP_MARK} stopped by ${by}`;
+  return `${STOP_MARK} canceled` + (reason ? ` (${CANCEL_REASONS[reason] || reason})` : "");
 }
 
-// A re-rendered turn's cancel line (a .bubble.cancel), or "" when the turn
-// record is not a canceled one.
+// A re-rendered turn's cancel line (a .bubble.cancel.stopped), 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, record.cancelled_by))}</div>`;
+  return `<div class="${STOPPED_LINE_CLASS}">${escape(cancelLineText(record.cancellation_reason, record.cancelled_by))}</div>`;
 }
 
 export function elapsedSince(startedAt, now = Date.now()) {

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

@@ -14,10 +14,12 @@ export function turnOutput(data) {
 
 // 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.
+// The footer's stop is the user's, drawn as a cancel is (\u25A0, timing.js
+// cancelLineText); a worker that exited on its own is a failure (\u2715).
 // null when no turn was running.
 export function workerGoneText({ turnRunning, stopped = false }) {
   if (!turnRunning) return null;
-  return `\u2715 canceled (${stopped ? "session stopped" : "worker exited"})`;
+  return stopped ? "\u25A0 canceled (session stopped)" : "\u2715 canceled (worker exited)";
 }
 
 // How long a turn's answer waits for the after_turn hooks' answer_display

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

@@ -159,29 +159,43 @@ function cut(line) {
   return line.length > LABEL_MAX ? `${line.slice(0, LABEL_MAX).trimEnd()}…` : line;
 }
 
-function toolCallsText(n) {
-  return `${n} tool call${n === 1 ? "" : "s"}`;
+// "3 tool calls (1 failed)": failed = status error, the tally's predicate
+// (tally.js), so a step's label and the block's summary never disagree.
+function toolCallsText(rows) {
+  const n = rows.length;
+  const failed = failedCount(rows);
+  return `${n} tool call${n === 1 ? "" : "s"}${failed ? ` (${failed} failed)` : ""}`;
+}
+
+// A gen's calls that failed (status error; blocked and stopped don't count).
+export function failedCount(rows) {
+  return rows.filter((r) => r.status === "error").length;
 }
 
 // The collapsed row of a gen: its narration's first line, else its first
 // call's title ("edit lib/a.rb"), else the tools it worked with, else
-// "thinking"; then its call count.
+// "thinking"; then its call count and how many failed.
 export function genLabel(gen) {
+  const { head, calls } = genLabelParts(gen);
+  return calls ? `${head} · ${calls}` : head;
+}
+
+// genLabel in its parts: +head+, +calls+ ("3 tool calls (1 failed)", or ""
+// without calls) and +repeats+: the head is words the open step's body
+// starts with (its narration, its first call's title), so an open step's
+// summary can say only its calls (turn_view.js labelHtml).
+export function genLabelParts(gen) {
   const line = String(gen.text || "").trim().split("\n")[0].trim();
-  const calls = gen.tools.length;
+  const calls = gen.tools.length ? toolCallsText(gen.tools) : "";
   const first = gen.tools[0];
-  let head;
-  if (line) {
-    head = cut(line);
-  } else if (first?.title) {
-    head = cut(`${toolName(first)} ${first.title}`);
-  } else if (calls) {
+  if (line) return { head: cut(line), calls, repeats: true };
+  if (first?.title) return { head: cut(`${toolName(first)} ${first.title}`), calls, repeats: true };
+  if (gen.tools.length) {
     const names = [...new Set(gen.tools.map(toolName))];
-    head = `working with ${names.slice(0, LABEL_TOOLS).join(", ")}${names.length > LABEL_TOOLS ? ", …" : ""}`;
-  } else {
-    return "thinking";
+    const head = `working with ${names.slice(0, LABEL_TOOLS).join(", ")}${names.length > LABEL_TOOLS ? ", …" : ""}`;
+    return { head, calls, repeats: false };
   }
-  return calls ? `${head} · ${toolCallsText(calls)}` : head;
+  return { head: "thinking", calls: "", repeats: false };
 }
 
 // The block's summary line: "working · 3 steps · 8 tool calls · execute ×7 · …"
@@ -192,7 +206,7 @@ export function blockSummary(turn, { running = false } = {}) {
   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));
+  else if (rows.length) fields.push(toolCallsText(rows));
   if (running) fields.unshift("working");
   return fields.join(" · ");
 }

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

@@ -30,19 +30,44 @@ import { taskCommand, taskStopButton } from "./task_stop.js";
 // denied it), else ok ("done").
 const NAMED_STATUSES = ["running", "error", "stopped", "blocked"];
 
-function activityStatusClass(status) {
-  return NAMED_STATUSES.includes(status) ? status : "ok";
+// A row's status as its parts: the mark's class (CSS draws the glyph), its
+// label (aria-label and title) and the word an exception shows after the
+// title (empty for done and running). Live and reload share it.
+export function statusParts(status) {
+  const named = NAMED_STATUSES.includes(status);
+  const cls = named ? status : "ok";
+  const label = named ? status : "done";
+  return { cls, label, word: cls === "ok" || cls === "running" ? "" : label };
 }
 
-function activityStatusLabel(status) {
-  return NAMED_STATUSES.includes(status) ? status : "done";
+function statusMarkHtml({ cls, label }) {
+  return `<span class="activity-status ${cls}" role="img" aria-label="${label}" title="${label}"></span>`;
+}
+
+function statusWordHtml({ cls, word }) {
+  return word ? `<span class="activity-state ${cls}">${word}</span>` : "";
 }
 
 // A live tool row filled from its activity row (status, title, output).
 function fillActivityRow(el, row, sessionId) {
+  const parts = statusParts(row.status);
   const statusEl = el.querySelector(".activity-status");
-  statusEl.className = `activity-status ${activityStatusClass(row.status)}`;
-  statusEl.textContent = activityStatusLabel(row.status);
+  statusEl.className = `activity-status ${parts.cls}`;
+  statusEl.setAttribute("role", "img");
+  statusEl.setAttribute("aria-label", parts.label);
+  statusEl.title = parts.label;
+  // The exception's word after the title (reloadRowHtml's place); never
+  // beside a running task_wait's stop button, which needs "running".
+  let wordEl = el.querySelector(":scope > .activity-state");
+  if (!parts.word) wordEl?.remove();
+  else {
+    if (!wordEl) {
+      wordEl = document.createElement("span");
+      (el.querySelector(":scope > .activity-params") || el.querySelector(":scope > .activity-tool")).after(wordEl);
+    }
+    wordEl.className = `activity-state ${parts.cls}`;
+    wordEl.textContent = parts.word;
+  }
   const toolEl = el.querySelector(".activity-tool");
   if (toolEl) toolEl.textContent = toolName(row);
   const paramsEl = el.querySelector(".activity-params");
@@ -363,13 +388,21 @@ export function createTurnView({
       // answer, which reuses the wrap).
       if (!gen.text && !gen.tools.length && turn.gens.length > 1) unwrapThinking(entry);
     }
-    entry.summary.textContent = model.genLabel(gen);
+    writeClosedLabel(entry, gen);
     if (!entry.toggled) entry.el.open = false;
     // Every generation's text goes into seenContent (the turn output dedupe).
     const k = normalize(gen.text);
     if (k) sawText(k);
   }
 
+  // A closed step's label and its failed mark (a red chevron that survives
+  // an ellipsed label): at close, and again when a late tool result lands
+  // in a step that already closed.
+  function writeClosedLabel(entry, gen) {
+    setLabel(entry.summary, gen);
+    entry.el.classList.toggle("has-failed", model.failedCount(gen.tools) > 0);
+  }
+
   // A step that closes mid-turn (the next one starts) collapses: a warn card
   // in it would go out of sight until the turn ends. It moves out of the
   // step, right after it in the block (open while the turn runs), where
@@ -417,6 +450,7 @@ export function createTurnView({
       fillActivityRow(el, r.row, sessionId());
       syncTaskStop(el, r.row);
     }
+    if (!entry.el.classList.contains("live")) writeClosedLabel(entry, r.gen);
     updateBlockSummary();
     onChange();
   }
@@ -517,7 +551,7 @@ export function createTurnView({
     }
     entry.text = document.createElement("div");
     entry.text.className = "gen-text";
-    entry.summary.textContent = model.genLabel({ ...gen, text: "" });
+    setLabel(entry.summary, { ...gen, text: "" });
     model.takeAnswer(turn, gen);
     // Cards and hook notices in a step that goes (below, or with the whole
     // block for a plain answer) stay: before the answer, out of the block,
@@ -697,6 +731,29 @@ function defaultPlaceAnswer(appendToHistory) {
   };
 }
 
+// A closed step's summary (model.genLabel). When its head is the words the
+// body starts with (the narration's first line, the first call's title)
+// and it has calls, the summary is marked .repeats and its parts are
+// spans: an open step shows only its calls (index.html), so it doesn't say
+// the same words twice. Its text stays genLabel's either way.
+// { repeats, html } (the summary's inside).
+function labelParts(gen) {
+  const { head, calls, repeats } = model.genLabelParts(gen);
+  if (!repeats || !calls) return { repeats: false, html: escapeHtml(model.genLabel(gen)) };
+  return { repeats: true, html: `<span class="gen-head">${escapeHtml(head)}</span><span class="gen-sep"> · </span><span class="gen-calls">${escapeHtml(calls)}</span>` };
+}
+
+function labelHtml(gen) {
+  const { repeats, html } = labelParts(gen);
+  return `<summary${repeats ? ' class="repeats"' : ""}>${html}</summary>`;
+}
+
+function setLabel(summary, gen) {
+  const { repeats, html } = labelParts(gen);
+  summary.classList.toggle("repeats", repeats);
+  summary.innerHTML = html;
+}
+
 // A reloaded tool row, the live row's markup (fillActivityRow): status, tool, params, the full command (an
 // execute/task_create's view), output (its "[tool]" tag dropped, 300 chars, the rest on hover), plus the call's
 // duration from its record.
@@ -712,8 +769,9 @@ function reloadRowHtml(r, thumbs) {
   const output = full
     ? `<div class="activity-output" title="${escapeHtml(full)}">${escapeHtml(full.length > 300 ? `${full.slice(0, 300)}…` : full)}</div>`
     : "";
-  return `<div class="activity-row" data-key="${escapeHtml(r.key)}"><span class="activity-status ${activityStatusClass(r.status)}">${activityStatusLabel(r.status)}</span>` +
-    `<span class="activity-tool">${escapeHtml(toolName(r))}</span>${params}${duration ? `<span class="activity-duration">${escapeHtml(duration)}</span>` : ""}` +
+  const status = statusParts(r.status);
+  return `<div class="activity-row" data-key="${escapeHtml(r.key)}">${statusMarkHtml(status)}` +
+    `<span class="activity-tool">${escapeHtml(toolName(r))}</span>${params}${statusWordHtml(status)}${duration ? `<span class="activity-duration">${escapeHtml(duration)}</span>` : ""}` +
     `${commandBlockHtml(r.view, r.title)}${output}` +
     `${r.images?.length ? thumbs(r.images) : ""}${r.diff ? activityDiffHtml(r.diff) : ""}</div>`;
 }
@@ -775,7 +833,8 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
         // The steers the step answered first, where the live rows went.
         const steers = (group.steps[k].steers || []).map((i) => steerHtml(i, false)).join("");
         const tools = gen.tools.length ? `<div class="activity-body">${gen.tools.map((r) => reloadRowHtml(r, thumbs)).join("")}</div>` : "";
-        return `<details class="gen"><summary>${escapeHtml(model.genLabel(gen))}</summary>${steers}${thinking}${text}${tools}</details>`;
+        const failed = model.failedCount(gen.tools) ? " has-failed" : "";
+        return `<details class="gen${failed}">${labelHtml(gen)}${steers}${thinking}${text}${tools}</details>`;
       });
       parts.push(`<details class="turn-work done"><summary>${escapeHtml(model.blockSummary({ gens, ended: true }))}</summary>${rows.join("")}</details>`);
     }

data/lib/samagotchi/worker.rb

@@ -268,7 +268,7 @@ module Samagotchi
 
       Log.info(:worker, "dead_question_dropped", id: @session.pending_question[:id])
       @session.pending_question = nil
-      @session.save(state_dir: @state_dir)
+      save_or_log(:dead_question) { @session.save(state_dir: @state_dir) }
     end
 
     # spawn_session hands the first prompt over in last_prompt, but
@@ -285,7 +285,7 @@ module Samagotchi
 
       prompt = @session.last_prompt
       @session.last_prompt = ""
-      @session.save(state_dir: @state_dir)
+      save_or_log(:initial_prompt) { @session.save(state_dir: @state_dir) }
       prompt
     end
 
@@ -308,14 +308,16 @@ module Samagotchi
       return false unless queue_as_command(prompt, nil)
 
       @session.status = Session::STATUS_IDLE
-      save_session
+      save_or_log(:initial_command) { save_session }
       true
     end
 
     # Add the queued context notes to the conversation (between turns only,
     # on this thread), save, then delete their files: a crash before the
     # delete leaves them claimed, and Engine#add_context_note skips a note
-    # the saved conversation already holds. Not activity: a note alone
+    # the saved conversation already holds. A failed save keeps the files
+    # too: the next pass claims them again, finds them in the conversation
+    # and saves again. Not activity: a note alone
     # neither starts a turn nor keeps an idle worker up.
     def absorb_notes
       files = SessionInbox.find_new_note_files(@session_dir)
@@ -326,7 +328,8 @@ module Samagotchi
         note = SessionInbox.read_note(file)
         @engine.add_context_note(@session, note) if note
       end
-      @session.save(state_dir: @state_dir)
+      return unless save_or_log(:notes) { @session.save(state_dir: @state_dir) }
+
       claimed.each { |file| FileUtils.rm_f(file) }
     end
 
@@ -426,7 +429,7 @@ module Samagotchi
         announce_command(command, status: result.status.to_s, output: result.output, changed: Array(result.changed))
         shown.each { |event| @engine.announce(event) }
       end
-      save_session unless Array(result.changed).empty?
+      save_or_log(:command) { save_session } unless Array(result.changed).empty?
       user_input(command[:client_id]) if resolved
       @continue_offer.after_command(result, resolved: resolved)
       @continue_offer.run_continue_turn(command) if result.resume
@@ -515,7 +518,21 @@ module Samagotchi
       unless response.nil? || response.strip.empty? || @continue_offer.awaiting?
         SessionInbox.write_output(@session_dir, response)
       end
-      save_session
+      save_or_log(:turn) { save_session }
+    end
+
+    # A save between turns (the turn's own, a command's, the notes', the
+    # first prompt's): what it saves is in memory, so one that fails (disk
+    # full, permissions; the next save writes it) is logged and must not
+    # take the worker down with it.
+    # @param at [Symbol] which save, for the log
+    # @return [Boolean] whether it saved
+    def save_or_log(at)
+      yield
+      true
+    rescue SystemCallError, IOError => e
+      Log.exception(:worker, "save_failed", e, at: at)
+      false
     end
 
     # Back to the conversation before the failed turn, as the REPL does (so

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -301,6 +301,7 @@ files:
 - lib/samagotchi/memory_bundle/uninstaller.rb
 - lib/samagotchi/memory_paths.rb
 - lib/samagotchi/model_catalog.rb
+- lib/samagotchi/model_list_store.rb
 - lib/samagotchi/model_overlay.rb
 - lib/samagotchi/model_profile.rb
 - lib/samagotchi/model_ref.rb