samagotchi 0.16.0 → 0.18.0

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

@@ -14,7 +14,10 @@
 
 import { dismissQuestion, sendAnswer, sendCommand } from "./data.js";
 import { diffHtml } from "./diff_view.js";
-import { approvalAllowed, approvalView, nextCardAction, relayedToView, resultText, summaryText } from "./question_card.js";
+import {
+  approvalAllowed, approvalView, CONTINUE_REASON_PLACEHOLDER, isContinue, nextCardAction, relayedToView, resultText,
+  summaryText,
+} from "./question_card.js";
 import { sessionHash } from "./route.js";
 import { clientLabel, continueLine, isOwn } from "./turn_events.js";
 
@@ -50,8 +53,11 @@ export function createQuestionCards({
     removeHintIfEmpty();
 
     const approval = approvalView(pq);
+    const stepLimit = isContinue(pq);
+    // The step-limit question stands for the old continue card.
+    if (stepLimit) dropContinueCard();
     const card = doc.createElement("details");
-    card.className = approval ? "bubble question approval" : "bubble question";
+    card.className = approval ? "bubble question approval" : stepLimit ? "bubble question step-limit" : "bubble question";
     card.dataset.qid = pq.id;
     // Open while pending: the question must be actionable.
     card.open = true;
@@ -77,7 +83,9 @@ export function createQuestionCards({
     }
 
     const options = Array.isArray(pq.options) ? pq.options : [];
-    if (options.length) {
+    if (stepLimit) {
+      renderStepLimitActions(card, pq, options);
+    } else if (options.length) {
       const list = doc.createElement("div");
       list.className = "question-options";
       const inputType = pq.multi_select ? "checkbox" : "radio";
@@ -98,6 +106,14 @@ export function createQuestionCards({
       card.appendChild(list);
     }
 
+    if (stepLimit) {
+      const follow = isNearBottom();
+      place(card);
+      questionEl = card;
+      if (follow) scrollToEnd();
+      return;
+    }
+
     let freeformInput = null;
     if (pq.allow_freeform) {
       freeformInput = doc.createElement("input");
@@ -168,6 +184,49 @@ export function createQuestionCards({
     if (follow) scrollToEnd();
   }
 
+  // The step-limit question's actions: a button per option (Continue,
+  // Stop), the reason (it goes with Stop) and no dismiss: the turn waits
+  // on one or the other. A Continue with a reason in the box is refused
+  // here, as the worker would.
+  function renderStepLimitActions(card, pq, options) {
+    const reason = doc.createElement("input");
+    reason.type = "text";
+    reason.className = "question-freeform continue-reason";
+    reason.placeholder = CONTINUE_REASON_PLACEHOLDER;
+    const err = doc.createElement("div");
+    err.className = "question-error hidden";
+    const row = doc.createElement("div");
+    row.className = "continue-actions";
+    const send = (label) => {
+      const freeform = label === "Continue" ? "" : reason.value.trim();
+      if (label === "Continue" && reason.value.trim()) {
+        err.textContent = "Continue takes no reason: clear it, or Stop with it.";
+        err.classList.remove("hidden");
+        return;
+      }
+      err.classList.add("hidden");
+      card.querySelectorAll("button, input").forEach((el) => { el.disabled = true; });
+      card.classList.add("submitting");
+      api.sendAnswer(sessionId(), { id: pq.id, selected: [label], ...(freeform ? { freeform } : {}) }).catch((e) => {
+        card.querySelectorAll("button, input").forEach((el) => { el.disabled = false; });
+        card.classList.remove("submitting");
+        err.textContent = /503|not_live/.test(e.message) ? "Session is not running — restart it to answer." : e.message;
+        err.classList.remove("hidden");
+      });
+    };
+    options.forEach((label, i) => {
+      const button = doc.createElement("button");
+      button.className = i === 0 ? "question-choice continue-yes" : "question-choice continue-no ghost";
+      button.dataset.value = String(label);
+      button.textContent = String(label);
+      button.addEventListener("click", () => send(String(label)));
+      row.appendChild(button);
+    });
+    if (pq.allow_freeform) row.appendChild(reason);
+    card.appendChild(row);
+    card.appendChild(err);
+  }
+
   // The tool, the command (or paths, or args) as code, where and why; no
   // code box when there is nothing to show.
   function renderApprovalDetails(view) {
@@ -282,6 +341,9 @@ export function createQuestionCards({
 
   function markQuestionSelection(sel) {
     if (!questionEl || !sel.length) return;
+    questionEl.querySelectorAll(".question-choice").forEach((button) => {
+      if (sel.includes(button.dataset.value)) button.classList.add("selected");
+    });
     questionEl.querySelectorAll(".question-option input").forEach((input) => {
       if (sel.includes(input.value)) {
         input.checked = true;
@@ -317,8 +379,17 @@ export function createQuestionCards({
     dropped: "Dropped: a new prompt came",
   };
 
+  // The old card goes: the step-limit question asks the same (a worker that
+  // posts it announces continue_offered too, for older pages).
+  function dropContinueCard() {
+    continueEl?.remove();
+    continueEl = null;
+  }
+
   function renderContinueCard(offer) {
     if (continueEl?.isConnected) return;
+    // A step-limit question is up: it is the card (an older worker has none).
+    if (isContinue(pending)) return;
     removeHintIfEmpty();
     const card = doc.createElement("div");
     card.className = "bubble continue";

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

@@ -70,6 +70,7 @@ export function withChildrenAfterParents(list) {
 const WAITING_BADGES = {
   question: { text: "question", title: "Waiting for your answer" },
   approval: { text: "approval", title: "Waiting for your approval" },
+  continue: { text: "out of steps", title: "The turn hit its step limit: continue or stop it" },
   card: { text: "needs you", title: "A card in the running turn waits for you" },
 };
 

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

@@ -360,6 +360,13 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
   // never above the session panel (the dock is absolute: a tall composer or
   // a phone's keyboard would push the stage's top out) ────────────────────
 
+  // Scroll the stage so +slot+'s end shows (it is the scroller's child).
+  function revealSlot(slot) {
+    if (stage.hidden || slot.hidden) return;
+    const end = slot.offsetTop + slot.offsetHeight - scroller.clientHeight;
+    if (end > scroller.scrollTop) scroller.scrollTop = end;
+  }
+
   function fitCap() {
     if (stage.hidden) return;
     const rest = dockEl.offsetHeight - stage.offsetHeight;
@@ -593,8 +600,13 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
       const stick = slot.scrollHeight - slot.scrollTop - slot.clientHeight < 24;
       slot.appendChild(el);
       slot.hidden = false;
-      if (stick || el.matches?.(PENDING) || el.querySelector?.(ASKS)) slot.scrollTop = slot.scrollHeight;
+      const waits = el.matches?.(PENDING) || el.querySelector?.(ASKS);
+      if (stick || waits) slot.scrollTop = slot.scrollHeight;
       scheduleRefresh();
+      // A card that waits for the user is brought into the stage's view: in
+      // a short window the prompt and headline fill it and the card sat
+      // below, out of sight (after the refresh, which hides the live slots).
+      if (waits) requestAnimationFrame(() => requestAnimationFrame(() => revealSlot(slot)));
       return true;
     },
     // Where the live timing line goes (the status row), null: the history.

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

@@ -30,3 +30,14 @@ export function stripShowParts(sessions) {
     waiting: waitingN ? `${waitingN} waiting` : "",
   };
 }
+
+// A window this short hides the strip by itself: at ~500-700 px the stage
+// is capped low and a card that waits there (a question, an approval) is
+// cut off below the strip.
+export const SHORT_WINDOW_QUERY = "(max-height: 700px)";
+
+// Whether the strip is hidden: the user's own hide (saved), or a short
+// window unless the user showed it (the pill) since it got short.
+export function stripAutoHidden({ saved, short, shownWhileShort }) {
+  return !!saved || (!!short && !shownWhileShort);
+}

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

@@ -55,6 +55,47 @@ export function normalizeTiming(data = {}) {
   };
 }
 
+// A turn-end re-read's timing (+data+, the server's ?tail=1&recent=1: the
+// newest turn's records and turn_count) merged into the page's (+timing+,
+// normalizeTiming's shape). Records by id: a known one is replaced in
+// place; an unknown turn goes in started_at order (ties and unparsable
+// dates keep arrival order), an unknown tool record at the end (they come
+// grouped by turn, in call order). startedAt, sessionDurationMs and
+// activeTurn are the reply's. `short`: the reply's turn_count says the page
+// misses a turn (it then reads the whole timing). A reply without
+// turn_count (an older server: the whole timing) replaces, as before; more
+// records than the count (a worker died before saving a turn the page saw)
+// are kept.
+// @return {{timing: object, short: boolean}}
+export function mergeTiming(timing, data = {}) {
+  const fresh = normalizeTiming(data || {});
+  const count = data?.turn_count;
+  if (typeof count !== "number" || !Number.isFinite(count)) return { timing: fresh, short: false };
+  const turnRecords = (timing?.turnRecords || []).slice();
+  fresh.turnRecords.forEach((record) => {
+    if (replaceById(turnRecords, record)) return;
+    const started = Date.parse(record.started_at);
+    const at = Number.isFinite(started)
+      ? turnRecords.findIndex((r) => Date.parse(r?.started_at) > started)
+      : -1;
+    if (at < 0) turnRecords.push(record);
+    else turnRecords.splice(at, 0, record);
+  });
+  const toolRecords = (timing?.toolRecords || []).slice();
+  fresh.toolRecords.forEach((record) => {
+    if (!replaceById(toolRecords, record)) toolRecords.push(record);
+  });
+  return { timing: { ...fresh, turnRecords, toolRecords }, short: turnRecords.length < count };
+}
+
+function replaceById(records, record) {
+  if (record?.id == null) return false;
+  const at = records.findIndex((r) => r?.id === record.id);
+  if (at < 0) return false;
+  records[at] = record;
+  return true;
+}
+
 export function turnRecordAt(timing, index) {
   const records = timing?.turnRecords;
   return Array.isArray(records) ? records[index] || null : null;
@@ -185,37 +226,51 @@ function recordRows(tools, iteration) {
 }
 
 // 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.
+// every assistant message is one step. Its calls take the turn's records by
+// tool, in call order (each the next record of its tool, consumed with the
+// ones it skipped), not by iteration: an empty retry spends an iteration
+// that left no message (as the TUI's join, attached_loop.rb join_duration).
+// 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 pool = [...tools].sort((a, b) =>
+    (Number(a.iteration) || 0) - (Number(b.iteration) || 0) || (Number(a.call_index) || 0) - (Number(b.call_index) || 0));
   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}`);
+        const r = takeRecord(pool, call.tool);
         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) });
+  // Records no saved message took (a generation that saved nothing): a
+  // step per iteration of theirs, after the messages'.
+  let iteration = g.texts.length;
+  for (const n of [...new Set(pool.map((r) => Number(r.iteration) || 0))]) {
+    iteration += 1;
+    const rows = recordRows(pool, n).map((row) => ({ ...row, key: `${iteration}:${row.key.split(":")[1]}` }));
+    steps.push({ i: null, iteration, thinking: "", tools: rows });
   }
   return { kind: "turn", turnIndex: g.turnIndex, user: g.user, answer, record, steps };
 }
 
+// The next record of +tool+ in +pool+ (call order), removed with the ones
+// before it; undefined when there is none (the pool stays as it was).
+function takeRecord(pool, tool) {
+  const at = pool.findIndex((r) => String(r.tool) === String(tool));
+  if (at < 0) return undefined;
+  return pool.splice(0, at + 1)[at];
+}
+
 // 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.

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

@@ -97,9 +97,73 @@ export function initWaitLine({ tasks } = {}) {
   return `waiting for ${labels.length ? labels.join(" · ") : "plugins"}…`;
 }
 
-// A composer line for the worker's command route rather than a prompt.
-export function isCommandLine(text) {
-  return /^[/!]/.test(String(text || "").trim());
+// Whether a composer line in an open session is one of its commands
+// (+commands+: the session GET's listing), as the terminals decide
+// (Commands::Registry#lookup): a "!" line with something after the "!", or
+// a listed name alone or followed by a space; a terminal's own (/stats,
+// /exit) too, which the page answers itself (webLocalReply). An unknown
+// "/word" (a path, a typo) goes to the model as a prompt, as in a terminal.
+export function sessionCommandLine(text, commands) {
+  const line = String(text || "").trim();
+  if (/^!\s*\S/.test(line)) return true;
+  if (!line.startsWith("/")) return false;
+  if (webLocalReply(line)) return true;
+  return (Array.isArray(commands) ? commands : [])
+    .some((c) => c && typeof c.name === "string" && (line === c.name || line.startsWith(`${c.name} `)));
+}
+
+// A line that is one word: a slash and a name, no spaces, no second slash
+// (Commands::Registry#unknown_command_word?). `/modle` is one; `/foo bar`
+// and `/usr/bin/env` are not (they are prompts).
+const UNKNOWN_COMMAND_WORD = /^\/[A-Za-z][A-Za-z0-9_-]*$/;
+
+// The hint for a command word no command answers (a typo like `/modle`),
+// or null when the line is not one: `Unknown command /modle. Did you mean
+// /model? /help lists the commands.` The "Did you mean" part needs a close
+// name among the session's commands and the page's own (webLocalReply).
+export function unknownCommandHint(text, commands) {
+  const line = String(text || "").trim();
+  if (!UNKNOWN_COMMAND_WORD.test(line)) return null;
+  if (sessionCommandLine(line, commands)) return null;
+  const names = (Array.isArray(commands) ? commands : [])
+    .map((c) => (c && typeof c.name === "string" ? c.name : null))
+    .filter(Boolean)
+    .concat(Object.keys(WEB_LOCAL_REPLIES));
+  const close = closestName(line, names);
+  return `Unknown command ${line}. ${close ? `Did you mean ${close}? ` : ""}/help lists the commands.`;
+}
+
+// The closest name within an optimal string alignment distance of 2, or
+// null. Ties go to the first in the list.
+function closestName(line, names) {
+  let best = null;
+  let bestDistance = 3;
+  for (const name of names) {
+    const distance = osaDistance(line, name);
+    if (distance < bestDistance) {
+      best = name;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+
+// Optimal string alignment distance: Levenshtein, with an adjacent
+// transposition counting as 1 (so `/modle` is 1 from `/model`, as Ruby's
+// DidYouMean reads it).
+function osaDistance(a, b) {
+  const rows = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 0; j <= b.length; j += 1) rows[0][j] = j;
+  for (let i = 1; i <= a.length; i += 1) {
+    for (let j = 1; j <= b.length; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        rows[i][j] = Math.min(rows[i][j], rows[i - 2][j - 2] + 1);
+      }
+    }
+  }
+  return rows[a.length][b.length];
 }
 
 // The terminal's own commands (a button in the web, or none yet): the
@@ -119,6 +183,13 @@ export function webLocalReply(text) {
   return WEB_LOCAL_REPLIES[name] || null;
 }
 
+// The start page's first message when the page answers it itself
+// (webLocalReply: /stats, /exit …): shown there, with no session made just
+// to hold the reply. With images it is a message, as in a session.
+export function startPageReply(text, { images = 0 } = {}) {
+  return images ? null : webLocalReply(text);
+}
+
 // The continue card's answers, as the terminal's continue prompt reads them.
 export function continueLine(choice, reason = "") {
   const why = String(reason || "").trim();

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

@@ -0,0 +1,15 @@
+// An open tab keeps its JS across a `chi web` restart (its event streams
+// just reconnect), so after an upgrade old page code talks to a new server.
+// The page knows the version that served it (body data-version); each
+// GET /api/events snapshot names the one serving now.
+
+// The toast's text when the chi web serving now is another version than
+// the one that served this page, else null: also when either side doesn't
+// say (an older chi web, a page from before data-version), and when the
+// toast was already shown for this version (+shown+: the reconnects'
+// snapshots carry it again).
+export function updateNotice(loaded, served, shown = null) {
+  const known = (v) => typeof v === "string" && v !== "";
+  if (!known(loaded) || !known(served) || loaded === served || served === shown) return null;
+  return `chi was updated to ${served}`;
+}

data/lib/samagotchi/worker.rb

@@ -12,6 +12,8 @@ require_relative "session_manager"
 require_relative "archive_store"
 require_relative "log"
 require_relative "turn_flow"
+require_relative "continue_offer"
+require_relative "iteration_limit"
 require_relative "session_commands"
 require_relative "model_profile"
 
@@ -44,8 +46,6 @@ module Samagotchi
     # How much of a command's output goes into its :command_ran.
     COMMAND_OUTPUT_LIMIT = 4096
     BUSY_OUTPUT = "busy: wait for the turn to end"
-    DEFAULT_MAX_ITERATIONS = 100
-    NO_INTERRUPT_MAX_ITERATIONS = 1000 # as Engine::NO_INTERRUPT_MAX_ITERATIONS
 
     # Wakes the worker loop. Whoever queues work writes it first and wakes
     # after, and #wait drains every wake before the loop looks for work: a
@@ -108,6 +108,13 @@ module Samagotchi
       # an empty session until the first turn.
       @engine.session = @session
       @turn_flow = TurnFlow.new(engine: @engine)
+      # Its question's answer is queued as the matching /continue (the
+      # Bridge exists by the time anyone answers).
+      @continue_offer = ContinueOffer.new(engine: @engine, turn_flow: @turn_flow, run_turn: method(:run_engine_turn),
+                                          max_iterations: method(:max_iterations),
+                                          queue_command: lambda { |line, client_id:|
+                                            @bridge.queue_command(line, client_id: client_id, card: true)
+                                          })
       # A recap written while a continue offer waits says the turn stopped
       # unfinished (before the idle jobs start).
       @engine.recap&.awaiting_continue = -> { @turn_flow.awaiting_continue? }
@@ -173,7 +180,7 @@ module Samagotchi
           absorb_notes
 
           if (prompt = take_initial_prompt)
-            run_prompt(prompt, nil)
+            run_prompt(prompt, nil) unless initial_command(prompt)
             next
           end
 
@@ -203,7 +210,10 @@ module Samagotchi
       ensure
         # The anytime commands finish and the plugins' services stop (a
         # server process), whatever the way out; the Bridge last, so a
-        # command's command_ran still reaches its UI on a crash.
+        # command's command_ran still reaches its UI on a crash. A
+        # step-limit question stays in the file (a save here would write
+        # over a stop's status): with no live worker the lists don't read
+        # it as waiting, and the next worker drops it (drop_dead_question).
         @engine&.shutdown
         @bridge&.stop
       end
@@ -269,6 +279,29 @@ module Samagotchi
       prompt
     end
 
+    # A session command sent as a message (chi send -m "/model x", a web
+    # page's first message) runs as the command, as the Bridge does for a
+    # POST /turn; an unknown /word stays a prompt. Queued: the loop's next
+    # pass runs it.
+    # @return [Boolean] whether +text+ was one
+    def queue_as_command(text, origin)
+      return false unless @engine.command_registry.command?(text.to_s)
+
+      @bridge.queue_command(text, client_id: origin&.dig(:client_id))
+      true
+    end
+
+    # The first prompt as a command: the session was saved as running for a
+    # turn that won't run.
+    # @return [Boolean] whether it was one
+    def initial_command(prompt)
+      return false unless queue_as_command(prompt, nil)
+
+      @session.status = Session::STATUS_IDLE
+      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
@@ -293,7 +326,10 @@ module Samagotchi
 
       begin
         message, origin, no_interrupt, images = SessionInbox.read_input(claimed_file)
-        run_prompt(message, origin, no_interrupt: !!no_interrupt, images: images || []) unless message.to_s.strip.empty?
+        return if message.to_s.strip.empty?
+        return if Array(images).empty? && queue_as_command(message, origin)
+
+        run_prompt(message, origin, no_interrupt: !!no_interrupt, images: images || [])
       ensure
         FileUtils.rm_f(claimed_file)
       end
@@ -304,7 +340,7 @@ module Samagotchi
     # @param images [Array<Hash>] the prompt's image refs ({file:, name:})
     def run_prompt(prompt, origin, no_interrupt: false, images: [])
       user_input(origin&.dig(:client_id))
-      drop_continue_offer(origin)
+      @continue_offer.drop(origin)
       @turn_flow.before_prompt_turn
       @merged_this_turn = []
       run_engine_turn(prompt, origin: origin, max_iterations: max_iterations(no_interrupt),
@@ -313,7 +349,7 @@ module Samagotchi
           # The Engine announced :turn_failed (with the error's one line).
           restore_failed_turn([[prompt, origin, images], *@merged_this_turn], error: error)
         else
-          after_turn(result, no_interrupt: no_interrupt)
+          @continue_offer.after_turn(result, no_interrupt: no_interrupt)
         end
       end
     end
@@ -329,16 +365,16 @@ module Samagotchi
       @engine.clear_due_reminder_names!
       return false unless @engine.reminders_due?
 
-      drop_continue_offer({ client_id: SessionManager::REMINDER_CLIENT_ID })
+      @continue_offer.drop({ client_id: SessionManager::REMINDER_CLIENT_ID })
       # A failure has no prompt to hand back (the Engine announced
       # :turn_failed). The offer went before the turn
-      # (drop_continue_offer); either way the rollback window closes.
+      # (ContinueOffer#drop); either way the rollback window closes.
       run_engine_turn(nil, continue: true, origin: { client_id: SessionManager::REMINDER_CLIENT_ID },
-                           max_iterations: DEFAULT_MAX_ITERATIONS) { @turn_flow.after_reminder_turn }
+                           max_iterations: IterationLimit.for) { @turn_flow.after_reminder_turn }
       true
     end
 
-    def max_iterations(no_interrupt) = no_interrupt ? NO_INTERRUPT_MAX_ITERATIONS : DEFAULT_MAX_ITERATIONS
+    def max_iterations(no_interrupt) = IterationLimit.for(no_interrupt: no_interrupt)
 
     # @return [Boolean] whether any command ran
     def run_queued_commands
@@ -372,22 +408,18 @@ module Samagotchi
     end
 
     def run_command(command)
-      awaiting = @turn_flow.awaiting_continue?
+      awaiting = @continue_offer.awaiting?
       result, shown = run_command_line(command)
-      resolved = awaiting && result.decision && result.decision != :invalid
+      resolved = @continue_offer.resolved?(awaiting, result)
       @engine.synchronize_events do
-        if resolved
-          @engine.announce(type: :continue_resolved, decision: result.decision.to_s, client_id: command[:client_id])
-        end
+        @continue_offer.announce_resolved(result, command) if resolved
         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?
       user_input(command[:client_id]) if resolved
-      # An offer answered without a turn ("no") is activity: the recap
-      # written at the offer (it says the turn stopped) gets rewritten.
-      @engine.record_activity if resolved && !result.resume
-      run_continue_turn(command) if result.resume
+      @continue_offer.after_command(result, resolved: resolved)
+      @continue_offer.run_continue_turn(command) if result.resume
     end
 
     # @return [Array(SessionCommands::Result, Array<Hash>)] the result, and
@@ -440,22 +472,6 @@ module Samagotchi
       @engine.announce(event)
     end
 
-    # The continue offer was answered yes: resume the conversation without a
-    # user message, with the iteration limit the offer's turn had. A failure
-    # keeps the offer, as the REPL does ("continue prompt preserved").
-    def run_continue_turn(command)
-      offer = @turn_flow.offer
-      @turn_flow.before_continue_turn
-      run_engine_turn(nil, continue: true, origin: { client_id: command[:client_id] }.compact,
-                           max_iterations: max_iterations(offer[:no_interrupt])) do |result, error|
-        if error
-          @engine.announce(type: :continue_offered, context: offer[:context], no_interrupt: offer[:no_interrupt])
-        else
-          after_turn(result, continue: true, no_interrupt: offer[:no_interrupt])
-        end
-      end
-    end
-
     # One Engine turn, the same for a prompt, a reminder and a continue:
     # the session shows as running to readers of the file (the web's
     # session list; the Engine resets it to idle when it ends), commands
@@ -476,31 +492,13 @@ module Samagotchi
       end
       yield result, error
       response = result&.output
-      SessionInbox.write_output(@session_dir, response) unless response.nil? || response.strip.empty?
-      save_session
-    end
-
-    # TurnFlow keeps the checkpoint (a cancelled turn's, for !rollback) and
-    # the continue offer of a turn that ran out of iterations, which every
-    # UI hears about.
-    def after_turn(result, continue: false, no_interrupt: false)
-      outcome = @turn_flow.after_turn(result, continue: continue, no_interrupt: no_interrupt)
-      return unless outcome == :continue_offered || outcome == :continue_cancelled
-
-      offer = @turn_flow.offer
-      @engine.announce(type: :continue_offered, context: offer[:context], no_interrupt: offer[:no_interrupt])
-    end
-
-    # A prompt (or a reminder turn) taken while a continue is offered
-    # replaces the answer (D2): the offer goes, the partial turn stays.
-    def drop_continue_offer(origin)
-      return unless @turn_flow.awaiting_continue?
-
-      @engine.synchronize_events do
-        @turn_flow.drop_offer!
-        @engine.announce(type: :continue_resolved, decision: "dropped", client_id: origin&.dig(:client_id))
+      # A turn that ran out of iterations and asks whether to continue left
+      # no reply: its text is what came before its last tool calls, and a
+      # wait (chi send --wait) gets the question instead.
+      unless response.nil? || response.strip.empty? || @continue_offer.awaiting?
+        SessionInbox.write_output(@session_dir, response)
       end
-      @engine.record_activity
+      save_session
     end
 
     # Back to the conversation before the failed turn, as the REPL does (so

data/lib/samagotchi/worker_sidecar.rb

@@ -42,7 +42,13 @@ module Samagotchi
       return nil unless sidecar&.port&.positive?
 
       begin
-        Socket.tcp(host, sidecar.port, connect_timeout: timeout).close
+        # Not Socket.tcp: with connect_timeout on macOS 26 it hands back the
+        # socket of a refused connect (the kernel's second connect() says
+        # EISCONN, SO_ERROR is unchecked), so a dead worker's port read as
+        # live. Ruby bug #22223, fixed in 3.4.11 / 4.0.7, not in 3.3.
+        # TCPSocket checks SO_ERROR and raises ECONNREFUSED on every Ruby,
+        # so this stays even once 3.3 is dropped.
+        TCPSocket.new(host, sidecar.port, connect_timeout: timeout).close
         sidecar
       rescue StandardError
         FileUtils.rm_f(path(session_dir)) if unlink