samagotchi 0.44.0 → 0.45.0

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

@@ -302,6 +302,8 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .note-text{white-space:pre-wrap;max-height:8em;overflow:auto}
 .bubble.command.busy{border-left-color:var(--warn)}
 .bubble.command.failed{border-left-color:var(--danger)}
+.bubble.command.queued{border-left-style:dashed}
+.bubble.command.queued .command-output{color:var(--text-faint)}
 .command-line{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-3)}
 .command-output{margin:6px 0 0;white-space:pre-wrap;font-size:12px;color:var(--text-2)}
 .bubble.continue{border-left:3px solid var(--accent);background:var(--bg-panel);padding:10px 12px}
@@ -612,7 +614,7 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 .ts-trail-item:is(.error,.blocked){color:var(--danger-text)}
 .ts-trail-item.warn{color:var(--warn-text)}
 .ts-trail-item.stopped{color:var(--warn-text);opacity:.8}
-.ts-trail-item.info,.ts-trail-item.steer{color:var(--accent)}
+.ts-trail-item.info,.ts-trail-item.steer,.ts-trail-item.edit{color:var(--accent)}
 .ts-trail-item.none{font-style:italic}
 /* A card waits: the tool row and trail give it their room. */
 .turn-stage.waiting .ts-now,.turn-stage.waiting .ts-trail{display:none}

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

@@ -179,9 +179,9 @@ export function formHtml(summary, escapeHtml, { running = false, kind = SESSION,
     `<label class="llmctx-field"><span>Budget</span><input name="budget" type="text" inputmode="numeric" autocomplete="off" ` +
     `placeholder="follow the model (64000, 64k or off)" value="${escapeHtml(own.budget)}"></label>` +
     `<div class="ctx-pop-error llmctx-error" hidden></div>` +
-    `<div class="ctx-pop-meta">${when}${running ? " A turn is running: set it when it ends." : ""}</div>` +
+    `<div class="ctx-pop-meta">${when}${running ? " A turn is running: it applies after this turn." : ""}</div>` +
     `<div class="ctx-pop-actions"><button type="button" class="ctx-pop-detach" data-act="reset">follow the model</button>` +
-    `<button type="submit" class="llmctx-set"${running ? " disabled" : ""}>Set</button></div></form>`;
+    `<button type="submit" class="llmctx-set">Set</button></div></form>`;
 }
 
 const EDGE = 16;
@@ -263,8 +263,6 @@ export function createLlmContextControl({ el, escapeHtml, summary, session = ()
     if (!data || session() !== openFor) return close();
     const now = pop.querySelector(".llmctx-now");
     if (now) now.textContent = nowText(data);
-    const set = pop.querySelector(".llmctx-set");
-    if (set) set.disabled = running();
   }
 
   el.addEventListener("click", (e) => {

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

@@ -198,15 +198,29 @@ export function handOffOrder({ prompt = null, block = null, extras = [], answer
 // history (it is idle-only).
 // What flashes in the trail for a few seconds while the turn runs (the
 // rows themselves go into their step inside the closed cloud): a hook's
-// notice, warn or info, as its row reads, and a plugin's nudge (steer).
-// chi's own asking-again row (a notice with a line and no hook) does not:
-// the status line tells that already. null: nothing flashes.
+// notice, warn or info, as its row reads, the ✂ row of an applied LLM
+// context edit (kind "edit"), a steer-cut row (a message cut in on a
+// thinking-only generation; kind "steer"), and a plugin's nudge (steer).
+// The row's leading mark ("✂ ", "↪ ") goes: FLASH_MARKS's stands in.
+// chi's own asking-again row (a notice with a line and no hook or cls)
+// does not: the status line tells that already. null: nothing flashes.
+// A hookless notice's cls names its flash: [cls, trail kind, the leading
+// mark the line loses].
+const HOOKLESS_FLASH = [
+  ["llm-context", "edit", /^✂ /],
+  ["steer-cut", "steer", /^↪ /],
+];
 export function flashOf(what, data = {}) {
   if (what === "steer") {
     const sender = steerSender(data.source);
     return { kind: "steer", text: sender ? `${sender} nudged the model` : "nudged the model" };
   }
-  if (what !== "notice" || !data.hook) return null;
+  if (what !== "notice") return null;
+  if (!data.hook) {
+    const flash = HOOKLESS_FLASH.find(([cls]) => cls === data.cls);
+    if (!flash || !data.line) return null;
+    return { kind: flash[1], text: data.line.replace(flash[2], "") };
+  }
   return { kind: data.level === "warn" ? "warn" : "info", text: data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}` };
 }
 

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

@@ -28,9 +28,9 @@ const PENDING = ".bubble.question:not(.answered):not(.cancelled), .bubble.contin
 // and never holds the hand-off (a turn cut short can leave it open).
 const ASKS = ".plugin-card[data-in-turn] .card-action";
 const MARKS = { answered: "✓", "no answer": "∅", canceled: "■", failed: "✕" };
-// The mark of a flash in the trail: a warn notice, a hook's info notice, a
-// plugin's nudge (steer).
-const FLASH_MARKS = { warn: "⚠", info: "ℹ", steer: "↪" };
+// The mark of a flash in the trail: a warn notice, a hook's info notice,
+// an applied LLM context edit (✂), a steer-cut row and a plugin's nudge (↪).
+const FLASH_MARKS = { warn: "⚠", info: "ℹ", edit: "✂", steer: "↪" };
 
 function node(tag, cls, parent = null) {
   const el = document.createElement(tag);

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

@@ -339,18 +339,26 @@ export function continueLine(choice, reason = "") {
 // tab's own), `resync` says the conversation changed (!rollback, !cmd, a
 // continue answered no) and must be read again. An anytime command's
 // (`anytime`, D8) bubble is drawn at its command_queued, before the cards
-// it shows; its command_ran fills that bubble in (`commandId`).
+// it shows; its command_ran fills that bubble in (`commandId`). So is a
+// command queued for after the running turn (`queued`): its command_queued
+// (waits: "turn_end") draws it `waiting`, saying so, until it ran or was
+// dropped (styled as failed).
+export const QUEUED_TEXT = "queued: runs after this turn";
+
 export function commandView(event, myId) {
   const own = isOwn(event.client_id, myId);
+  const waiting = event.waits === "turn_end";
   return {
     label: own ? null : clientLabel(event.client_id),
     line: event.line || "",
-    text: event.output || "",
+    text: event.output || (waiting ? QUEUED_TEXT : ""),
     busy: event.status === "busy",
-    failed: event.status === "error",
+    failed: event.status === "error" || event.status === "dropped",
     resync: (event.changed || []).includes("messages"),
     modelName: event.model_name || null,
     anytime: event.anytime === true,
+    queued: waiting || event.queued === true,
+    waiting,
     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",
@@ -498,7 +506,7 @@ export function replaysDrawnTurn(event, turnRecords = []) {
 // 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 } = {}) {
+export function snapshotEvents({ current_turn: turn = null, queued = [], queued_commands: commands = [], started_at = undefined } = {}) {
   const events = [];
   if (turn) {
     events.push(withImages({ type: "turn_started", prompt: turn.prompt, origin: turn.origin, continue: !!turn.continue, started_at }, turn.images));
@@ -576,6 +584,10 @@ export function snapshotEvents({ current_turn: turn = null, queued = [], started
   for (const entry of queued || []) {
     events.push(withImages({ type: "turn_enqueued", enqueued_id: entry.enqueued_id, client_id: entry.client_id, prompt: entry.prompt }, entry.images));
   }
+  // Commands waiting for the turn's end: their bubbles, as live.
+  for (const entry of commands || []) {
+    events.push({ type: "command_queued", command_id: entry.command_id, client_id: entry.client_id, line: entry.line, waits: "turn_end" });
+  }
   return events;
 }
 

data/lib/samagotchi/web/session_hub.rb

@@ -297,7 +297,7 @@ module Samagotchi
 
         entry.owner = owner
         entry.live = live
-        summary = SessionSummary.build(entry.session, owner: owner, session_dir: dir)
+        summary = SessionSummary.build(entry.session, owner: owner, session_dir: dir, registry: hub_registry)
         # A new worker (pid) or a new Bridge for the same session is an
         # event for the page even when the summary reads the same: it
         # reconnects its stream on it.
@@ -307,6 +307,14 @@ module Samagotchi
         emit("session", session: summary)
       end
 
+      # One HostRegistry for the hub's lifetime: 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.
+      def hub_registry
+        @hub_registry ||= HostRegistry.new
+      end
+
       def drop(id)
         entry = @sessions.delete(id)
         emit("session_gone", id: id) if entry&.summary

data/lib/samagotchi/web/session_summary.rb

@@ -4,6 +4,8 @@ require_relative "../session"
 require_relative "../recap_store"
 require_relative "../archive_store"
 require_relative "../session_metrics"
+require_relative "../llm_context_strategy"
+require_relative "../host_registry"
 require_relative "../bridge_client"
 require_relative "../worker_sidecar"
 require_relative "../bridge/pending_card"
@@ -26,12 +28,18 @@ module Samagotchi
       # @param root_cache [Hash, nil] ProjectScope.root_for's cache, shared
       #   across one listing (a session saved before project_root existed
       #   looks its project up)
+      # @param registry [HostRegistry, nil] the hosts to resolve the
+      #   session's llm_context budget against (its ctx_pct counts against
+      #   the smaller of that budget and the window, as the live meter
+      #   does). nil: one is built here; a caller that builds many summaries
+      #   (the session hub) keeps one and passes it.
       # @return [Hash] symbol keys
-      def build(session, owner:, session_dir:, status: displayed_status(session, owner: owner), root_cache: nil)
+      def build(session, owner:, session_dir:, status: displayed_status(session, owner: owner), root_cache: nil,
+                registry: nil)
         used = Array(session.used_memory_names)
         up = bridge_up?(session_dir, owner)
         sidecar = up ? WorkerSidecar.read(session_dir) : nil
-        saved = SessionMetrics.saved_summary(session_dir)
+        saved = SessionMetrics.saved_summary(session_dir, budget_tokens: budget_resolver(session, registry))
         {
           id: session.id,
           status: status,
@@ -86,6 +94,15 @@ module Samagotchi
         }
       end
 
+      # The budget resolver SessionMetrics.saved_summary takes: a callable,
+      # so the session's llm_context budget (config + the registry's index,
+      # no network) is resolved only for a session that has a saved context
+      # to count. One registry per caller (the hub) or one built here.
+      def budget_resolver(session, registry)
+        -> { LLMContextStrategy.session_budget(session, registry: registry ||= HostRegistry.new) }
+      end
+      private_class_method :budget_resolver
+
       # 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

@@ -59,6 +59,8 @@ 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"
+    # !rollback mid-turn would mean "the turn I'm in".
+    ROLLBACK_BUSY_OUTPUT = "busy: Ctrl-C the turn first, then !rollback"
 
     # 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
@@ -184,7 +186,10 @@ module Samagotchi
       # queued while that turn ran.
       @turn_end_seq = 0
       @engine.subscribe(observer: lambda { |event|
-        @turn_end_seq = event[:event_seq] if Events::TURN_END.include?(event[:type])
+        if Events::TURN_END.include?(event[:type])
+          @turn_end_seq = event[:event_seq]
+          @turn_end_type = event[:type]
+        end
         @turn_id = event[:turn_id] if event[:type] == :turn_started
         ring_question(event) if event[:type] == :question_requested
       })
@@ -198,7 +203,9 @@ module Samagotchi
                                    context_absorber: @context_absorber, wakes: @wakes,
                                    awaiting_continue: -> { @turn_flow.awaiting_continue? },
                                    stopped: -> { stopped_on_disk? },
-                                   queue_command: ->(line, client_id) { @bridge.queue_command(line, client_id: client_id) })
+                                   queue_command: lambda { |line, client_id, after_file|
+                                     @bridge.queue_command(line, client_id: client_id, after_file: after_file)
+                                   })
       # /model's default is the config's, as in the REPL; the Engine started
       # on the session's model.
       @default_model = ModelProfile.required_model_name(nil)
@@ -215,14 +222,7 @@ module Samagotchi
     def serve
       @bridge = SessionManager.start_bridge(engine: @engine, state_dir: @state_dir, session_id: @session_id,
                                             on_input: -> { @waker.wake },
-                                            on_command: lambda { |command|
-                                              next start_anytime_command(command) if anytime_command?(command[:line])
-
-                                              # Called with the event log held: the
-                                              # count says which turn ends came before it.
-                                              @command_queue << command.merge(after_seq: @engine.event_count)
-                                              @waker.wake
-                                            },
+                                            on_command: method(:on_command),
                                             on_exit_request: method(:exit_request),
                                             # Decided again as it leaves (a note may still come in).
                                             exit_discards: method(:empty_session?))
@@ -307,6 +307,9 @@ module Samagotchi
         # A stop between two queued turns leaves the rest queued.
         break if stopped_on_disk?
 
+        # Commands that came before this file (D1: a queued /model X sent
+        # before this prompt, a command an earlier file carried) run first.
+        run_queued_commands
         @inbound.absorb_notes
         run_input_file(input_file)
       end
@@ -334,6 +337,7 @@ module Samagotchi
     # group) before the Engine does.
     def teardown
       @context_poller&.stop
+      drop_queued_commands
       @engine&.shutdown
       @bridge&.stop
       # The process exits next: a parent wake it rang for (a crash's
@@ -549,29 +553,122 @@ module Samagotchi
 
     def max_iterations(no_interrupt) = IterationLimit.for(no_interrupt: no_interrupt)
 
+    # The queued commands that may run now, in order, up to one whose
+    # after_file (D1) still waits in the inbox: it and those behind it stay
+    # queued.
     # @return [Boolean] whether any command ran
     def run_queued_commands
       ran = false
-      while (command = next_command)
+      while (command = next_ready_command)
         run_command(command)
         ran = true
       end
       ran
     end
 
-    # A command queued while a turn ran is refused (S1), not run after it:
+    # Pops the first queued command if it may run now (its after_file is
+    # taken), else none: one behind it waits too, in arrival order (an idle
+    # /model Y that came just after the turn ended stays behind a /model X
+    # still waiting for a prompt sent before it). With the event log held,
+    # as the Bridge queues.
+    def next_ready_command
+      return nil if @command_queue.empty?
+
+      @engine.synchronize_events do
+        commands = drain_commands
+        first = commands.first
+        ready = first && ready_command?(first) ? commands.shift : nil
+        commands.each { |command| @command_queue << command }
+        ready
+      end
+    end
+
+    def ready_command?(command)
+      return true if command[:after_file].nil?
+
+      SessionInbox.find_new_input_files(@session_dir).none? { |path| File.basename(path) <= command[:after_file] }
+    end
+
+    def drain_commands
+      commands = []
+      while (command = next_command)
+        commands << command
+      end
+      commands
+    end
+
+    # A command a turn refuses (:refuse while it ran, S1) is answered busy:
     # at the turn's iteration boundaries (mid_turn: all of them), and when
     # it ends (the ones queued before its end event; later ones run next).
+    # A queued one (:queue) stays for after the turn, but a !cmd after a
+    # canceled or failed turn (D4): running it would close the rollback
+    # window the turn left, so it is dropped. With the event log held, so
+    # a command the Bridge queues meanwhile stays behind the ones kept, in
+    # arrival order. One that comes after the empty look is the next
+    # boundary's (or end's), as it would be.
     def refuse_queued_commands(mid_turn: false)
-      later = []
-      while (command = next_command)
-        if mid_turn || command[:after_seq].to_i < @turn_end_seq
-          announce_command(command, status: "busy", output: BUSY_OUTPUT, changed: [])
-        else
-          later << command
+      return if @command_queue.empty?
+
+      @engine.synchronize_events do
+        drain_commands.each do |command|
+          during = mid_turn || command[:after_seq].to_i < @turn_end_seq
+          case (during ? turn_answer(command, ended: !mid_turn) : :keep)
+          when :refuse then announce_command(command, status: "busy", output: busy_output(command), changed: [])
+          when :drop then drop_command(waiting_for_turn_end(command), "turn #{@turn_end_type == :turn_failed ? "failed" : "canceled"}: " \
+                                                                      "#{command[:line]} not run; send it again")
+          else @command_queue << (during ? waiting_for_turn_end(command) : command)
+          end
         end
       end
-      later.each { |command| @command_queue << command }
+    end
+
+    # What a turn does with +command+, queued while it ran: :refuse, :drop
+    # (D4, once it +ended+) or :keep. One queued idle just as the turn
+    # began (:loop) goes by its line's policy (a show form waits too).
+    def turn_answer(command, ended:)
+      policy = command[:mid_turn]
+      policy = @engine.command_registry.mid_turn(command[:line]) if policy == :loop
+      return :refuse if policy == :refuse
+      return :drop if ended && policy == :queue && shell_command?(command) &&
+                      %i[turn_canceled turn_failed].include?(@turn_end_type)
+
+      :keep
+    end
+
+    # +command+, kept for after the turn. One queued idle just as the turn
+    # began (:loop) whose line waits for a turn's end (/model X, !cmd) is
+    # marked as one queued mid-turn: its command_queued (waits) tells the
+    # UIs now, and its command_ran says queued.
+    def waiting_for_turn_end(command)
+      return command unless command[:mid_turn] == :loop && @engine.command_registry.mid_turn(command[:line]) == :queue
+
+      event = { type: :command_queued, **command.slice(:command_id, :client_id, :line), waits: "turn_end" }
+      event[:card] = true if command[:card]
+      @engine.announce(event)
+      command.merge(mid_turn: :queue)
+    end
+
+    def shell_command?(command) = @engine.command_registry.lookup(command[:line])&.id == :shell
+
+    def busy_output(command)
+      @engine.command_registry.lookup(command[:line])&.id == :rollback ? ROLLBACK_BUSY_OUTPUT : BUSY_OUTPUT
+    end
+
+    # +command+ won't run: its sender (a UI's queued bubble) is told.
+    def drop_command(command, output)
+      announce_command(command, status: "dropped", output: output, changed: [])
+    end
+
+    # The worker leaves with commands still queued (a stop, a crash): each
+    # one's sender is told it won't run, so no UI shows it waiting for good.
+    def drop_queued_commands
+      return if @command_queue.nil? || @command_queue.empty? || @engine.nil?
+
+      @engine.synchronize_events do
+        drain_commands.each { |command| drop_command(command, "dropped: the session's worker stopped before it ran") }
+      end
+    rescue StandardError => e
+      Log.warn(:worker, "drop_commands_failed", error: e.class.name, msg: e.message)
     end
 
     def next_command
@@ -607,7 +704,44 @@ module Samagotchi
       [result || SessionCommands::Result.new(status: :error, output: "not a session command", changed: []), shown]
     end
 
-    def anytime_command?(line) = @engine.command_registry.lookup(line)&.anytime == true
+    # A session command from the Bridge, called with the event log held:
+    # an anytime one starts now, any other is queued for the loop (and
+    # refused if a turn runs: #refuse_queued_commands). While a turn runs
+    # the line's policy decides (a show form like /model runs now); idle,
+    # only an always-anytime command (/help) runs beside the loop, so an
+    # idle /model X then /model run in order. A turn starting or ending
+    # right now may see the other side: the line is only shown early or
+    # run in order.
+    #
+    # A queued one (:queue) keeps arrival order with the prompts (D1): it
+    # runs once every input file written before it is taken (after_file,
+    # the newest one now; names compare, not clocks), so a prompt sent
+    # before it runs first and one sent after it runs after. One that came
+    # in an input file runs once that file is taken (+after_file+).
+    # @return [Symbol] the policy it applied (the Bridge marks an anytime
+    #   one's command_queued, and a queued one's): :anytime, :queue or
+    #   :refuse while a turn runs, :loop idle
+    def on_command(command, after_file: nil)
+      registry = @engine.command_registry
+      policy = if @engine.turn_running? then registry.mid_turn(command[:line])
+               else registry.anytime?(command[:line]) ? :anytime : :loop
+               end
+      if policy == :anytime
+        start_anytime_command(command)
+        return policy
+      end
+
+      after_file ||= newest_input_file if policy == :queue
+      # The count says which turn ends came before it.
+      @command_queue << command.merge(after_seq: @engine.event_count, mid_turn: policy, after_file: after_file).compact
+      @waker.wake
+      policy
+    end
+
+    # @return [String, nil] the newest input file waiting (its basename)
+    def newest_input_file
+      SessionInbox.find_new_input_files(@session_dir).map { |path| File.basename(path) }.max
+    end
 
     # An anytime command (/help, a plugin's /btw; D8) runs now, on its own
     # thread, never queued behind a turn: it is never busy. The Bridge calls
@@ -640,6 +774,8 @@ 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
+      # Its line was shown at its command_queued (waits: turn_end).
+      event[:queued] = true if command[:mid_turn] == :queue
       event[:card] = true if command[:card]
       # /llm-context or /model: what the next turn runs under now (the web's chip).
       event[:llm_context] = @engine.llm_context_summary if changed.intersect?(%i[llm_context model])

data/lib/samagotchi/worker_inbound.rb

@@ -61,8 +61,9 @@ module Samagotchi
     # @param wakes [WorkerWakes] the wake budget a context wake asks
     # @param awaiting_continue [#call] whether a continue offer waits
     # @param stopped [#call] whether the session was stopped on disk
-    # @param queue_command [#call] (line, client_id) queues a session
-    #   command for the loop's next pass
+    # @param queue_command [#call] (line, client_id, after_file) queues a
+    #   session command for the loop's next pass; after_file is the input
+    #   file it came in, or nil
     def initialize(session:, state_dir:, session_dir:, engine:, context_absorber:, wakes:, awaiting_continue:,
                    stopped:, queue_command:)
       @session = session
@@ -182,7 +183,7 @@ module Samagotchi
       begin
         message, origin, no_interrupt, images = SessionInbox.read_input(claimed_file)
         return if message.to_s.strip.empty?
-        return if Array(images).empty? && queue_as_command(message, origin)
+        return if Array(images).empty? && queue_as_command(message, origin, File.basename(input_file))
 
         yield Prompt.new(text: message, origin: origin, no_interrupt: !!no_interrupt, images: images || [])
       ensure
@@ -211,10 +212,10 @@ module Samagotchi
     # 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)
+    def queue_as_command(text, origin, after_file = nil)
       return false unless @engine.command_registry.command?(text.to_s)
 
-      @queue_command.call(text, origin&.dig(:client_id))
+      @queue_command.call(text, origin&.dig(:client_id), after_file)
       true
     end
 

metadata

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