samagotchi 0.16.0 → 0.17.0

data/lib/samagotchi/tools/builtins.rb

@@ -105,12 +105,20 @@ module Samagotchi
       # What execute and task_create export into the commands they run: a
       # chi started there answers as a parent agent
       # (Guardrails::ParentApprovals.parent_process?), even under a PTY
-      # wrapper. The session's id, "chi" without one.
+      # wrapper. The session's id, "chi" without one. And the model the
+      # session runs on (SAMAGOTCHI_SESSION_MODEL, read live, so right after
+      # /model), which chi self reports; unset when unknown, so a value
+      # inherited from an outer session never passes for this one.
       def parent_env(kctx)
-        id = kctx.peers.respond_to?(:session_id) ? kctx.peers.session_id.to_s : ""
-        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id }
+        peers = kctx.peers
+        id = peers.respond_to?(:session_id) ? peers.session_id.to_s : ""
+        model = peers.respond_to?(:model_ref) ? peers.model_ref.to_s : ""
+        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
+          SESSION_MODEL_ENV => model.empty? ? nil : model }
       end
 
+      SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
+
       # Stop flips the turn's controller, seen through the Engine's PeerView
       # (as DelegateWait does); a bare kernel has no peers: never cancelled.
       def cancelled_proc(kctx)

data/lib/samagotchi/tools/delegate_relay.rb

@@ -55,6 +55,10 @@ module Samagotchi
         fields = Relay.card(child, question, relay_id: relay_id, more: more)
         answer = relay.open_question(fields, watch: watch(child_id, qid, state_dir))
         settle(answer, fields, client: client, desk: desk, relay_id: relay_id, qid: qid)
+      ensure
+        # A relay that failed before it settled closes, so the desk (which
+        # prunes only settled ones) keeps none open; a settled one stays.
+        desk&.close(relay_id) if relay_id
       end
 
       # Closes the card when the child's question is no longer pending (it

data/lib/samagotchi/tools/peers.rb

@@ -7,10 +7,11 @@ module Samagotchi
     # folder, where sessions live, and whether the running turn was
     # canceled (a waiting tool returns on it), and the question flow a
     # delegate's approval is relayed through (relay: nil when this session
-    # can't host one). Engine hands KernelLoop one that follows its current
+    # can't host one), and the model the session runs on (model_ref: the
+    # resolved ref, live after /model). Engine hands KernelLoop one that follows its current
     # session (Engine::PeerView); this plain one is for specs and a kernel
     # without an Engine.
-    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, keyword_init: true) do
+    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, keyword_init: true) do
       # @return [Boolean] the turn was canceled (:cancelled is a proc or a value)
       def cancelled?
         cancelled.respond_to?(:call) ? !!cancelled.call : !!cancelled

data/lib/samagotchi/tools/task_runtime.rb

@@ -20,7 +20,7 @@ module Samagotchi
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
       # Set by chi (Builtins.parent_env); the model's env can't change it.
-      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION].freeze
+      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL].freeze
 
       module_function
 

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.16.0"
+  VERSION = "0.17.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -1059,7 +1059,8 @@ module Samagotchi
         port && BridgeClient.new(session_id: session_id, port: port, host: DEFAULT_HOST)
       end
 
-      # Read the live Engine state over the bridge (raw GET /session/:id/state).
+      # GET a read path of the session's live Bridge (+path+: "state",
+      # "snapshot", "stats", ...).
       # @return [Hash, nil] parsed JSON body, or nil when no live bridge / timeout.
       def bridge_get_json(session_id, path)
         bridge_client(session_id)&.get_json(path)

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

@@ -1,6 +1,5 @@
 import {
   listSessions,
-  createSession,
   getSession,
   sendTurn,
   cancelTurn,
@@ -37,14 +36,14 @@ import { createPromptHistory } from "./prompt_history.js";
 import { ALL_SESSIONS_HASH, sessionHash, sessionIdFromHash } from "./route.js";
 import { allScopeHref, cardFolder, projectScopeHref, scopeDir } from "./scope.js";
 import { shouldFollowScroll, keepFollowing } from "./scroll.js";
-import { stripColumns, stripShowParts } from "./strip.js";
+import { SHORT_WINDOW_QUERY, stripAutoHidden, stripColumns, stripShowParts } from "./strip.js";
 import { applySessionEvent, heldOrder, listedSessions, sortedByUpdated, waitingBadge, waitingFirst, waitingSearchText, withChildrenAfterParents } from "./sessions_list.js";
 import { createNotifications } from "./notifications.js";
 import {
   appendAboveLiveTiming, cancelLineText, elapsedSince, formatDuration, normalizeTiming, turnTimingText,
 } from "./timing.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, emptyAnswerLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isCommandLine, isOwn, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, restoreOnAck, retryStatusLine, snapshotEvents, turnOutput, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, emptyAnswerLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, restoreOnAck, retryStatusLine, snapshotEvents, turnOutput, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -1732,37 +1731,19 @@ function addCreatedSession(created) {
   render();
 }
 
-// A first message: an idle session, then the turn into it as for any
-// later one (handleSendTurn), so a failed first turn's prompt comes back
-// into the composer too (sentIds). A first command line starts the session
-// with it.
-async function handleCreate() {
-  const prompt = promptEl.value.trim();
-  if (chips.length || (prompt && !isCommandLine(prompt))) return handleSendTurn();
-  if (!prompt) return;
-  actionBtn.disabled = true;
-  try {
-    const s = await createSession(prompt, { dir: scope.dir, model: chosenModel() });
-    addCreatedSession(s);
-    select(s.id);
-    promptEl.value = "";
-    fitPrompt();
-    refreshHistory();
-  } catch (e) {
-    alert(e.message);
-  } finally {
-    actionBtn.disabled = false;
-  }
+// A first message: an idle session, then the turn (or the command) into it
+// as for any later one (handleSendTurn), so a failed first turn's prompt
+// comes back into the composer too (sentIds).
+function handleCreate() {
+  return handleSendTurn();
 }
 
 async function handleSendTurn() {
-  if (!selected && !chips.length && isCommandLine(promptEl.value.trim())) return handleCreate();
   if (current.owner === "tui") return;
   const prompt = turnText(promptEl.value, chips);
   if (!prompt) return;
   // An image-only send's text is its placeholders: not for ↑.
   const typed = promptEl.value.trim() !== "";
-  if (!chips.length && isCommandLine(prompt)) return handleSendCommand(prompt);
   if (!selected) {
     actionBtn.disabled = true;
     try {
@@ -1776,6 +1757,9 @@ async function handleSendTurn() {
       actionBtn.disabled = false;
     }
   }
+  // A session command by the session's list (the new one's too: select
+  // read it); an unknown /word is a prompt, as in a terminal.
+  if (!chips.length && sessionCommandLine(prompt, current.commands)) return handleSendCommand(prompt);
   const hint = historyEl.querySelector(".hint");
   if (hint) hint.remove();
   // Sending moves a finished turn out of the stage at once (else the echo
@@ -1795,6 +1779,15 @@ async function handleSendTurn() {
       if (!chip.ref) chip.ref = await uploadImage(selected, chip.file, chip.name);
     }
     const ack = await sendTurn(selected, prompt, { clientId, images: turnRefs(sending), history: typed });
+    if (ack?.command_id) {
+      // The worker knew it as a command (its list was newer than ours):
+      // its command_ran shows it, not a prompt bubble.
+      echo.remove();
+      promptEl.value = "";
+      fitPrompt();
+      if (!streamControl?.live) startStream(selected, selectSeq ?? 0);
+      return;
+    }
     if (ack?.enqueued_id) sentIds.add(ack.enqueued_id);
     refreshHistory();
     // A turn that failed fast was restored before this ack: its prompt
@@ -2247,11 +2240,27 @@ function stripHiddenSaved() {
     return false;
   }
 }
+// A short window hides the strip by itself, so the stage keeps room for a
+// card that waits (its question and choices); the sessions pill brings it
+// back until the window is tall again. Not saved: the saved choice is the
+// user's own hide ▴ / show.
+const shortWindow = window.matchMedia(SHORT_WINDOW_QUERY);
+let stripShownWhileShort = false;
+function applyStripHidden() {
+  document.body.classList.toggle("strip-hidden", stripAutoHidden({
+    saved: stripHiddenSaved(), short: shortWindow.matches, shownWhileShort: stripShownWhileShort,
+  }));
+}
 function setStripHidden(hidden) {
   try { localStorage.setItem("chi_strip_hidden", hidden ? "1" : "0"); } catch (_) {}
-  document.body.classList.toggle("strip-hidden", hidden);
+  stripShownWhileShort = !hidden && shortWindow.matches;
+  applyStripHidden();
 }
-setStripHidden(stripHiddenSaved());
+applyStripHidden();
+shortWindow.addEventListener("change", () => {
+  if (!shortWindow.matches) stripShownWhileShort = false;
+  applyStripHidden();
+});
 $("#stripShow").addEventListener("click", () => setStripHidden(false));
 
 $("#filter").addEventListener("input", renderAll);

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

@@ -31,9 +31,13 @@ export function waitingOn(summary) {
 }
 
 // How long a delegated child's new approval waits before it notifies: its
-// parent relays it within a poll or two when it waits on the child, and
-// then the parent's card notifies instead (one bell, not two).
-export const RELAY_HOLD_MS = 1500;
+// parent relays it when it waits on its children, and then the parent's
+// card notifies instead (one bell, not two). A child the parent isn't
+// waiting on directly is seen by its look at the others (DelegateRelay
+// OTHERS_EVERY, 2 s), and the relay reaches the page with the hub's next
+// scan (SessionHub SCAN_INTERVAL, 1 s): up to ~3 s. Only these approvals
+// wait; a child's approval nobody relays rings this late.
+export const RELAY_HOLD_MS = 3500;
 
 // What changed between two summaries of one session that needs the user.
 // @param prev the summary held before (null for a session not seen yet)

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

@@ -185,37 +185,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,19 @@ 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} `)));
 }
 
 // The terminal's own commands (a button in the web, or none yet): the

data/lib/samagotchi/worker.rb

@@ -173,7 +173,7 @@ module Samagotchi
           absorb_notes
 
           if (prompt = take_initial_prompt)
-            run_prompt(prompt, nil)
+            run_prompt(prompt, nil) unless initial_command(prompt)
             next
           end
 
@@ -269,6 +269,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 +316,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

data/lib/samagotchi/worker_sidecar.rb

@@ -42,7 +42,10 @@ module Samagotchi
       return nil unless sidecar&.port&.positive?
 
       begin
-        Socket.tcp(host, sidecar.port, connect_timeout: timeout).close
+        # 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.
+        TCPSocket.new(host, sidecar.port, connect_timeout: timeout).close
         sidecar
       rescue StandardError
         FileUtils.rm_f(path(session_dir)) if unlink

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -137,6 +137,7 @@ files:
 - docs/releasing.md
 - docs/sessions.md
 - docs/sub-agent.md
+- docs/testing.md
 - lib/samagotchi.rb
 - lib/samagotchi/answer_command.rb
 - lib/samagotchi/answer_display.rb
@@ -280,6 +281,7 @@ files:
 - lib/samagotchi/memory_bundle/source.rb
 - lib/samagotchi/memory_bundle/status.rb
 - lib/samagotchi/memory_bundle/system_bundle.rb
+- lib/samagotchi/memory_bundle/trash.rb
 - lib/samagotchi/memory_bundle/uninstaller.rb
 - lib/samagotchi/memory_paths.rb
 - lib/samagotchi/model_catalog.rb