samagotchi 0.44.0 → 0.45.0

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -126,6 +126,10 @@ module Samagotchi
         @early_lines = []
         @question = nil
         @answered_ids = Set.new
+        # Commands queued for after the running turn, any UI's: a /archive
+        # typed during the turn waits for them too (#archive_due?).
+        @queued_ids = Set.new
+        @archive_after_turn = false
         @reader = nil
         @first_prompt = first_prompt
         @first_commands = Array(first_command)
@@ -188,6 +192,7 @@ module Samagotchi
           when :event
             ended = safely_handle(payload)
             return ended if %i[closed failed unanswered].include?(ended)
+            return archive_now if archive_due?
 
             ended = take_early_lines
             return ended if ended
@@ -264,9 +269,11 @@ module Samagotchi
         when :answer_display then @display_pending = false
         when :context_status, :used_memories_updated then @status.take_event(event)
         # Another client's anytime command: its line now, before the cards
-        # it shows (its command_ran comes when it's done).
+        # it shows (its command_ran comes when it's done). One queued for
+        # after the turn says so now.
         when :command_queued
           @screen.commit(prompt_line(event[:client_id], event[:line])) if event[:anytime] && !own?(event[:client_id]) && !event[:card]
+          command_waits(event) if event[:waits] && !event[:card]
         when :command_ran
           command_ran(event)
           return first_command_ran(event) if @first_command_id && event[:command_id] == @first_command_id
@@ -379,6 +386,7 @@ module Samagotchi
         local = command_registry.lookup_local(text)&.id
         return submit(nil) if local == :detach
         return SessionCommands.delete_on_exit?(text) ? exit_and_delete : exit_worker if local == :exit
+        return archive_after_turn if local == :archive && (@running || !@queued_ids.empty?)
         return exit_and_archive if local == :archive
 
         if @continue_offer
@@ -446,6 +454,24 @@ module Samagotchi
         detach("Detached; the worker is stopping, but session #{id} was not deleted (#{e.message}): chi sessions delete #{id}")
       end
 
+      # /archive during a turn (D2): it waits for the turn's end and the
+      # commands queued behind it (#archive_due?), then runs.
+      # @return [nil]
+      def archive_after_turn
+        @archive_after_turn = true
+        @screen.commit("(archives after this turn)")
+        nil
+      end
+
+      def archive_due? = @archive_after_turn && !@running && @queued_ids.empty?
+
+      # @return [Symbol] :detached
+      def archive_now
+        @archive_after_turn = false
+        exit_and_archive
+        :detached
+      end
+
       # /archive: the worker is asked to exit as for /exit, then the session
       # is archived. A worker staying up for another UI (or reminders) is
       # stopped by the archive, as the web's archive stops it; a turn
@@ -546,13 +572,36 @@ module Samagotchi
         "worker unreachable: #{head.downcase}"
       end
 
+      QUEUED_NOTE = "(queued: runs after this turn)"
+
+      # A command queued for after the running turn (command_queued with
+      # waits): its line now (another client's) and a note; its command_ran
+      # has no line again (queued: true).
+      def command_waits(event)
+        @queued_ids << event[:command_id]
+        if own?(event[:client_id])
+          first = event[:command_id] == @first_command_id
+          return @screen.commit(first ? first_command_queued : QUEUED_NOTE)
+        end
+
+        @screen.commit("#{prompt_line(event[:client_id], event[:line])} #{QUEUED_NOTE}")
+      end
+
+      def first_command_queued
+        flag = @first_command_line.to_s.start_with?("/model") ? "--model" : "--llm-context"
+        "(#{flag} queued: applies after the running turn)"
+      end
+
       def command_ran(event)
         @open_ids.delete(event[:command_id])
-        @screen.commit(prompt_line(event[:client_id], event[:line])) unless own?(event[:client_id]) || event[:anytime] || event[:card]
+        @queued_ids.delete(event[:command_id])
+        unless own?(event[:client_id]) || event[:anytime] || event[:card] || event[:queued]
+          @screen.commit(prompt_line(event[:client_id], event[:line]))
+        end
         output = event[:output].to_s
         if output.empty?
           nil
-        elsif event[:status] == "busy" || PromptHistory.shell_line?(event[:line])
+        elsif %w[busy dropped].include?(event[:status]) || PromptHistory.shell_line?(event[:line])
           @screen.commit(output)
           put_back_busy_command(event) if event[:status] == "busy"
         else
@@ -992,6 +1041,14 @@ module Samagotchi
           @shown_enqueued << entry[:enqueued_id]
           @screen.commit("queued #{prompt_line(entry[:client_id], entry[:prompt])}")
         end
+        # Commands waiting for the turn's end (their command_ran prints no
+        # line); a resync prints only the ones it hadn't shown.
+        shown = @queued_ids.dup
+        @queued_ids.clear
+        Array(snapshot[:queued_commands]).each do |entry|
+          @queued_ids << entry[:command_id]
+          @screen.commit("queued #{prompt_line(entry[:client_id], entry[:line])}") unless shown.include?(entry[:command_id])
+        end
         return send_first_command unless @first_commands.empty?
 
         send_first_prompt
@@ -1076,10 +1133,18 @@ module Samagotchi
         Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
         from = messages.index { |m| m.equal?(exchange[last_user]) }
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
+        failed = join_failed_record(exchange[last_user])
         # A turn that ended with no answer: its notice, as live.
         empty = messages.drop(from + 1).filter_map { |m| TurnNote.empty_answer(m) }.last
         if empty
           @screen.commit(format_empty_answer_line(empty[:retries] || empty["retries"]))
+        elsif failed
+          # A failed turn whose steps stayed: the line the live view left,
+          # and no step text as if it were the answer (the web keeps a
+          # failed turn's texts as steps too).
+          failure = failed["failure"]
+          @screen.commit(@view.turn_failed_line(failure["summary"] || failure["message"], failed["duration_ms"]))
+          @screen.commit(@view.turn_end_hint(ROLLBACK_HINT)) if failure["kept_steps"]
         else
           # The saved answer is raw: the latest keeps its thinking, and one may
           # be only a tool call.
@@ -1119,6 +1184,23 @@ module Samagotchi
         []
       end
 
+      # The turn's saved record when it failed with the fields its line is
+      # made of (SessionMetrics#failure_fields), else nil: a completed,
+      # canceled or older turn — or one saved before the failure field —
+      # draws its answer as before.
+      def join_failed_record(prompt)
+        record = SessionMetrics.saved_turn_record(Session.session_dir(@client.session_id),
+                                                  prompt[:turn_id] || prompt["turn_id"])
+        return nil unless record && record["status"] == "failed" && record["failure"].is_a?(Hash)
+
+        failure = record["failure"]
+        return nil if failure["summary"].to_s.empty? && failure["message"].to_s.empty?
+
+        record
+      rescue Session::InvalidId
+        nil
+      end
+
       # The duration of +part+'s call: the next record of its tool, in call
       # order, consumed with the ones it skipped. By tool and order, not by
       # iteration: an empty retry spends an iteration that left no message.

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -486,7 +486,7 @@ module Samagotchi
         lines << "output cap hits:  #{snapshot[:capped].to_i}"
         context = snapshot[:context] || {}
         if context[:used_tokens]
-          pct = context[:window_tokens].to_i.positive? ? format(" (%.1f%%)", context[:used_tokens] * 100.0 / context[:window_tokens]) : ""
+          pct = context_pct_text(context, snapshot[:llm_context])
           lines << "context used:     #{context[:used_tokens]} tokens#{pct}"
         end
         lines << "context window:   #{context[:window_tokens]} tokens (#{context[:window_source]})" if context[:window_tokens]
@@ -506,6 +506,24 @@ module Samagotchi
         lines.join("\n")
       end
 
+      # " (25.0% of the 64000 budget)" when the session's llm_context budget
+      # is set and smaller than the window, else " (12.5%)": the live meter
+      # counts against the smaller of the two (ContextStatus#counted_against),
+      # and so does this. The summary is Explained#summary (symbol or string
+      # keys: the attached TUI's come as JSON); "" when there is no window.
+      def context_pct_text(context, llm_context)
+        window = context[:window_tokens].to_i
+        return "" unless window.positive?
+
+        summary = llm_context.is_a?(Hash) ? llm_context : {}
+        budget = summary[:budget_tokens] || summary["budget_tokens"]
+        budget = nil unless budget.is_a?(Numeric) && budget.positive?
+        used = context[:used_tokens] * 100.0
+        return format(" (%.1f%%)", used / window) unless budget && budget < window
+
+        format(" (%.1f%% of the %d budget)", used / budget, budget)
+      end
+
       # "stale,forget (the session); apply turn_end (models: x); budget
       # 64000 (the session)" for /stats (Explained#summary; symbol or
       # string keys, the attached TUI's come as JSON); nil without one.

data/lib/samagotchi/terminal_ui.rb

@@ -60,6 +60,9 @@ module Samagotchi
     REMINDER_PENDING_POLL_INTERVAL = 0.5
     # What a command sent during a turn gets, as from a worker (Worker::BUSY_OUTPUT).
     COMMAND_BUSY = "busy: wait for the turn to end"
+    ROLLBACK_BUSY = "busy: Ctrl-C the turn first, then !rollback"
+    # A command typed during a turn that runs after it (/model X, !cmd).
+    COMMAND_QUEUED = "(queued: runs after this turn)"
     # /detach is the attached terminal's; the REPL owns its session.
     REPL_DETACH_NOTE = "(not attached: this session runs in this terminal; /exit ends it)"
     IMAGE_LINE_WAITS = "(a line with images runs as the next turn)"
@@ -569,8 +572,10 @@ module Samagotchi
         # Not an answer to a continue offer either.
         next detach_note if local == :detach
 
-        # /stats and /recap run; the offer stays open.
-        if @turn_flow.awaiting_continue? && !%i[stats recap].include?(local)
+        # /stats and /recap run; the offer stays open. So does a session
+        # command (one queued during the turn: /model X, !cmd); /continue
+        # answers it.
+        if @turn_flow.awaiting_continue? && !%i[stats recap].include?(local) && !offer_leaves_open?(input)
           answer_continue_offer(session, input)
         else
           # The ? read left no echo: show what ran.
@@ -714,6 +719,13 @@ module Samagotchi
 
     # An answer at the ? prompt of a continue offer. A valid one closes the
     # offer's choices and leaves one line; an invalid one gets its error.
+    # Whether +input+ is a session command that runs past a continue offer,
+    # leaving it open: any but /continue (the worker's S2).
+    def offer_leaves_open?(input)
+      entry = command_registry.lookup(input)
+      !entry.nil? && entry.id != :continue
+    end
+
     def answer_continue_offer(session, input)
       answer = @commands.continue_answer(input)
       if answer.decision == :invalid
@@ -743,7 +755,7 @@ module Samagotchi
       # /model, /models, !rollback, !cmd, /continue (shared with workers);
       # an anytime command's cards print as it shows them (btw's
       # "thinking…" before the answer).
-      command = if command_registry.lookup(input)&.anytime
+      command = if command_registry.anytime?(input)
                   @engine.running_anytime { @commands.run(input) }
                 else
                   @commands.run(input)
@@ -1031,26 +1043,58 @@ module Samagotchi
     # While a turn runs, a line submitted at the open prompt steers it: it
     # merges at the next iteration boundary (Kernel), and one that comes after
     # the last runs as the next turn. Reminder turns too.
+    #
+    # A command that waits for the turn's end (/model X, !cmd) and every line
+    # after it wait in @after_turn, in the order typed (D1), with the image
+    # lines (which never steer): once the turn ends they come back after the
+    # steering it didn't merge (typed before them), ahead of anything sent
+    # after Ctrl-C.
     def with_steering(&)
       return yield unless @repl_input
 
-      @repl_input.during_turn(method(:steer_line), leftovers: -> { @pending_input_queue.drain }, &)
+      @after_turn = []
+      @command_waits = false
+      @repl_input.during_turn(method(:steer_line), leftovers: -> { @pending_input_queue.drain + lines_after_turn }, &)
+    end
+
+    # The lines that waited for the turn's end, taken from @after_turn. After
+    # a canceled or failed turn (Ctrl-C raises through here; a failure too)
+    # a !cmd among them is dropped (D4): running it would close the
+    # !rollback the turn left.
+    def lines_after_turn
+      lines = @after_turn.slice!(0..)
+      ended = if @active_cancel_controller&.cancelled? || $!.is_a?(Interrupt) then "canceled"
+              elsif $! then "failed"
+              end
+      return lines unless ended
+
+      lines.reject do |line|
+        next false unless command_registry.lookup(line)&.id == :shell
+
+        @surface.commit("turn #{ended}: #{line.strip} not run; send it again")
+        true
+      end
     end
 
     # On the reader thread, from ReplInput: takes a line for the running turn.
     # A line sent after Ctrl-C waits for the next turn (the kernel would not
     # merge it into the cancelled one). Ctrl-D or exit ends the REPL after
     # the turn. /stats and /recap run now, an anytime command (/help, a
-    # plugin's /btw) starts now on its own thread; other commands wait, back
-    # in the prompt.
+    # plugin's /btw, /model alone) starts now on its own thread; one that
+    # runs after the turn (/model X, !cmd) waits in the queue, in arrival
+    # order with the other lines that wait; others go back in the prompt.
     # @return [Boolean, :back] whether the turn took it, :back to put it back
     def steer_line(line)
       local = local_command(line) unless line.nil?
       return exit_after_turn(delete: SessionCommands.delete_on_exit?(line)) if line.nil? || local == :exit
+      return archive_after_turn if local == :archive
       return detach_note if local == :detach
       return false if @active_cancel_controller&.cancelled?
-      return start_anytime_command(line) if command_registry.lookup(line)&.anytime
-      # A command, never steering text (/archive waits, back in the prompt).
+
+      policy = command_registry.mid_turn(line)
+      return start_anytime_command(line) if policy == :anytime
+      return command_queued(line) if policy == :queue
+      # A command, never steering text.
       return command_during_turn(line) if local || command_registry.command?(line)
       return true if line.strip.empty?
 
@@ -1060,7 +1104,9 @@ module Samagotchi
         return true
       end
       # Steering merges text only: a line with images runs as the next turn.
-      return image_line_waits if ImageInput.extract(line).any?
+      return image_line_waits(line) if ImageInput.extract(line).any?
+      # Behind a command that waits for the turn's end, a line waits too.
+      return wait_for_turn_end(line) if @command_waits
 
       epoch = @engine.input_epoch
       @pending_input_queue.push(line.strip)
@@ -1071,9 +1117,16 @@ module Samagotchi
       true
     end
 
-    def image_line_waits
+    def image_line_waits(line)
       @surface.commit(IMAGE_LINE_WAITS)
-      false
+      wait_for_turn_end(line)
+    end
+
+    # +line+ runs once the turn has ended, in the order typed (#with_steering).
+    # @return [true] the turn took it
+    def wait_for_turn_end(line)
+      @after_turn << line
+      true
     end
 
     def detach_note
@@ -1081,6 +1134,18 @@ module Samagotchi
       true
     end
 
+    # /archive during a turn (D2): the REPL leaves and archives once the
+    # turn and the lines queued behind it (S5) ran, as /exit does.
+    # @return [true]
+    def archive_after_turn
+      return @surface.commit(SCRATCH_ARCHIVE_REFUSED).then { true } if @scratch
+
+      @exit_after_turn = true
+      @archive_on_exit = true
+      @surface.commit("(archives after this turn; Ctrl-C cancels it)")
+      true
+    end
+
     def exit_after_turn(delete: false)
       @exit_after_turn = true
       @delete_on_exit = true if delete
@@ -1098,10 +1163,17 @@ module Samagotchi
     def command_during_turn(line)
       return true if show_local_command(line)
 
-      @surface.commit(COMMAND_BUSY)
+      @surface.commit(command_registry.lookup(line)&.id == :rollback ? ROLLBACK_BUSY : COMMAND_BUSY)
       :back
     end
 
+    # @return [true] it waits for the turn's end (#wait_for_turn_end)
+    def command_queued(line)
+      @surface.commit(COMMAND_QUEUED)
+      @command_waits = true
+      wait_for_turn_end(line)
+    end
+
     # D8: an anytime command runs on its own thread while the turn goes on
     # (it reads copies, and shows things through its ctx). What it prints
     # while the turn runs goes above the live region now, its cards as it

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -488,15 +488,10 @@ module Samagotchi
       # A session's LLM context strategy, apply rule and budget, each with
       # where it came from (LLMContextStrategy::Explained#summary), as its
       # worker would resolve them; nil when they can't be.
+      # (LLMContextStrategy.for_session, shared with the ctx % the session
+      # lists count.)
       def llm_context_for(session)
-        registry = host_registry
-        name = session.model_name.to_s.strip.empty? ? ModelProfile.required_model_name(nil) : session.model_name
-        target = registry.resolve(name)
-        names = registry.lookup_names(session.model_typed || name, resolved: name, target: target)
-        own = session.llm_context
-        LLMContextStrategy.explain(target, names: names, **(own&.resolve_args || {})).summary(own)
-      rescue StandardError
-        nil
+        LLMContextStrategy.for_session(session, registry: host_registry)
       end
 
       # Built again when config.yml's hosts: changed (compared as read: the
@@ -679,6 +674,8 @@ module Samagotchi
           failed_turn: failed_turn_for(session, raw_messages),
           current_turn: current_turn,
           queued: turn_snapshot ? Array(turn_snapshot["queued"]) : [],
+          # Commands waiting for the running turn's end (their bubbles).
+          queued_commands: turn_snapshot ? Array(turn_snapshot["queued_commands"]) : [],
           recap: turn_snapshot && turn_snapshot["recap"],
           saved_recap: saved_recap_for(id, session, turn_snapshot),
           continue_offer: turn_snapshot && turn_snapshot["continue_offer"],
@@ -1496,7 +1493,8 @@ module Samagotchi
       # @param owner [OwnerLock::Owner, nil] #session_owner; its kind is shown as `owner`
       def session_to_json(s, status: s.status, owner: nil)
         SessionSummary.build(s, status: status, owner: owner,
-                                session_dir: @session_class.session_dir(s.id, state_dir: default_state_dir))
+                                session_dir: @session_class.session_dir(s.id, state_dir: default_state_dir),
+                                registry: host_registry)
       end
 
       # The whole timing: analytics.json's records merged with a live

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

@@ -447,16 +447,20 @@ function fitStripColumns() {
 // The order a list draws its cards in: +next+, what waits on the user
 // first (waitingFirst), back to its place once answered. Never under the
 // pointer, though: while it is over the list the order last drawn holds,
-// and its leaving draws the list again. +idOf+ names a card: a session's
-// id, or familyId (a card per family: its head's id). drawnOrder is the
-// cards drawn, which select mode picks from.
+// and its leaving draws the list again. A hidden list holds nothing: the
+// strip keeps :hover for a moment after a click on its All sessions tile
+// hid it, and an update held then brought it back from the all view in an
+// order nobody saw (a waiting family behind). +idOf+ names a card: a
+// session's id, or familyId (a card per family: its head's id). drawnOrder
+// is the cards drawn, which select mode picks from.
 const drawnOrder = new Map(); // list element → card ids in the order last drawn
 const heldLists = new Set(); // lists drawn in a held order
 const canHover = globalThis.matchMedia?.("(hover: hover)").matches ?? false;
 function listOrder(el, next, idOf = (s) => s.id) {
   // The strip's popover holds it too (the pointer leaves the strip for it,
   // and a touch screen has no hover at all).
-  const holding = (canHover && el.matches(":hover")) || (el === topStripEl && familyPop.isOpen());
+  const holding = el.getClientRects().length > 0
+    && ((canHover && el.matches(":hover")) || (el === topStripEl && familyPop.isOpen()));
   const held = holding ? drawnOrder.get(el) : null;
   const ordered = held ? heldOrder(held, next, idOf) : next;
   if (held && ordered.some((x, i) => idOf(x) !== idOf(next[i]))) heldLists.add(el);
@@ -1160,7 +1164,7 @@ function renderSessionView(data) {
   const activeTurnId = current.timing.activeTurn?.id || null;
   // The saved fill, so a reloaded or stopped session shows it before its
   // next turn (a running turn's replay below streams over it).
-  const savedPct = savedCtxPct(data.timing?.context);
+  const savedPct = savedCtxPct(data.timing?.context, s.llm_context?.budget_tokens);
   if (savedPct !== null) current.ctxPct = savedPct;
   if (data.timing?.context?.window_tokens) {
     current.ctxWindow = data.timing.context.window_tokens;
@@ -1211,6 +1215,7 @@ function renderSessionView(data) {
   const replay = snapshotEvents({
     current_turn: data.current_turn,
     queued: data.queued,
+    queued_commands: data.queued_commands,
     started_at: current.timing.activeTurn?.started_at,
   });
   // Marked replayed: a call's duration isn't timed from the replay's clock.
@@ -1821,7 +1826,8 @@ function updateInfoBar() {
   const ctxText = ctxBarText(current.ctxPct, current.ctxWindowSource);
   const tokens = current.timing.tokens;
   const ctxTip = tokensTipText(tokens, undefined, current.timing.memoryIndex,
-                               { tokens: current.ctxWindow, source: current.ctxWindowSource, pct: current.ctxPct });
+                               { tokens: current.ctxWindow, source: current.ctxWindowSource, pct: current.ctxPct,
+                                 budget: current.llmContext?.budget_tokens });
   const speedTextNow = lastSpeedText(tokens);
   const avgSpeed = speedText(tokens?.avg_decode_tps, tokens?.tps_source);
   const speedTip = `Decode speed of the last generation${avgSpeed ? `; session average ${avgSpeed}` : ""}`;
@@ -1984,7 +1990,7 @@ const streamHandlers = {
     const { text, thinking } = routeChunk(data);
     liveTurn.timing.setNote("");
     turnDom.chunk({ text, thinking, iteration: data.iteration ?? null });
-    const pct = extractCtxPct(data, current.ctxWindow);
+    const pct = extractCtxPct(data, current.ctxWindow, current.llmContext?.budget_tokens);
     if (pct !== null && !Number.isNaN(pct)) {
       current.ctxPct = pct;
       updateInfoBar();
@@ -2133,17 +2139,19 @@ const streamHandlers = {
     }
     if (view.resync) await resync();
     // A card's action that isn't anytime (the step-limit question's
-    // /continue) has no bubble: nothing to remove.
-    const queued = view.anytime ? commandBubble(view.commandId) : null;
+    // /continue) has no bubble: nothing to remove. An anytime or queued
+    // one's bubble was drawn at its command_queued: filled in here.
+    const queued = view.anytime || view.queued ? commandBubble(view.commandId) : null;
     if (view.hidden) queued?.remove();
     else if (queued) drawCommandBubble(queued, view);
     else addCommandBubble(view);
   },
   // An anytime command (/help, a plugin's /btw) runs at once, beside a
-  // turn: its bubble goes here, so the cards it shows come after it.
+  // turn: its bubble goes here, so the cards it shows come after it. One
+  // queued for after the turn (/model X mid-turn) shows waiting here.
   command_queued: (data) => {
     // A card's action waits for its command_ran: shown only if it answers.
-    if (data.anytime && !data.card && !commandBubble(data.command_id)) addCommandBubble({ ...commandView(data, clientId), text: "" });
+    if ((data.anytime || data.waits) && !data.card && !commandBubble(data.command_id)) addCommandBubble(commandView(data, clientId));
   },
   // Due reminders went into the turn (a reminder turn has no prompt bubble).
   reminder_injected: (data) => addCommandBubble({ label: null, line: reminderText(data), text: "" }),
@@ -2162,7 +2170,7 @@ const streamHandlers = {
     if (Array.isArray(data.used_memory_names)) setUsedMemories(data.used_memory_names);
   },
   context_status: (data) => {
-    const pct = extractCtxPct(data, current.ctxWindow);
+    const pct = extractCtxPct(data, current.ctxWindow, current.llmContext?.budget_tokens);
     if (pct !== null) {
       current.ctxPct = pct;
       updateInfoBar();
@@ -2198,7 +2206,7 @@ const streamHandlers = {
   // The loop asks again after an empty answer: a row of the empty step
   // (a reload puts it back from the snapshot's cards).
   empty_answer_retry: (data) => { turnDom.notice({ line: emptyRetryLine(data) }); },
-  steer_cut: (data) => { turnDom.notice({ line: steerCutLine(data) }); },
+  steer_cut: (data) => { turnDom.notice({ line: steerCutLine(data), cls: "steer-cut" }); },
   // A batch of LLM context edits the server applied: a ✂ row of the
   // current step, its hover listing the outputs.
   llm_context_edited: (data) => { turnDom.notice(llmContextNotice(data)); },
@@ -2434,8 +2442,8 @@ function addCommandBubble(view) {
 
 // A command bubble's line and output (again, when its command_ran fills in
 // an anytime command's bubble in place).
-function drawCommandBubble(div, { label, line, text, busy = false, failed = false, commandId = null }) {
-  div.className = "bubble command" + (busy ? " busy" : "") + (failed ? " failed" : "");
+function drawCommandBubble(div, { label, line, text, busy = false, failed = false, waiting = false, commandId = null }) {
+  div.className = "bubble command" + (busy ? " busy" : "") + (failed ? " failed" : "") + (waiting ? " queued" : "");
   if (commandId) div.dataset.commandId = commandId;
   div.replaceChildren();
   const head = document.createElement("div");

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

@@ -30,10 +30,12 @@ export function moveSelection(index, count, delta) {
 }
 
 // One row's parts: the name, its description, and a note (the bundle it
-// comes from; "mid-turn too" for an anytime one), "" when there is none.
+// comes from; "mid-turn too" for an anytime one, "show: mid-turn too" for
+// one whose show form is), "" when there is none.
 export function commandRow(command) {
   const notes = [];
   if (command.source && command.source !== "core") notes.push(command.source);
   if (command.anytime) notes.push("mid-turn too");
+  else if (command.mid_turn === "depends") notes.push("show: mid-turn too");
   return { name: command.name, description: command.description || "", note: notes.join(" · ") };
 }

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

@@ -2,11 +2,24 @@
 // the kernel resolved for this generation (:generation_started carries it as
 // context_window_tokens); llama.cpp's stream payloads report token counts
 // but no n_ctx, so without it only a precomputed pct or an n_ctx works.
+// `budgetTokens` is the session's LLM context budget (llm_context's
+// budget_tokens): a percentage this file computes counts against it when it
+// is smaller than the window, as the kernel's :context_status does
+// (ContextStatus#counted_against), so the meter reads the same from either.
 
 function num(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : null;
 }
 
+// What a fill counts against: the window, or the budget when one is set
+// and smaller; null without a window.
+export function countedTokens(windowTokens, budgetTokens = null) {
+  const window = num(windowTokens);
+  if (!window || window <= 0) return null;
+  const budget = num(budgetTokens);
+  return budget && budget > 0 ? Math.min(budget, window) : window;
+}
+
 // Tokens in context after this chunk: prompt + generated so far.
 function usedTokens(p) {
   if (!p || typeof p !== "object") return null;
@@ -18,30 +31,35 @@ function usedTokens(p) {
   return (prompt ?? 0) + (completion ?? 0);
 }
 
-export function extractCtxPct(data, windowTokens = null) {
+export function extractCtxPct(data, windowTokens = null, budgetTokens = null) {
   if (!data || typeof data !== "object") return null;
   if (num(data.ctx_pct) !== null) return data.ctx_pct;
   if (num(data.est_pct) !== null) return data.est_pct;
   if (num(data.ctxPct) !== null) return data.ctxPct;
   // The kernel's :context_status event: { usage: { estimated_pct, ... }, bucket }.
   if (num(data.usage?.estimated_pct) !== null) return data.usage.estimated_pct;
-  if (data.context_window_tokens && data.total_tokens) return (data.total_tokens / data.context_window_tokens) * 100;
+  if (data.context_window_tokens && data.total_tokens) {
+    const against = countedTokens(data.context_window_tokens, budgetTokens);
+    if (against) return (data.total_tokens / against) * 100;
+  }
   const p = data.payload || data;
   if (num(p.ctx_pct) !== null) return p.ctx_pct;
-  const window = num(p.n_ctx) || num(windowTokens);
+  const against = countedTokens(num(p.n_ctx) || num(windowTokens), budgetTokens);
   const used = usedTokens(p);
-  if (!window || window <= 0 || used === null) return null;
-  return (used / window) * 100;
+  if (!against || used === null) return null;
+  return (used / against) * 100;
 }
 
 // The saved context (the session's timing.context: used_tokens after the
 // last counted turn, the window now): the meter's value on load, before a
-// turn streams. null when either count is missing.
-export function savedCtxPct(context) {
+// turn streams, counted against +budgetTokens+ (the session's llm_context
+// budget_tokens) when it is smaller, as live. null when either count is
+// missing.
+export function savedCtxPct(context, budgetTokens = null) {
   const used = num(context?.used_tokens);
-  const window = num(context?.window_tokens);
-  if (used === null || !window || window <= 0) return null;
-  return (used / window) * 100;
+  const against = countedTokens(context?.window_tokens, budgetTokens);
+  if (used === null || !against) return null;
+  return (used / against) * 100;
 }
 
 // A session card's quiet ctx: "12%", or "" when the list row has none.
@@ -99,18 +117,27 @@ export function ctxBarText(pct, windowSource = null) {
   return `ctx ${windowSource === "default" ? "~" : ""}${Math.round(pct)}%`;
 }
 
-// The ctx tooltip's window line ({tokens:, source:, pct:} the session's
-// window, where it came from and the meter's value): "context: ~41.0k of
-// 128.0k tokens (server)", as /stats names the source; "" without a window.
+// The ctx tooltip's window line ({tokens:, source:, pct:, budget:} the
+// session's window, where it came from, the meter's value and the LLM
+// context budget): "context: ~41.0k of 128.0k tokens (server)", as /stats
+// names the source; under a budget smaller than the window the meter's
+// percentage is of the budget: "context: ~41.0k of the 64.0k budget,
+// 128.0k window (server)"; "" without a window.
 export function ctxWindowText(window) {
   const tokens = num(window?.tokens);
   if (!tokens || tokens <= 0) return "";
+  const against = countedTokens(tokens, window.budget);
   const pct = num(window.pct);
-  const used = pct === null ? "" : `~${countK((pct / 100) * tokens)} of `;
   const source = window.source === "default"
     ? "chi's default, a guess: set window_tokens for this model"
     : window.source;
-  return `context: ${used}${countK(tokens)} tokens${source ? ` (${source})` : ""}`;
+  const sourceText = source ? ` (${source})` : "";
+  if (against < tokens) {
+    const used = pct === null ? "" : `~${countK((pct / 100) * against)} of `;
+    return `context: ${used}the ${countK(against)} budget, ${countK(tokens)} window${sourceText}`;
+  }
+  const used = pct === null ? "" : `~${countK((pct / 100) * tokens)} of `;
+  return `context: ${used}${countK(tokens)} tokens${sourceText}`;
 }
 
 // The ctx tooltip (info bar and card): +title+, then the session's tokens