samagotchi 0.8.1 → 0.10.0

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

@@ -0,0 +1,352 @@
+// The cards that ask the user inside the history, and their DOM (the words
+// are question_card.js'):
+//
+// ── ask_user_question card ─────────────────────────────────────────────────
+// Inline card in the message history: rendered on question_requested (or from
+// pending_question on session select for reload recovery), resolved/disabled
+// on question_answered / question_cancelled so SSE replay and answers from
+// another client converge to the same state.
+//
+// ── continue card ──────────────────────────────────────────────────────────
+// A turn ran out of iterations: continue it, drop it, or drop it saying why
+// (the terminal's continue prompt). Answers go as /continue commands; the
+// card closes on the continue_resolved every client gets.
+
+import { dismissQuestion, sendAnswer, sendCommand } from "./data.js";
+import { diffHtml } from "./diff_view.js";
+import { approvalAllowed, approvalView, nextCardAction, resultText, summaryText } from "./question_card.js";
+import { clientLabel, continueLine, isOwn } from "./turn_events.js";
+
+// @param sessionId () => the open session's id (answers go there)
+// @param clientId this tab's id in the session's events
+// @param place (card) puts a new card at the end of the history
+// @param isNearBottom () => whether the history follows its end
+// @param scrollToEnd () scrolls the history to its end
+// @param removeHintIfEmpty () drops the history's placeholder hint
+// @param api {sendAnswer, dismissQuestion, sendCommand} (data.js)
+// @param doc the page's document
+// @return {renderQuestion(pq), resolveQuestion(id, opts), removeQuestion(),
+//   questionCard() (the live card or null), pendingQuestion() (or null),
+//   renderContinue(offer), resolveContinue(data), forgetContinue()}
+export function createQuestionCards({
+  sessionId, clientId, place, isNearBottom, scrollToEnd, removeHintIfEmpty,
+  api = { sendAnswer, dismissQuestion, sendCommand }, doc = globalThis.document,
+}) {
+  // Live ask_user_question card, keyed by pending question id. Re-rendered from
+  // pending_question on session select so a reload mid-question restores it.
+  let questionEl = null;
+  let pending = null;
+  // The continue offer's card while the offer is pending.
+  let continueEl = null;
+
+  function renderQuestionCard(pq) {
+    const action = nextCardAction({ cardId: questionEl?.dataset.qid ?? null, pendingId: pending?.id ?? null }, pq);
+    if (action === "same") return;
+    // A resolved card stays where it was; only a pending one is replaced.
+    if (action === "keep") questionEl = null;
+    else removeQuestionCard();
+    pending = pq;
+    removeHintIfEmpty();
+
+    const approval = approvalView(pq);
+    const card = doc.createElement("details");
+    card.className = approval ? "bubble question approval" : "bubble question";
+    card.dataset.qid = pq.id;
+    // Open while pending: the question must be actionable.
+    card.open = true;
+
+    // The summary is the card's one line: the question (or its header) while
+    // pending, the result once resolved. It replaces the old .question-header.
+    const summary = doc.createElement("summary");
+    summary.textContent = summaryText(pq);
+    card.appendChild(summary);
+    // A hand toggle: the resolve's auto-collapse then leaves it as the user
+    // left it (rememberToggle-style, as turn_view.js does).
+    summary.addEventListener("click", () => { card.dataset.toggled = "1"; });
+
+    if (approval) {
+      card.appendChild(renderApprovalDetails(approval));
+    } else {
+      const q = doc.createElement("div");
+      q.className = "question-text";
+      q.textContent = pq.question || "";
+      card.appendChild(q);
+    }
+
+    const options = Array.isArray(pq.options) ? pq.options : [];
+    if (options.length) {
+      const list = doc.createElement("div");
+      list.className = "question-options";
+      const inputType = pq.multi_select ? "checkbox" : "radio";
+      options.forEach((label, i) => {
+        const row = doc.createElement("label");
+        row.className = "question-option";
+        const input = doc.createElement("input");
+        input.type = inputType;
+        input.name = `q-${pq.id}`;
+        input.value = String(label);
+        input.dataset.index = String(i);
+        const text = doc.createElement("span");
+        text.textContent = String(label);
+        row.appendChild(input);
+        row.appendChild(text);
+        list.appendChild(row);
+      });
+      card.appendChild(list);
+    }
+
+    let freeformInput = null;
+    if (pq.allow_freeform) {
+      freeformInput = doc.createElement("input");
+      freeformInput.type = "text";
+      freeformInput.className = "question-freeform";
+      freeformInput.placeholder = approval ? "Reason for the model (with Deny, or alone to deny)…" : "Other…";
+      card.appendChild(freeformInput);
+    }
+
+    const err = doc.createElement("div");
+    err.className = "question-error hidden";
+    card.appendChild(err);
+
+    const submit = doc.createElement("button");
+    submit.className = "question-submit";
+    submit.textContent = "Submit";
+    submit.addEventListener("click", () => {
+      const chosen = Array.from(card.querySelectorAll(".question-option input:checked")).map((i) => i.value);
+      const freeform = freeformInput ? freeformInput.value.trim() : "";
+      if (!chosen.length && !freeform) {
+        err.textContent = "Pick an option or enter a response.";
+        err.classList.remove("hidden");
+        return;
+      }
+      err.classList.add("hidden");
+      submit.disabled = true;
+      card.classList.add("submitting");
+      api.sendAnswer(sessionId(), {
+        id: pq.id,
+        selected: chosen,
+        ...(freeform ? { freeform } : {}),
+      }).catch((e) => {
+        submit.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");
+      });
+    });
+    card.appendChild(submit);
+
+    // Leaves the question unanswered, like an empty answer in the terminal.
+    // The card closes on the question_cancelled every client gets.
+    // For an approval, dismissing denies the call.
+    const dismiss = doc.createElement("button");
+    dismiss.className = "question-dismiss ghost";
+    dismiss.textContent = approval ? "Deny" : "Dismiss";
+    dismiss.addEventListener("click", () => {
+      err.classList.add("hidden");
+      submit.disabled = true;
+      dismiss.disabled = true;
+      api.dismissQuestion(sessionId(), pq.id).catch((e) => {
+        submit.disabled = false;
+        dismiss.disabled = false;
+        err.textContent = /503|not_live/.test(e.message)
+          ? "Session is not running — restart it to answer."
+          : e.message;
+        err.classList.remove("hidden");
+      });
+    });
+    card.appendChild(dismiss);
+
+    place(card);
+    questionEl = card;
+    if (isNearBottom()) scrollToEnd();
+  }
+
+  // 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) {
+    const box = doc.createElement("div");
+    box.className = "approval-details";
+    const tool = doc.createElement("div");
+    tool.className = "approval-tool";
+    tool.textContent = view.tool;
+    box.appendChild(tool);
+    if (view.what) {
+      const what = doc.createElement("pre");
+      what.className = view.isCommand ? "approval-what command" : "approval-what paths";
+      const code = doc.createElement("code");
+      code.textContent = view.what;
+      what.appendChild(code);
+      box.appendChild(what);
+    }
+    // An edit/write: the diff it would make, under the path.
+    if (view.preview) {
+      const diff = doc.createElement("div");
+      diff.className = "approval-diff";
+      diff.innerHTML = diffHtml(view.preview);
+      box.appendChild(diff);
+    }
+    for (const [cls, label, text] of [["approval-where", "in", view.where], ["approval-why", "why", view.why]]) {
+      if (!text) continue;
+      const row = doc.createElement("div");
+      row.className = cls;
+      const b = doc.createElement("span");
+      b.className = "approval-label";
+      b.textContent = `${label} `;
+      row.appendChild(b);
+      row.appendChild(doc.createTextNode(text));
+      box.appendChild(row);
+    }
+    return box;
+  }
+
+  function resolveQuestionCard(id, { answer = null, cancelled = false, reason = "" } = {}) {
+    if (!questionEl) return;
+    if (id && pending && String(pending.id) !== String(id)) return;
+    // A double-delivered question_answered / question_cancelled (SSE replay
+    // after a reconnect) is a no-op: the card is already resolved.
+    if (questionEl.classList.contains("answered") || questionEl.classList.contains("cancelled")
+      || questionEl.querySelector(".question-result")) return;
+
+    const result = resultText(pending, { answer, cancelled, reason });
+    const note = doc.createElement("div");
+    note.className = "question-result";
+    note.textContent = result;
+    if (cancelled) {
+      questionEl.classList.add("cancelled");
+    } else {
+      questionEl.classList.add("answered");
+      if (approvalAllowed(pending, answer) === false) questionEl.classList.add("denied");
+      markQuestionSelection(answer && Array.isArray(answer.selected) ? answer.selected : []);
+    }
+    questionEl.appendChild(note);
+    questionEl.classList.remove("submitting");
+    disableQuestionInputs();
+    // The summary becomes the result; the card collapses to that one line
+    // unless the user opened or closed it by hand.
+    const summary = questionEl.querySelector("summary");
+    if (summary) summary.textContent = summaryText(pending, { answer, cancelled, reason });
+    if (!questionEl.dataset.toggled) questionEl.open = false;
+    pending = null;
+  }
+
+  function markQuestionSelection(sel) {
+    if (!questionEl || !sel.length) return;
+    questionEl.querySelectorAll(".question-option input").forEach((input) => {
+      if (sel.includes(input.value)) {
+        input.checked = true;
+        input.closest(".question-option").classList.add("selected");
+      }
+    });
+  }
+
+  function disableQuestionInputs() {
+    if (!questionEl) return;
+    questionEl.querySelectorAll("input, button").forEach((el) => {
+      el.disabled = true;
+    });
+  }
+
+  function removeQuestionCard() {
+    if (questionEl) {
+      questionEl.remove();
+      questionEl = null;
+    }
+    pending = null;
+  }
+
+  // ── continue card ──────────────────────────────────────────────────────────
+  // A turn ran out of iterations: continue it, drop it, or drop it saying why
+  // (the terminal's continue prompt). Answers go as /continue commands; the
+  // card closes on the continue_resolved every client gets.
+
+  const CONTINUE_DECISIONS = {
+    resume: "Continued",
+    abort: "Not continued",
+    abort_with_reason: "Not continued (reason noted)",
+    dropped: "Dropped: a new prompt came",
+  };
+
+  function renderContinueCard(offer) {
+    if (continueEl?.isConnected) return;
+    removeHintIfEmpty();
+    const card = doc.createElement("div");
+    card.className = "bubble continue";
+    const text = doc.createElement("div");
+    text.className = "continue-text";
+    text.textContent = "The turn ran out of iterations. Continue it?";
+    card.appendChild(text);
+    const task = offer?.context?.original_prompt;
+    if (task) {
+      const ctx = doc.createElement("div");
+      ctx.className = "continue-context";
+      ctx.textContent = task;
+      card.appendChild(ctx);
+    }
+    const err = doc.createElement("div");
+    err.className = "question-error hidden";
+    const answer = (line) => {
+      err.classList.add("hidden");
+      card.querySelectorAll("button, input").forEach((el) => { el.disabled = true; });
+      api.sendCommand(sessionId(), line, { clientId }).catch((e) => {
+        card.querySelectorAll("button, input").forEach((el) => { el.disabled = false; });
+        err.textContent = e.message;
+        err.classList.remove("hidden");
+      });
+    };
+    const yes = doc.createElement("button");
+    yes.className = "continue-yes";
+    yes.textContent = "Yes";
+    yes.addEventListener("click", () => answer(continueLine("yes")));
+    const no = doc.createElement("button");
+    no.className = "continue-no ghost";
+    no.textContent = "No";
+    no.addEventListener("click", () => answer(continueLine("no")));
+    const reason = doc.createElement("input");
+    reason.type = "text";
+    reason.className = "continue-reason";
+    reason.placeholder = "Why not? (the model reads it)";
+    const noBecause = doc.createElement("button");
+    noBecause.className = "continue-no-reason ghost";
+    noBecause.textContent = "No, because…";
+    noBecause.addEventListener("click", () => {
+      if (!reason.value.trim()) return reason.focus();
+      answer(continueLine("no", reason.value));
+    });
+    const row = doc.createElement("div");
+    row.className = "continue-actions";
+    [yes, no, reason, noBecause].forEach((el) => row.appendChild(el));
+    card.appendChild(row);
+    card.appendChild(err);
+    const follow = isNearBottom();
+    place(card);
+    continueEl = card;
+    if (follow) scrollToEnd();
+  }
+
+  function resolveContinueCard(data) {
+    const card = continueEl;
+    continueEl = null;
+    if (!card) return;
+    card.classList.add("resolved");
+    card.querySelectorAll("button, input").forEach((el) => { el.disabled = true; });
+    const note = doc.createElement("div");
+    note.className = "question-result";
+    const who = isOwn(data.client_id, clientId) ? "" : ` (${clientLabel(data.client_id) || "another client"})`;
+    note.textContent = (CONTINUE_DECISIONS[data.decision] || data.decision || "Answered") + who;
+    card.appendChild(note);
+  }
+
+  return {
+    renderQuestion: renderQuestionCard,
+    resolveQuestion: resolveQuestionCard,
+    removeQuestion: removeQuestionCard,
+    questionCard: () => questionEl,
+    pendingQuestion: () => pending,
+    renderContinue: renderContinueCard,
+    resolveContinue: resolveContinueCard,
+    // The turn view was reset: a later offer draws a new card.
+    forgetContinue() { continueEl = null; },
+  };
+}

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

@@ -0,0 +1,34 @@
+// What the page knows about the open session: the info bar's fields, the
+// composer's owner check, the command list's commands and the turn timing.
+// One object, so switching sessions starts every field from here (a field
+// the previous session set, its "delegated by" parent, its commands, never
+// shows for the next one).
+
+import { normalizeTiming } from "./timing.js";
+
+export function emptySessionState() {
+  return {
+    firstPreview: "",
+    usedMemories: [],
+    // The session's --memory and --mute lists (from the session card; shown
+    // in the info bar's tooltip).
+    preloadedMemories: [],
+    mutedMemories: [],
+    // A delegated session's parent (the info bar's "delegated by" chip).
+    parentId: null,
+    ctxPct: null,
+    // Window the kernel resolved for the running generation (:generation_started).
+    ctxWindow: null,
+    status: "",
+    model: "",
+    // What the worker's server said it served for a model name: [served, asked].
+    served: null,
+    dir: "",
+    // Who holds the session: "worker" (shared), "tui" (a plain terminal chi;
+    // sending would be refused) or null.
+    owner: null,
+    // The session's commands (its worker's, plugins' too) for the / list.
+    commands: [],
+    timing: normalizeTiming(),
+  };
+}

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

@@ -21,7 +21,7 @@ export function turnTimingText(number, durationMs, { running = false, canceled =
 }
 
 // A cancel's reason as the terminal UIs name it too (Formatting::
-// CANCEL_REASONS); anything else as it is.
+// CANCEL_REASONS); anything else as it is. Both sides: spec/shared/labels_matrix.json.
 const CANCEL_REASONS = { ctrl_c: "Ctrl-C", user: "stopped", hook: "by a hook" };
 
 // The line a canceled turn ends with: "✕ canceled (stopped)", live from

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

@@ -30,6 +30,8 @@ export function isOwn(clientId, myId) {
   return clientId != null && clientId === myId;
 }
 
+// As the TUI labels them (Formatting::CLIENT_LABELS); this file's label
+// helpers and the TUI's agree per spec/shared/labels_matrix.json.
 const CLIENT_LABELS = Object.freeze({ tui: "tui", web: "web", system: "reminder", delegate: "delegate" });
 
 // The label on another client's prompt, by its client_id prefix.
@@ -220,7 +222,9 @@ export function promptOps(event, { myId, known, unmatchedMerge = false }) {
 // parts in order), then the prompts queued behind it. app.js feeds these to
 // its stream handlers, so a join renders exactly like watching live.
 // `merged_input` is the one synthetic type: a prompt merged into the turn.
-// A `notice` part carries its event as it came (TurnNotice).
+// A `notice` part carries its event as it came (TurnNotice). The TUI replays
+// a turn the same way (TurnAccumulator.replay_events); spec/shared/
+// turn_snapshot.json pins both.
 export function snapshotEvents({ current_turn: turn = null, queued = [], started_at = undefined } = {}) {
   const events = [];
   if (turn) {
@@ -249,10 +253,15 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], started
           const title = part.title ? { title: part.title } : {};
           events.push({ type: "tool_call_started", ...call, params: part.params, ...title });
           if (part.status !== "running") {
+            // The activity as the live event had it; action and duration_ms
+            // only in snapshots from a worker that keeps them (the TUI's
+            // row; the web times rows from the turn's tool records).
+            const action = part.action ? { action: part.action } : {};
             const completed = {
               type: "tool_call_completed", ...call, output: part.output, output_truncated: !!part.output_truncated,
-              activity: { status: part.status, params: part.params, ...title },
+              activity: { ...action, tool: part.tool, status: part.status, params: part.params, ...title },
             };
+            if (part.duration_ms != null) completed.duration_ms = part.duration_ms;
             if (part.diff) completed.diff = part.diff;
             events.push(withImages(completed, part.images));
           }

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

@@ -155,20 +155,6 @@ function isStep(gen) {
   return !gen.answer || !!gen.thinking || gen.tools.length > 0;
 }
 
-// One stream event into the model; null for the types it ignores.
-export function applyEvent(turn, event) {
-  switch (event?.type) {
-    case "turn_started": return turnStarted(turn);
-    case "generation_started": return generationStarted(turn, event.iteration ?? null);
-    case "generation_chunk": return chunk(turn, { text: event.text, thinking: event.thinking, iteration: event.iteration ?? null });
-    case "generation_completed": return generationCompleted(turn);
-    case "tool_call_started": return toolStarted(turn, event);
-    case "tool_call_completed": return toolCompleted(turn, event);
-    case "turn_completed": case "turn_canceled": case "turn_failed": return turnEnded(turn);
-    default: return null;
-  }
-}
-
 function cut(line) {
   return line.length > LABEL_MAX ? `${line.slice(0, LABEL_MAX).trimEnd()}…` : line;
 }

data/lib/samagotchi/web/session_hub.rb

@@ -244,7 +244,11 @@ module Samagotchi
 
         stamp = [stat.mtime, stat.size]
         changed = false
-        if stamp != entry.stamp
+        dir = Session.session_dir(id, state_dir: @state_dir)
+        dir_stamp = dir_mtime(dir)
+        # The folder changing re-reads the file too: a stop is a marker file
+        # there (Session::STOPPED_FILE), not a change to the session file.
+        if stamp != entry.stamp || dir_stamp != entry.dir_stamp
           session = Session.summary_from_file(path)
           # Corrupt, or missing a field: not a session, as Session.list has it.
           # A `chi scratch` session is never shown.
@@ -257,8 +261,6 @@ module Samagotchi
           entry.stamp = stamp
           changed = true
         end
-        dir = Session.session_dir(id, state_dir: @state_dir)
-        dir_stamp = dir_mtime(dir)
         if dir_stamp != entry.dir_stamp
           entry.dir_stamp = dir_stamp
           changed = true
@@ -304,7 +306,7 @@ module Samagotchi
       def live_stamp(owner, dir)
         return nil unless owner
 
-        { pid: owner["pid"], kind: owner["kind"], bridge_started_at: bridge_started_at(dir) }
+        { pid: owner.pid, kind: owner.kind, bridge_started_at: bridge_started_at(dir) }
       end
 
       def bridge_started_at(dir)

data/lib/samagotchi/web/session_summary.rb

@@ -18,7 +18,7 @@ module Samagotchi
       module_function
 
       # @param session [Session] a saved session (messages may be empty)
-      # @param owner [Hash, nil] SessionManager.session_owner's answer; its
+      # @param owner [OwnerLock::Owner, nil] SessionManager.session_owner's; its
       #   kind is shown as `owner`
       # @param session_dir [String] the session's folder (recap.json, bridge.json)
       # @param status [String] the turn state to show; by default
@@ -48,7 +48,7 @@ module Samagotchi
           # The session that delegated this one (the `delegate` tool), else nil.
           parent_id: session.respond_to?(:parent_id) ? session.parent_id : nil,
           first_preview: first_preview_for(session),
-          owner: owner&.fetch("kind", nil),
+          owner: owner&.kind,
           # 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.
@@ -88,7 +88,9 @@ module Samagotchi
       end
 
       # @return [Boolean] the sidecar file is there and the session has a
-      #   live owner (the file alone says nothing: the worker may be gone)
+      #   live owner (the file alone says nothing: the worker may be gone).
+      #   The owner lock, not WorkerSidecar.live's port probe: a list builds
+      #   this for every session, and the lock costs no connect.
       def bridge_up?(session_dir, owner)
         !owner.nil? && File.file?(WorkerSidecar.path(session_dir))
       rescue StandardError