samagotchi 0.2.0 → 0.4.0

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

@@ -28,6 +28,13 @@ export function applySessionEvent(list, type, data = {}) {
   return list;
 }
 
+// The sessions a list shows: archived ones only when asked (the all view's
+// "include archived"). The page keeps them in its list either way: a parent
+// chip and the open session still need them.
+export function listedSessions(list, includeArchived = false) {
+  return includeArchived ? list : list.filter((s) => !s.archived);
+}
+
 const updatedMs = (s) => {
   const ms = Date.parse(s.updated_at || "");
   return Number.isNaN(ms) ? 0 : ms;

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

@@ -92,9 +92,12 @@ export function turnGroups(items, timing) {
   items.forEach((item, i) => {
     if (item?.role === "note") {
       groups.push({ kind: "note", i });
+    } else if (item?.role === "steer") {
+      if (turn) turn.steers.push(i);
+      else groups.push({ kind: "steer", i });
     } else if (item?.role === "user") {
       turnIndex += 1;
-      turn = { kind: "turn", turnIndex, user: i, texts: [] };
+      turn = { kind: "turn", turnIndex, user: i, texts: [], steers: [] };
       groups.push(turn);
     } else if (item?.role === "assistant") {
       if (turn) turn.texts.push(i);
@@ -103,22 +106,44 @@ export function turnGroups(items, timing) {
   });
   return groups.map((g) => {
     if (g.kind !== "turn") return g;
-    const record = turnRecordAt(timing, g.turnIndex);
-    const tools = record ? (timing?.toolRecords || []).filter((r) => r.turn_id === record.id) : [];
-    const stepsOnly = canceledSteps(g, record, tools);
-    if (g.texts.some((i) => items[i].parts)) return partsTurn(g, items, record, tools, stepsOnly);
-    const maxIteration = tools.reduce((m, r) => Math.max(m, Number(r.iteration) || 0), 0);
-    const stepTexts = stepsOnly ? g.texts : g.texts.slice(0, -1);
-    const steps = [];
-    for (let k = 0; k < Math.max(stepTexts.length, maxIteration); k += 1) {
-      const iteration = k + 1;
-      steps.push({ i: stepTexts[k] ?? null, iteration, tools: recordRows(tools, iteration) });
-    }
-    const answer = g.texts.length && !stepsOnly ? g.texts[g.texts.length - 1] : null;
-    return { kind: "turn", turnIndex: g.turnIndex, user: g.user, answer, record, steps };
+    return withSteers(turnGroup(g, items, timing), g.steers, items);
   });
 }
 
+// A turn's steers (a plugin's nudges) into its steps: each goes to the step
+// that answered it (`step`: the server counts the model messages since the
+// prompt, plus one). One whose step isn't there (the answer, which leaves
+// the block) stays on the group (`steers`): a bubble before the answer, as
+// live. A turn without steers keeps its shape.
+function withSteers(group, steerIndexes, items) {
+  if (!steerIndexes.length) return group;
+  const steps = group.steps.map((step) => ({ ...step, steers: [] }));
+  const left = [];
+  for (const i of steerIndexes) {
+    const n = Number(items[i].step) || 1;
+    const step = steps.find((s) => s.iteration === n);
+    if (step) step.steers.push(i);
+    else left.push(i);
+  }
+  return { ...group, steps, steers: left };
+}
+
+function turnGroup(g, items, timing) {
+  const record = turnRecordAt(timing, g.turnIndex);
+  const tools = record ? (timing?.toolRecords || []).filter((r) => r.turn_id === record.id) : [];
+  const stepsOnly = canceledSteps(g, record, tools);
+  if (g.texts.some((i) => items[i].parts)) return partsTurn(g, items, record, tools, stepsOnly);
+  const maxIteration = tools.reduce((m, r) => Math.max(m, Number(r.iteration) || 0), 0);
+  const stepTexts = stepsOnly ? g.texts : g.texts.slice(0, -1);
+  const steps = [];
+  for (let k = 0; k < Math.max(stepTexts.length, maxIteration); k += 1) {
+    const iteration = k + 1;
+    steps.push({ i: stepTexts[k] ?? null, iteration, tools: recordRows(tools, iteration) });
+  }
+  const answer = g.texts.length && !stepsOnly ? g.texts[g.texts.length - 1] : null;
+  return { kind: "turn", turnIndex: g.turnIndex, user: g.user, answer, record, steps };
+}
+
 // A canceled turn that ran more than one step or any call has no answer:
 // its partial text stays in the block, as it does live (turn_view.js
 // turnEnded promotes only a completed turn or a lone step with no tools).

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

@@ -45,10 +45,36 @@ export function reminderText(event) {
 }
 
 // Who a hook's notice is from: the bundle's name for a bundle hook
-// ("known_names.rb (bundle known-names)"), else "hook".
+// ("known_names.rb (bundle known-names)"), chi's own notice by its word
+// (thinking), else "hook".
 export function hookNoticeLabel(hook) {
-  const m = /\(bundle (.+)\)$/.exec(String(hook || ""));
-  return m ? m[1] : "hook";
+  const name = String(hook || "");
+  const m = /\(bundle (.+)\)$/.exec(name);
+  if (m) return m[1];
+  // chi's own notices name themselves with a bare word (thinking).
+  return /^[a-z][a-z0-9-]*$/.test(name) ? name : "hook";
+}
+
+// The row a step gets when the loop asks again after an empty answer.
+export function emptyRetryLine({ attempt, of } = {}) {
+  return `↻ empty answer, asking again (${attempt}/${of})`;
+}
+
+// The live turn's status while the provider is asked again after an error
+// (generation_retrying): "↻ retrying (503) in 4 s, 2/5" (retry 2 of 5).
+export function retryStatusLine({ attempt, max_retries, next_delay, status, error_class } = {}) {
+  const why = status || String(error_class || "").split("::").pop();
+  const delay = Number(next_delay);
+  const when = Number.isFinite(delay) ? ` in ${delay < 1 ? delay.toFixed(1) : Math.round(delay)} s` : "";
+  const count = attempt ? `, ${attempt}${max_retries ? `/${max_retries}` : ""}` : "";
+  return `↻ retrying${why ? ` (${why})` : ""}${when}${count}`;
+}
+
+// The live turn's status while it waits for plugins' slow setup before its
+// first request (plugin_init_wait).
+export function initWaitLine({ tasks } = {}) {
+  const labels = (tasks || []).map((t) => [t?.bundle, t?.label].filter(Boolean).join(": ")).filter(Boolean);
+  return `waiting for ${labels.length ? labels.join(" · ") : "plugins"}…`;
 }
 
 // A composer line for the worker's command route rather than a prompt.
@@ -56,6 +82,20 @@ export function isCommandLine(text) {
   return /^[/!]/.test(String(text || "").trim());
 }
 
+// The terminal's own commands that have a button in the web: the reply
+// the page shows itself (they never go to the worker, which doesn't know
+// them), or null.
+const WEB_LOCAL_REPLIES = {
+  "/archive": "/archive: use the archive button in the session bar",
+  "/exit": "/exit: close the tab to leave; stop in the session bar stops the worker",
+  "/quit": "/quit: close the tab to leave; stop in the session bar stops the worker",
+};
+
+export function webLocalReply(text) {
+  const name = String(text || "").trim().split(/\s+/)[0].toLowerCase();
+  return WEB_LOCAL_REPLIES[name] || null;
+}
+
 // The continue card's answers, as the terminal's continue prompt reads them.
 export function continueLine(choice, reason = "") {
   const why = String(reason || "").trim();
@@ -80,6 +120,8 @@ export function commandView(event, myId) {
     modelName: event.model_name || null,
     anytime: event.anytime === true,
     commandId: event.command_id || null,
+    // A card's action (Nudge…): no bubble unless it says something back.
+    hidden: event.card === true && !event.output && event.status !== "error",
   };
 }
 
@@ -100,6 +142,27 @@ export function restoreAction(event, { myId, sentIds, composerEmpty }) {
   }, sent && composerEmpty ? event.images : null);
 }
 
+// A turn that fails fast can have its prompt_restored come over the stream
+// before the /turn ack names its enqueued_id: `early` (a Map) keeps such a
+// restore of this tab's own prompt by that id, and the ack takes it back
+// (restoreOnAck), so the prompt goes into the composer the ack would clear.
+export function keepEarlyRestore(event, early, { myId, sentIds }) {
+  const origin = event?.origin || {};
+  const id = origin.enqueued_id;
+  if (!isOwn(origin.client_id, myId) || !id || sentIds.has(id)) return false;
+  early.set(id, event);
+  return true;
+}
+
+// The ack's enqueued_id (already in sentIds) was restored early: what the
+// composer gets back (as restoreAction for an empty composer), else null.
+export function restoreOnAck(enqueuedId, early, { myId, sentIds }) {
+  const event = enqueuedId && early.get(enqueuedId);
+  if (!event) return null;
+  early.delete(enqueuedId);
+  return restoreAction(event, { myId, sentIds, composerEmpty: true });
+}
+
 // What an event does to the prompt bubbles, as a list of ops for app.js:
 //   add   — a bubble for a prompt this tab hasn't shown (state queued /
 //           started / steered, labelled by its sender)
@@ -172,10 +235,12 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], started
           if (part.label) call.label = part.label;
           events.push({ type: "tool_call_started", ...call, params: part.params });
           if (part.status !== "running") {
-            events.push(withImages({
+            const completed = {
               type: "tool_call_completed", ...call, output: part.output, output_truncated: !!part.output_truncated,
               activity: { status: part.status, params: part.params },
-            }, part.images));
+            };
+            if (part.diff) completed.diff = part.diff;
+            events.push(withImages(completed, part.images));
           }
           break;
         }
@@ -191,6 +256,11 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], started
           closeText();
           events.push({ type: "hook_notice", hook: part.hook, text: part.text, level: part.level });
           break;
+        // A plugin's steer: a steer-only merge, as live.
+        case "steer":
+          closeText();
+          events.push({ type: "pending_input_merged", count: 0, content: null, steers: [{ source: part.source, text: part.text }] });
+          break;
         default:
           break;
       }

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

@@ -13,7 +13,8 @@ import { toolName } from "./activity.js";
 import { leavesBlock } from "./card.js";
 import { activityStatusClass, activityStatusLabel, fillActivityRow } from "./chat_view.js";
 import { copySourceAttr } from "./copy.js";
-import { escapeHtml, messageBodyHtml, noteHtml, normalize } from "./format.js";
+import { activityDiffHtml } from "./diff_view.js";
+import { escapeHtml, messageBodyHtml, noteHtml, normalize, steerRowHtml } from "./format.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { hookNoticeLabel } from "./turn_events.js";
 import { cancelLineHtml, formatDuration, turnGroups, turnTimingText } from "./timing.js";
@@ -29,6 +30,8 @@ export function createTurnView({ historyEl, appendToHistory, isNearBottom, sawTe
   let blockToggled = false;
   // gen → { el, summary, thinking, text, activity, rows: Map(key → el), toggled }
   const genEls = new Map();
+  // Steer rows waiting for the step that answers them (steer()).
+  let pendingSteers = [];
   const dirty = new Set();
   let rafPending = false;
   // The promoted answer bubble while it is held at the box's height (the
@@ -69,6 +72,9 @@ export function createTurnView({ historyEl, appendToHistory, isNearBottom, sawTe
     const summary = document.createElement("summary");
     summary.textContent = `step ${turn.gens.length}`;
     el.appendChild(summary);
+    // A plugin's steers merged since the last step: this step answers them.
+    for (const row of pendingSteers) el.appendChild(row);
+    pendingSteers = [];
     const text = document.createElement("div");
     text.className = "gen-text streaming";
     // A step after the first shows "…" until its text comes (the first one
@@ -317,7 +323,8 @@ export function createTurnView({ historyEl, appendToHistory, isNearBottom, sawTe
 
   // A hook's line (hook_notice) as a row of the current step, above the row
   // of the call it judged; false with no running turn (app.js shows the
-  // bubble then).
+  // bubble then). data.line is a whole row of chi's own (an empty-answer
+  // retry), shown as is.
   function notice(data) {
     const r = turn && model.notice(turn, data);
     if (!r) return false;
@@ -325,13 +332,34 @@ export function createTurnView({ historyEl, appendToHistory, isNearBottom, sawTe
     if (!r.gen.text) entry.text.textContent = "";
     const el = document.createElement("div");
     el.className = "hook-notice" + (data.level === "warn" ? " warn" : "");
-    el.textContent = `${hookNoticeLabel(data.hook)}: ${data.text || ""}`;
+    el.textContent = data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}`;
     const follow = isNearBottom();
     activityEl(r.gen).appendChild(el);
     if (follow) historyEl.scrollTop = historyEl.scrollHeight;
     return true;
   }
 
+  // A plugin's steer (pending_input_merged's steers) as the first row of
+  // the step that answers it: it joined the turn after the current step's
+  // tools, and the next generation (a new, open step) reads it; the
+  // current step collapses when that one starts. Held until then (a turn
+  // that ends first puts it in its last step). False with no running turn.
+  function steer(data) {
+    if (!turn || turn.ended) return false;
+    const holder = document.createElement("div");
+    holder.innerHTML = steerRowHtml(data);
+    pendingSteers.push(holder.firstChild);
+    return true;
+  }
+
+  // Held steer rows into the last step (the turn ends without another).
+  function flushSteers() {
+    const gen = turn.gens[turn.gens.length - 1];
+    const entry = gen && genEls.get(gen);
+    if (entry) for (const row of pendingSteers) entry.el.insertBefore(row, entry.thinkingWrap || entry.text);
+    pendingSteers = [];
+  }
+
   // A card shown during the turn (a plugin's, app.js draws it) as a row of
   // the current step, like a notice; false with no running turn (app.js
   // puts it between turns then).
@@ -376,8 +404,8 @@ export function createTurnView({ historyEl, appendToHistory, isNearBottom, sawTe
     // between turns.
     const leaving = !gen.thinking && gen.tools.length === 0;
     const plain = turn.gens.length === 1 && gen.tools.length === 0;
-    const cards = leaving || plain ? [...entry.el.querySelectorAll(".plugin-card, .hook-notice")] : [];
-    cards.forEach((el) => { if (el.classList.contains("hook-notice")) el.classList.add("bubble"); });
+    const cards = leaving || plain ? [...entry.el.querySelectorAll(".plugin-card, .hook-notice, .steer-row")] : [];
+    cards.forEach((el) => { if (!el.classList.contains("plugin-card")) el.classList.add("bubble"); });
     if (leaving) entry.el.remove();
     if (plain) {
       // A plain answer: no block, the bubble where it was (as the chat
@@ -425,6 +453,7 @@ export function createTurnView({ historyEl, appendToHistory, isNearBottom, sawTe
     // one shows at once.
     const box = promoting && kind === "completed" ? genEls.get(last)?.box : null;
     const heldHeight = box ? box.getBoundingClientRect().height : 0;
+    if (pendingSteers.length) flushSteers();
     apply(model.turnEnded(turn));
     if (promoting) promote(last, { heldHeight });
     const kept = [];
@@ -453,6 +482,7 @@ export function createTurnView({ historyEl, appendToHistory, isNearBottom, sawTe
       if (entry.tickerTimer) { clearTimeout(entry.tickerTimer); entry.tickerTimer = null; }
     }
     genEls.clear();
+    pendingSteers = [];
     dirty.clear();
     rafPending = false;
   }
@@ -499,6 +529,7 @@ export function createTurnView({ historyEl, appendToHistory, isNearBottom, sawTe
     },
     turnEnded,
     notice,
+    steer,
     card,
     flush,
     // The rendered answer landed (or the re-read failed): let the held
@@ -532,7 +563,7 @@ function reloadRowHtml(r, thumbs) {
     : "";
   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>` : ""}${output}` +
-    `${r.images?.length ? thumbs(r.images) : ""}</div>`;
+    `${r.images?.length ? thumbs(r.images) : ""}${r.diff ? activityDiffHtml(r.diff) : ""}</div>`;
 }
 
 // A reloaded history in the turn view (renderHistory's object path): per
@@ -554,28 +585,38 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     const { body, renderedMarkdown } = messageBodyHtml(m);
     return `<div class="bubble output${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(m, renderedMarkdown)}>${body}</div>${timing}`;
   };
+  const steerHtml = (i, bubble) => steerRowHtml({ source: items[i].source, text: items[i].content }, { bubble });
   return turnGroups(items, timing).map((group) => {
     if (group.kind === "note") return `<div class="bubble note">${noteHtml(items[group.i])}</div>`;
+    if (group.kind === "steer") return steerHtml(group.i, true);
     if (group.kind === "answer") return answerHtml(items[group.answer], "");
     const prompt = items[group.user];
     const parts = [`<div class="bubble user"${copySourceAttr(prompt, false)}><div class="user-message">${messageBodyHtml(prompt).body}${thumbs(prompt.images)}</div></div>`];
     const [only] = group.steps;
+    const noBlock = !group.steps.length ||
+      (group.steps.length === 1 && group.answer !== null && only.i === null && !only.tools.length && only.thinking);
     if (group.steps.length === 1 && group.answer !== null && only.i === null && !only.tools.length && only.thinking) {
       // A plain answer with thinking: the chat view's collapsed block, as live.
       parts.push(`<details class="bubble thinking"><summary>thinking</summary><div class="thinking-body">${escapeHtml(only.thinking)}</div></details>`);
     } else if (group.steps.length) {
       const gens = group.steps.map((step) => ({ text: step.i === null ? "" : String(items[step.i].content ?? ""), thinking: step.thinking || "", tools: step.tools }));
-      const rows = gens.map((gen) => {
+      const rows = gens.map((gen, k) => {
         // A thinking-only step: the body directly under the step's own
         // "thinking" summary (no wrap that would repeat it), as live.
         const body = gen.thinking ? `<div class="thinking-body">${escapeHtml(gen.thinking)}</div>` : "";
         const thinking = body && (gen.text || gen.tools.length) ? `<details class="thinking"><summary>thinking</summary>${body}</details>` : body;
         const text = gen.text ? `<div class="gen-text">${escapeHtml(gen.text)}</div>` : "";
+        // 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>${thinking}${text}${tools}</details>`;
+        return `<details class="gen"><summary>${escapeHtml(model.genLabel(gen))}</summary>${steers}${thinking}${text}${tools}</details>`;
       });
       parts.push(`<details class="turn-work done"><summary>${escapeHtml(model.blockSummary({ gens, ended: true }))}</summary>${rows.join("")}</details>`);
     }
+    // Steers with no step to sit in, or in a turn that shows no block: on
+    // their own after the prompt.
+    const loose = noBlock ? [...group.steps.flatMap((step) => step.steers || []), ...(group.steers || [])] : group.steers || [];
+    parts.push(loose.map((i) => steerHtml(i, true)).join(""));
     // A turn with no answer (canceled, or running: no record yet) shows its
     // timing after its prompt and steps, where the live view leaves it.
     if (group.answer === null) parts.push(timingHtml(group));

data/lib/samagotchi/web/server.rb

@@ -9,6 +9,7 @@ require "webrick"
 
 require_relative "app"
 require_relative "session_hub"
+require_relative "../config"
 require_relative "../project_scope"
 require_relative "../log"
 require_relative "../version"
@@ -51,7 +52,8 @@ module Samagotchi
       # open) its page for +dir+ and leave it be; else start one.
       # @param scope ["project", "all"] "all": the plain page, every session
       # @return [Integer] the exit status
-      def self.launch(port: nil, host: nil, scope: "project", dir: Dir.pwd, open_browser: false, markdown: false, turn_view: true)
+      def self.launch(port: nil, host: nil, scope: "project", dir: Dir.pwd, open_browser: false, markdown: false, turn_view: true,
+                      annotate_presets: Config::BY_KEY["web.annotate_presets"].default)
         host = resolve_host(host)
         port = resolve_port(port)
         url = scope_url(host, port, dir: dir, scope: scope)
@@ -65,7 +67,8 @@ module Samagotchi
           warn in_use_message(port)
           1
         else
-          start(port: port, host: host, url: url, open_browser: open_browser, markdown: markdown, turn_view: turn_view) ? 0 : 1
+          start(port: port, host: host, url: url, open_browser: open_browser, markdown: markdown, turn_view: turn_view,
+                annotate_presets: annotate_presets) ? 0 : 1
         end
       rescue Interrupt
         # Ctrl-C: the server has stopped (start's ensure); one line, and the
@@ -78,13 +81,14 @@ module Samagotchi
       #   from; built over the app's state dir unless given
       # @return [Boolean] false when the port was taken (said so on stderr)
       def self.start(port: nil, host: nil, url: nil, open_browser: false, state_dir: nil, manager: nil, markdown: false,
-                     turn_view: true, hub: nil)
+                     turn_view: true, annotate_presets: Config::BY_KEY["web.annotate_presets"].default, hub: nil)
         port = resolve_port(port)
         host = resolve_host(host)
         url ||= "http://#{url_host(host)}:#{port}/"
 
         hub ||= SessionHub.new(state_dir: state_dir || Session.default_state_dir, manager: manager || SessionManager)
-        app = App.new(manager: manager, state_dir: state_dir, markdown: markdown, turn_view: turn_view, hub: hub)
+        app = App.new(manager: manager, state_dir: state_dir, markdown: markdown, turn_view: turn_view,
+                      annotate_presets: annotate_presets, hub: hub)
         Samagotchi::Log.info(:web, "start", url: "http://#{host}:#{port}", version: Samagotchi::VERSION)
         hub.start
         # Said once the port is bound: a second chi web racing for it gets

data/lib/samagotchi/web/session_hub.rb

@@ -244,7 +244,8 @@ module Samagotchi
         if stamp != entry.stamp
           session = Session.summary_from_file(path)
           # Corrupt, or missing a field: not a session, as Session.list has it.
-          return drop(id) if session.nil?
+          # A `chi scratch` session is never shown.
+          return drop(id) if session.nil? || session.scratch
 
           # Looked up once per parse (a git call for a session saved before
           # the field), never per tick.

data/lib/samagotchi/web/session_summary.rb

@@ -2,7 +2,10 @@
 
 require_relative "../session"
 require_relative "../recap_store"
+require_relative "../archive_store"
+require_relative "../session_metrics"
 require_relative "../bridge_client"
+require_relative "../bridge/pending_card"
 
 module Samagotchi
   module Web
@@ -25,6 +28,7 @@ module Samagotchi
       # @return [Hash] symbol keys
       def build(session, owner:, session_dir:, status: displayed_status(session, owner: owner), root_cache: nil)
         used = session.respond_to?(:used_memory_names) ? Array(session.used_memory_names) : []
+        up = bridge_up?(session_dir, owner)
         {
           id: session.id,
           status: status,
@@ -46,13 +50,32 @@ module Samagotchi
           owner: owner&.fetch("kind", nil),
           # The saved recap's first sentence, for the session card.
           recap: RecapStore.preview(session_dir),
+          # How full the context was after the last turn (%), or nil.
+          ctx_pct: SessionMetrics.saved_context_pct(session_dir)&.round(1),
+          # Hidden from the strip and the list unless "include archived".
+          archived: ArchiveStore.archived?(session_dir),
           project_root: session.project_root(cache: root_cache),
           # A worker is reachable: its Bridge sidecar is there and the
           # owner lock is held. A sidecar a dead worker left is not up.
-          bridge_up: bridge_up?(session_dir, owner)
+          bridge_up: up,
+          # For the tab's notifications (notify.js): an open question, the
+          # running turn's open card with actions, and how the last turn
+          # ended.
+          pending_question: pending_question_for(session),
+          pending_card: up ? Bridge::PendingCard.read(session_dir) : nil,
+          last_turn: session.respond_to?(:last_turn) ? session.last_turn : nil
         }
       end
 
+      # The open question as {id:, kind:} ("approval" for a guardrail's,
+      # else "question"); nil when there is none. The text stays out.
+      def pending_question_for(session)
+        pending = session.respond_to?(:pending_question) ? session.pending_question : nil
+        return nil unless pending.is_a?(Hash) && pending[:id]
+
+        { id: pending[:id], kind: pending[:kind].to_s == "approval" ? "approval" : "question" }
+      end
+
       # status is turn state (idle/running). The live worker's snapshot is the
       # truth; on disk, a "running" with no live owner was left by a worker
       # that died mid-turn.

data/lib/samagotchi/worker.rb

@@ -7,6 +7,7 @@ require_relative "turn_note"
 require_relative "context_note"
 require_relative "worker_idle_exit"
 require_relative "session_manager"
+require_relative "archive_store"
 require_relative "log"
 require_relative "turn_flow"
 require_relative "session_commands"
@@ -286,6 +287,7 @@ module Samagotchi
       # list); the Engine resets it to idle when it ends.
       @session.status = Session::STATUS_RUNNING
       @session.save(state_dir: @state_dir)
+      user_input(origin&.dig(:client_id))
       drop_continue_offer(origin)
       @turn_flow.before_prompt_turn
       @merged_this_turn = []
@@ -316,6 +318,7 @@ module Samagotchi
       @engine.clear_due_reminder_names!
       return false unless @engine.reminders_due?
 
+      drop_continue_offer({ client_id: SessionManager::REMINDER_CLIENT_ID })
       @session.status = Session::STATUS_RUNNING
       @session.save(state_dir: @state_dir)
       begin
@@ -329,8 +332,8 @@ module Samagotchi
       ensure
         refuse_queued_commands
       end
-      # A pending continue offer stays (the REPL rule); otherwise the
-      # rollback window closes.
+      # The offer went before the turn (drop_continue_offer); the rollback
+      # window closes.
       @turn_flow.after_reminder_turn
       @session.save(state_dir: @state_dir) unless stopped_on_disk?
       true
@@ -381,6 +384,7 @@ module Samagotchi
         shown.each { |event| @engine.announce(event) }
       end
       @session.save(state_dir: @state_dir) unless Array(result.changed).empty? || stopped_on_disk?
+      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
@@ -432,6 +436,7 @@ module Samagotchi
                 status: status, output: text[0, COMMAND_OUTPUT_LIMIT], changed: changed.map(&:to_s),
                 model_name: @engine.effective_model_name }
       event[:anytime] = true if anytime
+      event[:card] = true if command[:card]
       event[:output_truncated] = true if text.length > COMMAND_OUTPUT_LIMIT
       @engine.announce(event)
     end
@@ -472,8 +477,8 @@ module Samagotchi
       @engine.announce(type: :continue_offered, context: offer[:context], no_interrupt: offer[:no_interrupt])
     end
 
-    # A prompt taken while a continue is offered replaces the answer (D2):
-    # the offer goes, the partial turn stays.
+    # 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?
 
@@ -536,6 +541,7 @@ module Samagotchi
             FileUtils.rm_f(claimed_file)
           end
         end
+        merged.each { |_prompt, origin| user_input(origin&.dig(:client_id)) }
         unless merged.empty?
           @engine.announce(type: :input_merged, count: merged.size, origins: merged.filter_map(&:last))
           @merged_this_turn.concat(merged)
@@ -628,6 +634,12 @@ module Samagotchi
       Log.info(:worker, "idle_exit", idle_s: @idle_exit.idle_seconds.round)
     end
 
+    # A human's input (ArchiveStore.user_input?) un-archives the session;
+    # a delegate's, a plugin's or a reminder's doesn't.
+    def user_input(client_id)
+      ArchiveStore.user_input(@session_id, state_dir: @state_dir) if ArchiveStore.user_input?(client_id)
+    end
+
     def stopped_on_disk?
       SessionManager.stopped_on_disk?(@session_id, state_dir: @state_dir)
     end