samagotchi 0.48.0 → 0.50.0

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

@@ -4,15 +4,24 @@
 // on (a provider retry, plugins' setup) and how many turns this page saw
 // end. The DOM, the clock and the interval come in, so `node --test` drives
 // it with a fake element.
-import { elapsedSince, turnTimingText } from "./timing.js";
+import { elapsedSince, liveDurationText, turnTimingText } from "./timing.js";
 
 // The live line's text, or null when the turn's start is unknown. +inStage+:
 // the stage's status row already says the turn runs, so the line drops its
-// own "running" there.
+// own "running" there. The duration is the live one (never "0ms": under a
+// second it shows tenths).
 export function liveLineText({ number, startedAt, note = "", inStage = false }, now = Date.now()) {
   const duration = elapsedSince(startedAt, now);
   if (duration === null) return null;
-  return turnTimingText(number, duration, { running: !inStage }) + (note ? ` · ${note}` : "");
+  const turn = Number.isInteger(number) && number > 0 ? `turn ${number}` : "turn";
+  return `${turn}${!inStage ? " running" : ""} · ${liveDurationText(duration)}${note ? ` · ${note}` : ""}`;
+}
+
+// The live ticker's interval at +elapsedMs+ into the turn: 200 ms during the
+// first ten seconds (the live text counts up from the first second), then
+// the one-second tick.
+export function liveTickMs(elapsedMs) {
+  return Number(elapsedMs) < 10000 ? 200 : 1000;
 }
 
 // The record a turn-end read finishes its line with: the one with the
@@ -52,18 +61,36 @@ export function createLiveTiming({
   // the next one, so a turn queued behind another reads its own number while
   // the other's re-read is still out.
   let ended = 0;
+  // The ticker's current interval, so a tick that crossed the 10 s boundary
+  // re-arms it at the slower one.
+  let tickerMs = null;
 
   function stopTicker() {
     if (ticker !== null) {
       cancel(ticker);
       ticker = null;
+      tickerMs = null;
     }
   }
 
+  function armTicker(ms) {
+    stopTicker();
+    ticker = every(tick, ms);
+    tickerMs = ms;
+  }
+
   function tick() {
-    const text = liveLineText({ number, startedAt: timing().activeTurn?.started_at, note, inStage }, now());
+    const startedAt = timing().activeTurn?.started_at;
+    const text = liveLineText({ number, startedAt, note, inStage }, now());
     if (el && text !== null) el.textContent = text;
     onTick();
+    // The interval follows the elapsed time: 200 ms while the line counts
+    // up from the first second, one a second once it is on whole seconds.
+    if (ticker !== null) {
+      const elapsed = elapsedSince(startedAt, now());
+      const ms = elapsed === null ? tickerMs : liveTickMs(elapsed);
+      if (ms !== tickerMs) armTicker(ms);
+    }
   }
 
   return {
@@ -87,7 +114,7 @@ export function createLiveTiming({
       el.className = "turn-timing live";
       inStage = !!place(el);
       tick();
-      ticker = every(tick, 1000);
+      armTicker(liveTickMs(0));
     },
 
     tick,

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

@@ -108,6 +108,21 @@ function withTask(slot, row) {
   return row.tool === "task_wait" && row.view?.task_id ? { ...slot, taskId: row.view.task_id, key: row.key } : slot;
 }
 
+// A trail item's text and its hover: the text the (CSS-truncated) item shows,
+// and the full text it hovers. A call hovers its full command when it has
+// one, else its whole "<mark> <name> <title>" text; a flash (a hook notice)
+// hovers its whole "<mark> <text>" line.
+export function trailItemText(item) {
+  const text = `${trailMark(item.status)} ${item.name}${item.title ? ` ${item.title}` : ""}`;
+  return { text, hover: item.command || text };
+}
+
+// A trail flash's text and hover: the whole "<mark> <text>" line.
+export function trailFlashText(flash, mark) {
+  const text = `${mark} ${flash.text}`;
+  return { text, hover: text };
+}
+
 // While the first step has no thinking and no tool rows the turn is plain:
 // its text streams in the stage's answer slot, as the turn view's
 // chrome-less block streams like a bubble.

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

@@ -11,7 +11,7 @@
 // reload. Slots are patched in place, never rebuilt from HTML: a selection
 // and annotate survive. The rules are pure in stage_model.js.
 import { createTurnView } from "./turn_view.js";
-import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor, trailMark, trailTone } from "./stage_model.js";
+import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor, trailFlashText, trailItemText, trailTone } from "./stage_model.js";
 import { formatDuration } from "./timing.js";
 import { taskCommand, taskStopButton } from "./task_stop.js";
 
@@ -265,12 +265,18 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     if (shown.trail === key) return;
     shown.trail = key;
     trail.replaceChildren();
-    if (flashing) node("span", `ts-trail-item ${flashing.kind}`, trail).textContent = `${FLASH_MARKS[flashing.kind]} ${flashing.text}`;
+    if (flashing) {
+      const flash = trailFlashText(flashing, FLASH_MARKS[flashing.kind]);
+      const el = node("span", `ts-trail-item ${flashing.kind}`, trail);
+      el.textContent = flash.text;
+      el.title = flash.hover;
+    }
     for (const item of items) {
       const tone = trailTone(item.status);
       const el = node("span", `ts-trail-item${tone ? ` ${tone}` : ""}`, trail);
-      el.textContent = `${trailMark(item.status)} ${item.name} ${item.title}`.trim();
-      if (item.command) el.title = item.command;
+      const { text, hover } = trailItemText(item);
+      el.textContent = text;
+      el.title = hover;
     }
     if (!flashing && !items.length) node("span", "ts-trail-item none", trail).textContent = "no tool calls yet";
   }

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

@@ -20,6 +20,17 @@ export function turnTimingText(number, durationMs, { running = false, canceled =
   return `${turn}${running ? " running" : ""} · ${formatDuration(durationMs)}${canceled ? " · canceled" : ""}`;
 }
 
+// The LIVE line's duration: never milliseconds — under a second it shows
+// tenths ("0.0s", "0.2s"), then what formatDuration prints from 1 s on
+// (its 0.1 s precision holds to 10 s). A finished turn's line keeps
+// formatDuration exactly as it is.
+export function liveDurationText(durationMs) {
+  const ms = Number(durationMs);
+  if (!Number.isFinite(ms) || ms < 0) return "";
+  if (ms < 1000) return `${(ms / 1000).toFixed(1)}s`;
+  return formatDuration(ms);
+}
+
 // A cancel's reason as the terminal UIs name it too (Formatting::
 // 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" };

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

@@ -370,6 +370,17 @@ export function commandView(event, myId) {
   };
 }
 
+// Whether a command_ran that re-read the conversation (`resync`) needs its
+// own bubble: the redrawn history ends with a command bubble for its line
+// (a `!cmd` appends its "!(<command>)\n<output>" message, which renders as
+// one), so a second bubble would show the output twice. +historyBubbles+:
+// the `.bubble.command` elements in document order; +line+: the event's
+// line. Only the last one counts: it is the redrawn history's end.
+export function historyHasCommandBubble(historyBubbles, line) {
+  const last = historyBubbles[historyBubbles.length - 1];
+  return !!last && last.querySelector(":scope > .command-line")?.textContent === line;
+}
+
 // What a prompt_restored (the worker rolled a failed turn back and handed its
 // prompt back) does in this tab: `refill` is the text for an empty composer,
 // only for a prompt this page sent (`sentIds`, its acks' enqueued_ids), so a

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

@@ -99,6 +99,27 @@ export function stateBadgeHtml(state) {
   return BADGES[state] ? `<span class="state-badge">${escapeHtml(BADGES[state])}</span>` : "";
 }
 
+// A `!cmd`'s saved user message (the worker appends "!(<command>)\n<output>"
+// for the next turn): its command line and its output, or null when the
+// content is any other message. The command sits on the first line inside
+// `!(` `)`; the output is everything after that first newline. A message
+// that merely starts with "!" or "!(" without the newline shape is a plain
+// message.
+export function shellCommandMessage(content) {
+  const text = String(content ?? "");
+  const match = text.match(/^!\((.*)\)\n([\s\S]*)$/);
+  if (!match) return null;
+  return { line: `!${match[1]}`, text: match[2] };
+}
+
+// A `!cmd`'s history bubble: the same markup the live page draws for a
+// command (app.js's drawCommandBubble): the line, the output in a
+// pre.command-output.
+export function commandBubbleHtml({ line, text }) {
+  const body = text ? `<pre class="command-output">${escapeHtml(text)}</pre>` : "";
+  return `<div class="bubble command"><div class="command-line">${escapeHtml(line)}</div>${body}</div>`;
+}
+
 // A user's line: who sent it (+label+, a delegate report's or another
 // client's), its body (`>` lines as quotes) and +thumbs+ (its images'
 // markup), its state's badge. +message+: { content, display } (the copy

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

@@ -15,7 +15,7 @@ import { escapeHtml, failedTurnText, messageBodyHtml, noteHtml, normalize, sourc
 import { thumbsHtml } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { hookNoticeLabel } from "./turn_events.js";
-import { emptyAnswerHtml, htmlElement, toolRowHtml, toolRowInnerHtml, userBubbleHtml } from "./turn_html.js";
+import { commandBubbleHtml, emptyAnswerHtml, htmlElement, shellCommandMessage, toolRowHtml, toolRowInnerHtml, userBubbleHtml } from "./turn_html.js";
 import { cancelLineHtml, formatDuration, turnGroups, turnTimingText } from "./timing.js";
 import { createSentenceFeed } from "./sentences.js";
 import { createTicker } from "./thinking_ticker.js";
@@ -755,8 +755,14 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     const { body, renderedMarkdown } = messageBodyHtml(m);
     return `<div class="bubble output${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(m, renderedMarkdown)}>${body}</div>${timing}`;
   };
-  // A user's line, labelled when chi brought it in (a delegate report).
-  const userHtml = (m, opts = {}) => userBubbleHtml(m, { label: sourceLabel(m?.source), thumbs: thumbs(m.images), ...opts });
+  // A user's line, labelled when chi brought it in (a delegate report). A
+  // `!cmd`'s saved message (the worker's "!(<command>)\n<output>") renders
+  // as its command bubble, as live does — not as a user bubble.
+  const userHtml = (m, opts = {}) => {
+    const shell = shellCommandMessage(m?.content);
+    if (shell) return commandBubbleHtml(shell);
+    return userBubbleHtml(m, { label: sourceLabel(m?.source), thumbs: thumbs(m.images), ...opts });
+  };
   // The first text after a delegate report merged mid-turn, unless it is
   // the turn's answer (shown anyway).
   const reportReplyHtml = (i, group) => {

data/lib/samagotchi/web/session_hub.rb

@@ -307,12 +307,20 @@ module Samagotchi
         emit("session", session: summary)
       end
 
-      # One HostRegistry for the hub's lifetime: every session's ctx_pct may
+      # One HostRegistry kept across scans: every session's ctx_pct may
       # need its llm_context budget resolved, and the registry's config read
       # is what would otherwise repeat per scan and per session. Built on
-      # the first summary that needs it.
+      # the first summary that needs it, and built again when config.yml's
+      # hosts: changed (compared as read, like App#host_registry: the YAML
+      # read is mtime-cached), so a host added or a window changed while
+      # chi web runs is picked up on the next refresh of a card.
       def hub_registry
-        @hub_registry ||= HostRegistry.new
+        hosts = ConfigFile.hosts_config
+        if @hub_registry.nil? || hosts != @hub_registry_hosts
+          @hub_registry = HostRegistry.new(hosts_config: hosts)
+          @hub_registry_hosts = hosts
+        end
+        @hub_registry
       end
 
       def drop(id)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.48.0
+  version: 0.50.0
 platform: ruby
 authors:
 - Dmitry Dedov