samagotchi 0.43.0 → 0.45.0

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -83,6 +83,13 @@ module Samagotchi
         paint("↪ cut in for #{STEER_CUT_FOR.fetch(event[:source].to_s, "your message")}", 90)
       end
 
+      # "✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid
+      # off)": a batch of LLM context edits went in (LLMContextNotice builds
+      # the line; the web prints the same), dim like the retry row.
+      def format_llm_context_line(event)
+        paint(event[:text].to_s.empty? ? "✂ LLM context edited" : event[:text].to_s, 90)
+      end
+
       # "no answer: the model returned nothing (after 1 retry)", dim like the
       # retry row: a turn that ended with no answer (TurnNote.empty_answer_line).
       def format_empty_answer_line(retries)
@@ -479,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]
@@ -499,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/one_shot_sink.rb

@@ -30,6 +30,7 @@ module Samagotchi
         case event[:type]
         when :empty_answer_retry then line(format_empty_retry_line(event))
         when :steer_cut then line(format_steer_cut_line(event))
+        when :llm_context_edited then line(format_llm_context_line(event))
         when :generation_retrying then line(format_generation_retry_line(event))
         when :turn_completed, :turn_canceled then @turn_over = true
         when :hook_notice

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.43.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
@@ -1658,6 +1656,8 @@ module Samagotchi
       def messages_for_display(msgs, parts: false, cwd: nil)
         filtered = []
         list = Array(msgs)
+        # The outputs' ✂ marks (LLM context edits), by id, for the parts.
+        marks = parts ? MessageParts.edit_marks(list) : {}
         list.each_with_index do |m, index|
           role = (m[:role] || m["role"]).to_s
           content = (m[:content] || m["content"]).to_s
@@ -1689,7 +1689,7 @@ module Samagotchi
           next if role == "tool_response"
 
           stripped = Samagotchi::OutputFormatter.strip_markup(content)
-          did = parts && %w[model assistant].include?(role) ? message_parts(list, index, cwd) : nil
+          did = parts && %w[model assistant].include?(role) ? message_parts(list, index, cwd, marks) : nil
           next if stripped.empty? && did.nil?
 
           norm_role = role == "model" ? "assistant" : role
@@ -1757,10 +1757,11 @@ module Samagotchi
       end
 
       # The parts of the assistant message at +index+, with the tool_response
-      # messages right after it.
-      def message_parts(list, index, cwd = nil)
+      # messages right after it; +marks+: the session's ✂ marks
+      # (MessageParts.edit_marks).
+      def message_parts(list, index, cwd = nil, marks = {})
         responses = list.drop(index + 1).take_while { |r| (r[:role] || r["role"]).to_s == "tool_response" }
-        MessageParts.for_message(list[index], responses, cwd: cwd)
+        MessageParts.for_message(list[index], responses, cwd: cwd, marks: marks)
       end
 
       # The last message messages_for_display shows as an answer

data/lib/samagotchi/web/message_parts.rb

@@ -7,6 +7,8 @@ require_relative "../tool_view"
 require_relative "../llm/native_tool_normalizer"
 require_relative "../tools/builtins"
 require_relative "../image_store"
+require_relative "../llm_context_edit"
+require_relative "../token_usage"
 
 module Samagotchi
   module Web
@@ -28,6 +30,10 @@ module Samagotchi
     # by the saved image_counts (older sessions without them: only a lone
     # call gets them).
     #
+    # A call's chi-owned id (ToolIds, saved as tool_ids) is the part's
+    # tool_id:, and an LLM context edit saved on its output (LLMContextEdit,
+    # under edits) the part's edit: (.edit_marks), the row's ✂ mark.
+    #
     # A plugin tool's params are what its live row showed (its preview),
     # saved with the result as tool_params (native: one per call, chat: one
     # per result); its label ("chrome: screenshot") likewise as tool_labels,
@@ -59,15 +65,17 @@ module Samagotchi
       # @param registry [Tools::Registry] the session's tools
       # @param cwd [String, nil] the session's working directory (a file
       #   tool's title is relative to it)
+      # @param marks [Hash{String => Hash}] the session's edit marks by
+      #   output id (.edit_marks)
       # @return [Hash, nil] { thinking:, tools: [{ tool:, params:, title:,
-      #   output:, output_truncated:, images: }] } with only what it found; nil for nothing
-      def for_message(message, responses, registry: Tools::Builtins.default, cwd: nil)
+      #   output:, output_truncated:, images:, tool_id:, edit: }] } with only what it found; nil for nothing
+      def for_message(message, responses, registry: Tools::Builtins.default, cwd: nil, marks: {})
         content = field(message, :content).to_s
         calls = field(message, :tool_calls)
         tools = if calls.is_a?(Array) && !calls.empty?
-                  native_tools(calls, responses, registry, cwd)
+                  native_tools(calls, responses, registry, cwd, marks)
                 else
-                  markup_tools(content, responses, registry, cwd)
+                  markup_tools(content, responses, registry, cwd, marks)
                 end
         parts = {}
         thinking = [field(message, :thinking).to_s.strip, thinking_of(content)].reject(&:empty?).join("\n\n")
@@ -87,7 +95,7 @@ module Samagotchi
         blocks.map(&:strip).reject(&:empty?).join("\n\n")
       end
 
-      def markup_tools(content, responses, registry, cwd = nil)
+      def markup_tools(content, responses, registry, cwd = nil, marks = {})
         calls = []
         calls.concat(ToolCallParser::Qwen.new(ModelProfile.qwen36).parse(content)) if content.include?("<tool_call>")
         calls.concat(ToolCallParser::Gemma.new(ModelProfile.gemma4).parse(content)) if content.include?("<|tool_call>")
@@ -98,9 +106,11 @@ module Samagotchi
         shown = saved_list(responses, :tool_params, calls.length)
         labels = saved_list(responses, :tool_labels, calls.length)
         diffs = saved_list(responses, :tool_diffs, calls.length)
+        ids = saved_list(responses, :tool_ids, calls.length)
         images = split_images(responses, calls.length)
         calls.each_with_index.map do |call, i|
-          tool_part(call, outputs[i], registry, shown[i], images[i], label: labels[i], diff: diffs[i], cwd: cwd)
+          tool_part(call, outputs[i], registry, shown[i], images[i], label: labels[i], diff: diffs[i], cwd: cwd,
+                                                                     tool_id: ids[i], marks: marks)
         end
       end
 
@@ -122,16 +132,78 @@ module Samagotchi
         counts.map { |n| images.shift(n) }
       end
 
-      def native_tools(calls, responses, registry, cwd = nil)
-        by_id = responses.to_h { |r| [field(r, :tool_call_id), r] }
+      def native_tools(calls, responses, registry, cwd = nil, marks = {})
+        # By id only for an id that names one response: a server may omit
+        # it (nil), send "" or repeat it; those pair by position.
+        ids = responses.map { |r| field(r, :tool_call_id).to_s }
+        unique = ->(id) { !id.empty? && ids.count(id) == 1 }
+        by_id = responses.each_with_index.to_h { |r, i| [ids[i], r] }.select { |id, _| unique.call(id) }
         calls.each_with_index.map do |raw, i|
           ref = CallRef.new(field(raw, :name).to_s, field(raw, :arguments))
           call = LLM::NativeToolNormalizer.normalize(ref) || { name: ref.name }
-          response = by_id[field(raw, :id)] || (field(responses[i], :tool_call_id).nil? ? responses[i] : nil)
+          response = by_id[field(raw, :id).to_s] || (responses[i] && !unique.call(ids[i]) ? responses[i] : nil)
           tool_part(call, response && field(response, :content).to_s, registry, field(response, :tool_params),
                     response && field(response, :images), label: field(response, :tool_labels),
-                                                          diff: field(response, :tool_diffs), cwd: cwd)
+                                                          diff: field(response, :tool_diffs), cwd: cwd,
+                                                          tool_id: Array(field(response, :tool_ids)).first, marks: marks)
+        end
+      end
+
+      # The ✂ mark of each output an LLM context edit is saved on, by its
+      # id, from +messages+ (a session's, symbol or string keys): {kind:
+      # "stale" | "forget", staged: true while a forget waits for the
+      # turn's end, note: (a stale stub's reason, "superseded by a later
+      # read"; the first output of a forget_outputs call's, its note), with:
+      # (the others of that call's: the first one's id), kept: ("12-40, 50",
+      # a forget's kept lines)}. A forget call's outputs share the note,
+      # author and stamp (LLMContextView's key); the first in the session's
+      # order carries the note.
+      # @return [Hash{String => Hash}]
+      def edit_marks(messages)
+        first = {}
+        Array(messages).each_with_object({}) do |entry, marks|
+          next unless field(entry, :role).to_s == "tool_response"
+
+          saved = field(entry, :edits)
+          next unless saved.is_a?(Hash)
+
+          edits = saved.filter_map { |id, hash| LLMContextEdit.from_h(id, hash) }.to_h { |edit| [edit.id, edit] }
+          order = Array(field(entry, :tool_ids)).map(&:to_s)
+          edits.sort_by { |id, _| order.index(id) || order.size }.each do |id, edit|
+            marks[id] = edit_mark(edit, first)
+          end
+        end
+      rescue StandardError
+        {}
+      end
+
+      def edit_mark(edit, first)
+        mark = { kind: edit.kind.to_s }
+        mark[:staged] = true unless edit.applied?
+        if edit.kind == :stale
+          mark[:note] = edit.note[/superseded by .*\z/] || edit.note
+        else
+          key = [edit.note, edit.by, edit.staged_at]
+          if first.key?(key)
+            mark[:with] = first[key]
+          else
+            first[key] = edit.id
+            mark[:note] = edit.note
+          end
+          kept = edit.keep.map { |from, to| from == to ? from.to_s : "#{from}-#{to}" }
+          mark[:kept] = kept.join(", ") unless kept.empty?
         end
+        mark
+      end
+
+      # +output+'s ✂ mark (+marks+ by +id+); an applied stale stub says
+      # what it frees: its output, ~chars/4.
+      def mark_of(id, marks, output)
+        mark = marks[id]
+        return nil unless mark
+        return mark unless mark[:kind] == "stale" && !mark[:staged] && output
+
+        mark.merge(tokens: (output.length / TokenUsage::CHARS_PER_TOKEN).ceil)
       end
 
       # +count+ outputs from a joined tool_response: the "[tool]"-tagged
@@ -153,7 +225,9 @@ module Samagotchi
       # +shown+ is the saved params line, when it is a String.
       # +diff+ is what an edit/write changed (EditPreview.change), saved as
       # tool_diffs. +cwd+: the session's working directory, for the title.
-      def tool_part(call, output, registry, shown = nil, images = nil, label: nil, diff: nil, cwd: nil)
+      # +tool_id+: its output's ToolIds id, with its ✂ mark in +marks+.
+      def tool_part(call, output, registry, shown = nil, images = nil, label: nil, diff: nil, cwd: nil, tool_id: nil,
+                    marks: {})
         name = call[:name].to_s
         params = shown.is_a?(String) ? shown : ToolActivity.tool_activity_params(name, call, registry: registry)
         part = { tool: name, params: params.to_s }
@@ -171,6 +245,11 @@ module Samagotchi
         refs = Array(images).select { |ref| ref.is_a?(Hash) }
         part[:images] = refs.map { |ref| ImageStore.symbolize(ref).slice(:file, :name, :width, :height) } unless refs.empty?
         part[:diff] = diff if diff.is_a?(Hash)
+        if tool_id
+          part[:tool_id] = tool_id.to_s
+          mark = mark_of(tool_id.to_s, marks, output)
+          part[:edit] = mark if mark
+        end
         part
       end
 

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

@@ -60,7 +60,7 @@ import {
 } from "./timing.js";
 import { createLiveTurn } from "./live_turn.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, llmContextHover, llmContextLine, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -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.
@@ -1527,11 +1532,17 @@ function showSteers(steers) {
   }
 }
 
+// A ✂ row's notice data (turnDom.notice, placeTurnNotice).
+function llmContextNotice(data) {
+  return { line: llmContextLine(data), cls: "llm-context", title: llmContextHover(data) };
+}
+
 function showHookNotice(data, { before = null } = {}) {
   removeHintIfEmpty();
   const el = document.createElement("div");
-  el.className = "bubble hook-notice" + (data.level === "warn" ? " warn" : "");
+  el.className = "bubble hook-notice" + (data.level === "warn" ? " warn" : "") + (data.cls ? ` ${data.cls}` : "");
   el.textContent = data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}`;
+  if (data.title) el.title = data.title;
   const follow = isNearBottom();
   if (before) historyEl.insertBefore(el, before);
   else appendToHistory(el);
@@ -1623,18 +1634,20 @@ function placeSnapshotCards(entries) {
 // plain answer, a step the history doesn't have) a bubble before the
 // turn's answer, or before its timing line when it has none.
 function placeTurnNotice(entry, before) {
+  const extra = entry.type === "llm_context_edited" ? llmContextNotice(entry) : {};
   const line = noticeLine(entry);
   const turnEls = reloadedTurnEls(before);
   const place = turnNoticePlace(entry);
   const block = turnEls.find((el) => el.matches(".turn-work"));
   const step = place && block ? block.querySelectorAll(":scope > .gen")[place.step] : null;
   if (!step) {
-    showHookNotice({ ...entry, line }, { before: turnAnswerEl(turnEls) || before });
+    showHookNotice({ ...entry, ...extra, line }, { before: turnAnswerEl(turnEls) || before });
     return;
   }
   const el = document.createElement("div");
-  el.className = "hook-notice" + (entry.level === "warn" ? " warn" : "");
+  el.className = "hook-notice" + (entry.level === "warn" ? " warn" : "") + (extra.cls ? ` ${extra.cls}` : "");
   el.textContent = line;
+  if (extra.title) el.title = extra.title;
   let body = step.querySelector(":scope > .activity-body");
   if (!body) {
     body = document.createElement("div");
@@ -1813,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}` : ""}`;
@@ -1976,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();
@@ -2125,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: "" }),
@@ -2154,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();
@@ -2190,7 +2206,10 @@ 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)); },
   // The provider is asked again after an error, or the turn waits for
   // plugins' setup: a note on the live timing line until it streams.
   generation_retrying: (data) => liveTurn.timing.setNote(retryStatusLine(data)),
@@ -2423,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");