samagotchi 0.17.0 → 0.18.0

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

@@ -23,17 +23,11 @@ export function listSessions(sort, order, { dir, ...opts } = {}) {
   );
 }
 
-// opts.dir: the folder the chat starts in (else the server's cwd).
-// dir: the folder the chat starts in; model: the model it starts on (as
-// GET /api/models spells it); either left out means the server's default.
-export function createSession(prompt, { dir, model, ...opts } = {}) {
-  const body = { prompt, ...(dir ? { dir } : {}), ...(model ? { model } : {}) };
-  return api("/api/sessions", { method: "POST", body: JSON.stringify(body), ...opts });
-}
-
 // A session with no first turn: the page's first message is sent into it
-// as a turn (with its images, once they are uploaded). preview: that
-// message, which names the session until its turn is saved.
+// as a turn (with its images, once they are uploaded). dir: the folder the
+// chat starts in; model: the model it starts on (as GET /api/models spells
+// it); either left out means the server's default. preview: that message,
+// which names the session until its turn is saved.
 export function createIdleSession({ dir, model, preview, ...opts } = {}) {
   const body = { idle: true, ...(dir ? { dir } : {}), ...(model ? { model } : {}), ...(preview ? { preview } : {}) };
   return api("/api/sessions", { method: "POST", body: JSON.stringify(body), ...opts });
@@ -61,11 +55,16 @@ export function uploadImage(id, file, name, opts = {}) {
 }
 
 // opts.tail: the lighter answer for the end of a turn (the session, its
-// timing and the last answer only), not the whole history.
+// timing and the last answer only), not the whole history; with
+// opts.recent its timing holds the newest turn's records and turn_count
+// (mergeTiming), and opts.turnId asks for that turn's answer.
+// opts.timing: the whole timing alone (when the merge came up short).
 // opts.parts: each saved message with what it did (thinking, tool calls
 // and their output), for the turn view's reload.
-export function getSession(id, { tail, parts, cards, ...opts } = {}) {
-  const query = cards ? "?cards=1" : tail ? "?tail=1" : parts ? "?parts=1" : "";
+export function getSession(id, { tail, recent, turnId, timing, parts, cards, ...opts } = {}) {
+  let query = cards ? "?cards=1" : tail ? "?tail=1" : timing ? "?timing=1" : parts ? "?parts=1" : "";
+  if (tail && recent) query += "&recent=1";
+  if (tail && turnId) query += `&turn_id=${encodeURIComponent(turnId)}`;
   return api(`/api/sessions/${id}${query}`, opts);
 }
 

data/lib/samagotchi/web/public/index.html

@@ -224,6 +224,9 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 .continue-context{font-size:12px;color:var(--text-3);margin-bottom:8px;white-space:pre-wrap}
 .continue-actions{display:flex;flex-wrap:wrap;gap:8px;align-items:center}
 .continue-reason{flex:1;min-width:140px;background:var(--bg-inset);border:1px solid var(--border-strong);border-radius:8px;color:var(--text);padding:6px 8px}
+/* The step-limit question (kind continue): the continue card's buttons inside a question card; the picked one stays marked once answered. */
+.bubble.question.step-limit .continue-actions{margin-top:2px}
+.bubble.question.step-limit .question-choice.selected{outline:2px solid var(--ok);outline-offset:1px;opacity:1}
 .bubble.question.submitting{opacity:.7}
 .bubble.question.answered{border-left-color:var(--ok)}
 .bubble.question.cancelled{border-left-color:var(--text-muted);opacity:.75}
@@ -666,9 +669,11 @@ body.all-view #center, body.all-view #topStrip{display:none}
 .card.archived{opacity:.6}
 .card.archived:hover{opacity:.85}
 .card .archived-badge{font-size:10px;padding:1px 6px;border-radius:6px;border:1px solid var(--border-strong);color:var(--text-muted)}
-#toast{position:fixed;left:50%;bottom:24px;transform:translateX(-50%);z-index:50;display:flex;gap:12px;align-items:center;padding:8px 14px;border-radius:10px;background:var(--bg-raised);color:var(--text);border:1px solid var(--border-strong);box-shadow:0 6px 24px rgba(0,0,0,.25);font-size:13px}
+#toast{position:fixed;left:50%;bottom:24px;transform:translateX(-50%);width:max-content;max-width:calc(100vw - 32px);box-sizing:border-box;z-index:50;display:flex;gap:12px;align-items:center;padding:8px 14px;border-radius:10px;background:var(--bg-raised);color:var(--text);border:1px solid var(--border-strong);box-shadow:0 6px 24px rgba(0,0,0,.25);font-size:13px}
 #toast[hidden]{display:none}
 #toast .toast-action{background:transparent;border:0;color:var(--accent);font-weight:600;cursor:pointer;padding:2px 4px}
+#toast .toast-close{background:transparent;border:0;color:var(--text-muted);cursor:pointer;padding:2px 4px;margin-left:-6px}
+#toast .toast-close:hover{color:var(--text)}
 #allList{flex:1;min-height:0;overflow:auto;display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:12px;align-content:start;padding:2px}
 .card.skeleton{pointer-events:none;border-style:dashed;opacity:.9;animation:skeleton-pulse 1.2s ease-in-out infinite}
 .card.skeleton .line{height:10px;background:var(--bg-raised);border-radius:6px}

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

@@ -15,13 +15,15 @@ export function notifyState({ hasNotification, secureContext, permission, wanted
 // A finished turn shorter than this was watched: no "done".
 export const DONE_MIN_SECONDS = 10;
 
-const questionReason = (q) => (q.kind === "approval" ? "approval" : "question");
+// The step-limit question (kind "continue": a turn ran out of iterations
+// and asks whether to go on) has its own reason: "out of steps".
+const questionReason = (q) => (q.kind === "approval" ? "approval" : q.kind === "continue" ? "continue" : "question");
 
 // What a session waits on the user for right now, from one summary: an open
 // question or approval, or a running turn's card with actions (check-in's
 // Nudge / Keep going / Stop asks as a question does). The session cards
 // mark and lift these; attentionFor notifies when one opens.
-// @return null | {reason: "question"|"approval"|"card", id}
+// @return null | {reason: "question"|"approval"|"continue"|"card", id}
 export function waitingOn(summary) {
   const q = summary?.pending_question;
   if (q && q.id) return { reason: questionReason(q), id: q.id };
@@ -137,6 +139,7 @@ export function attentionText(session, attention) {
   const body = {
     question: "needs an answer",
     approval: "needs approval",
+    continue: "hit its step limit",
     card: "needs you",
     failed: "turn failed",
     done: `done in ${seconds} s`

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

@@ -8,6 +8,23 @@ export function isApproval(pq) {
   return !!pq && pq.kind === "approval";
 }
 
+// The step-limit question (kind "continue"): a turn ran out of iterations.
+// Its card has a button per option (Continue, Stop) and a reason that goes
+// with Stop; it can't be dismissed.
+export function isContinue(pq) {
+  return !!pq && pq.kind === "continue";
+}
+
+export const CONTINUE_REASON_PLACEHOLDER = "Stop, because… (the model reads it)";
+
+// Why a step-limit question closed unanswered (its question_cancelled reason).
+const CONTINUE_CLOSED = {
+  dropped: "Dropped: a new prompt came",
+  answered: "Answered with /continue",
+  superseded: "Set aside for another question",
+  replaced: "Asked again",
+};
+
 // A delegate's approval relayed to this session's user (the approval
 // relay): who asks (the chain, "ab12 → cd34" for a grandchild's) and its
 // task, or null.
@@ -79,6 +96,7 @@ export function resultText(pq, { answer = null, cancelled = false, reason = "" }
   const approval = isApproval(pq);
   const relay = relayView(pq);
   if (cancelled && relay && reason !== "dismissed") return relayClosedText(relay, reason);
+  if (isContinue(pq)) return continueResultText({ answer, cancelled, reason });
   if (cancelled) {
     const label = approval ? "Denied" : "Cancelled";
     return reason ? `${label} (${reason})` : label;
@@ -97,6 +115,14 @@ export function resultText(pq, { answer = null, cancelled = false, reason = "" }
   return parts.length ? `Answered: ${parts.join(" · ")}` : "Answered";
 }
 
+function continueResultText({ answer, cancelled, reason }) {
+  if (cancelled) return CONTINUE_CLOSED[reason] || (reason ? `Closed (${reason})` : "Closed");
+  const sel = answer && Array.isArray(answer.selected) ? answer.selected : [];
+  const freeform = answer && answer.freeform ? String(answer.freeform) : "";
+  if (sel[0] === "Continue") return "Continued";
+  return freeform ? `Stopped: ${freeform}` : "Stopped";
+}
+
 // Shorten a line of text for the card's summary (the collapsed one-liner).
 export function truncate(text, n = 80) {
   const s = String(text ?? "");
@@ -115,7 +141,8 @@ export function summaryText(pq, { answer = null, cancelled = false, reason = ""
     const text = asked ? `${truncate(asked, 60)} → ${result}` : result;
     return truncate(relay ? `${relay.who}: ${text}` : text, 120);
   }
-  const label = isApproval(pq) ? `Approve ${pq.approval?.label || pq.approval?.tool || "call"}?` : "Question";
+  const label = isApproval(pq) ? `Approve ${pq.approval?.label || pq.approval?.tool || "call"}?`
+    : isContinue(pq) ? "Step limit" : "Question";
   return truncate(pq.header || label);
 }
 

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/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;

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

@@ -112,6 +112,60 @@ export function sessionCommandLine(text, 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
 // reply the page shows itself (they never go to the worker, which doesn't
 // know them), or null.
@@ -129,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? }
@@ -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
@@ -330,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),
@@ -339,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
@@ -355,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
@@ -398,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
@@ -466,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
@@ -502,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,9 +42,12 @@ module Samagotchi
       return nil unless sidecar&.port&.positive?
 
       begin
-        # Not Socket.tcp: with connect_timeout (Ruby 3.4, macOS 26) it hands
-        # back the socket of a refused connect (SO_ERROR set), so a dead
-        # worker's port read as live. TCPSocket raises ECONNREFUSED.
+        # 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