samagotchi 0.29.0 → 0.30.0

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

@@ -176,21 +176,26 @@ export function failedCount(rows) {
 // call's title ("edit lib/a.rb"), else the tools it worked with, else
 // "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(gen.tools)}` : head;
+  return { head: "thinking", calls: "", repeats: false };
 }
 
 // The block's summary line: "working · 3 steps · 8 tool calls · execute ×7 · …"

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

@@ -399,7 +399,7 @@ export function createTurnView({
   // an ellipsed label): at close, and again when a late tool result lands
   // in a step that already closed.
   function writeClosedLabel(entry, gen) {
-    entry.summary.textContent = model.genLabel(gen);
+    setLabel(entry.summary, gen);
     entry.el.classList.toggle("has-failed", model.failedCount(gen.tools) > 0);
   }
 
@@ -551,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,
@@ -731,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.
@@ -811,7 +834,7 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
         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>` : "";
         const failed = model.failedCount(gen.tools) ? " has-failed" : "";
-        return `<details class="gen${failed}"><summary>${escapeHtml(model.genLabel(gen))}</summary>${steers}${thinking}${text}${tools}</details>`;
+        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,16 +518,21 @@ module Samagotchi
       unless response.nil? || response.strip.empty? || @continue_offer.awaiting?
         SessionInbox.write_output(@session_dir, response)
       end
-      save_after_turn
+      save_or_log(:turn) { save_session }
     end
 
-    # The turn's own save: the turn ended fine and its messages are in
-    # memory, so a save that fails here (disk full, permissions; the next
-    # save writes them) must not take the worker down with it.
-    def save_after_turn
-      save_session
+    # 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)
+      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.29.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