samagotchi 0.44.0 → 0.46.0

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
@@ -1250,6 +1322,8 @@ module Samagotchi
 
       # The activity row goes while the question waits.
       @view.finish_thinking_spinner
+      return dismiss_unaskable_question(prompt) if @non_interactive
+
       # An edit's diff goes above the slot, into the scrollback.
       preview = prompt.preview_lines(paint: method(:paint))
       @surface.commit(preview.join("\n")) unless preview.empty?
@@ -1273,6 +1347,17 @@ module Samagotchi
       @surface.clear_slot(:notes)
     end
 
+    # --non-interactive has no one to ask (as for an approval or a hook's
+    # question there): the question is dismissed at once, as an empty answer
+    # would be, and the model finishes its reply. Never a read of stdin: a
+    # pipe its writer keeps open would block it forever. Its one line goes to
+    # stderr (#banner): stdout is the answer's alone.
+    def dismiss_unaskable_question(prompt)
+      @engine.cancel_question("user") rescue nil
+      banner(prompt.summary("(dismissed: no one to answer in a non-interactive run)", paint: method(:paint)))
+      false
+    end
+
     # Loop until a valid selection or a cancel. The block reads one answer:
     # a line, nil (Ctrl-D, or Ctrl-C with no turn), or :canceled (the turn
     # was cancelled).

data/lib/samagotchi/tools/delegate_wait.rb

@@ -84,10 +84,11 @@ module Samagotchi
           outcomes << outcome.line
           return with_outcomes(canceled_result(child_id, reports: reports), outcomes) if outcome.stopped
 
-          # Wait on with the child as it is now: a turn that ends with no
-          # reply after the relay still ends the wait, and the relayed
-          # question isn't reported again.
-          baseline = ReplyWait.baseline_of(Session.load(child_id, state_dir: sd), question_id: wait.question[:id])
+          # Wait on from the child as it was before the relay (read when it
+          # asked), the relayed question no longer reported: a turn that
+          # ends with no reply during the relay's POST or after it still
+          # ends the wait.
+          baseline = ReplyWait.baseline_of(wait.session, question_id: wait.question[:id])
         end
       rescue ArgumentError => e
         "Error: #{e.message}"

data/lib/samagotchi/tools/task_runtime.rb

@@ -66,6 +66,8 @@ module Samagotchi
           err: output_io
         )
         Process.detach(pid)
+        # Read now, compared before each signal: a pid reused later is not this task.
+        pid_started = ProcessGroup.start_time(pid)
 
         now = timestamp
         record = {
@@ -76,6 +78,7 @@ module Samagotchi
           "workspace_root" => Dir.pwd,
           "status" => "running",
           "pid" => pid,
+          "pid_started" => pid_started,
           "created_at" => now,
           "started_at" => now,
           "finished_at" => nil,
@@ -190,7 +193,7 @@ module Samagotchi
 
         pid = refreshed["pid"]
         # Checked again just before the signal: never a group chi didn't start.
-        return [mark_not_chis(refreshed), nil] unless ProcessGroup.leader?(pid)
+        return [mark_not_chis(refreshed), nil] unless chis_group?(refreshed, started: refreshed["pid_started"])
 
         refreshed["stop_requested_by"] = by.to_s
         write_record(refreshed)
@@ -210,13 +213,19 @@ module Samagotchi
         return record unless record["status"] == "running"
 
         pid = record["pid"]
-        return record if ProcessGroup.leader?(pid)
+        return record if chis_group?(record)
         # Gone: its exit code says how it ended.
         return mark_finished_without_exit_code(record) if ProcessGroup.signalable?(pid) && !ProcessGroup.alive?(pid)
 
         mark_not_chis(record)
       end
 
+      # Whether the record's pid still leads its own group. With +started+
+      # (the start time recorded at task_create), also the same process: a
+      # ps per call, so only task_stop asks it, just before the signal;
+      # a refresh (each task_wait poll, task_list) checks the group only.
+      def chis_group?(record, started: nil) = ProcessGroup.leader?(record["pid"], started: started)
+
       # A running record whose pid isn't a group chi started (NOT_CHIS_PROCESS)
       # ends as failed, unless its exit code or a stop on disk says more.
       def mark_not_chis(record)

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -443,7 +443,9 @@ module Samagotchi
             warnings.concat(listing.warnings)
             # the web's own spelling, kept as it was: bare on the default host
             listing.rows.each do |row|
-              models << { name: row.host == default_host ? row.id : "#{row.host}:#{row.id}", host: row.host, id: row.id }
+              model = { name: row.host == default_host ? row.id : "#{row.host}:#{row.id}", host: row.host, id: row.id }
+              model[:configured] = true if row.configured
+              models << model
             end
           end
         rescue StandardError => e
@@ -488,15 +490,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
@@ -662,7 +659,8 @@ module Samagotchi
         session_json = session_to_json(session, status: displayed_status(session, snapshot, owner: owner), owner: owner)
         # What the worker's server said it served for that model (after a turn).
         if snapshot
-          session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"])
+          session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"],
+                                            served_expected_by: snapshot["served_expected_by"])
           # The model notes its prompt carries now (a /model there changes them).
           session_json = session_json.merge(prompt_notes: snapshot["prompt_notes"]) if snapshot["prompt_notes"].is_a?(Array)
         end
@@ -679,6 +677,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 +1496,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);
@@ -1152,7 +1156,7 @@ function renderSessionView(data) {
   setCapabilities(data.capabilities);
   current.status = s.status;
   current.model = s.model_name;
-  current.served = s.served_model ? [s.served_model, s.served_model_for] : null;
+  current.served = s.served_model ? [s.served_model, s.served_model_for, s.served_expected_by || null] : null;
   current.dir = s.working_directory;
   current.owner = s.owner || null;
   current.timing = normalizeTiming(data.timing);
@@ -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();
@@ -2001,7 +2007,7 @@ const streamHandlers = {
   },
   generation_completed: (data) => {
     liveTurn.timing.setNote("");
-    if (data?.served_model) current.served = [data.served_model, data.requested_model];
+    if (data?.served_model) current.served = [data.served_model, data.requested_model, data.served_expected_by || null];
     // The generation's speed and the session's token totals, from the server.
     current.timing.tokens = generationTokens(current.timing.tokens, data);
     if (data?.served_model || data?.tokens) 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,13 +2206,17 @@ 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)),
+  generation_retrying: (data) => {
+    // A dropped stream's step asked again: what it streamed is void.
+    if (data?.restarted) turnDom.generationRestarted(data);
+    liveTurn.timing.setNote(retryStatusLine(data));
+  },
   plugin_init_wait: (data) => liveTurn.timing.setNote(initWaitLine(data)),
   plugin_init_started: (data) => onInitEvent("plugin_init_started", data),
   plugin_init_finished: (data) => onInitEvent("plugin_init_finished", data),
@@ -2434,8 +2446,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.
@@ -59,12 +77,24 @@ export function speedText(tps, source) {
   return `${source === "estimate" ? "~" : ""}${number} tok/s`;
 }
 
-// A cost in USD: "$0.42"; under a cent, four decimals ("$0.0012"); "" for
-// none or zero. As Formatting#cost_text.
-export function costText(cost) {
+// A cost in USD: "$0.42"; under a cent, four decimals ("$0.0012"); "~$0.12"
+// for an estimate (hosts.<name>.models prices); "" for none or zero. As
+// Formatting#cost_text.
+export function costText(cost, { estimate = false } = {}) {
   const value = num(cost);
   if (value === null || value <= 0) return "";
-  return value >= 0.01 ? `$${value.toFixed(2)}` : `$${value.toFixed(4)}`;
+  return `${estimate ? "~" : ""}${value >= 0.01 ? `$${value.toFixed(2)}` : `$${value.toFixed(4)}`}`;
+}
+
+// The ctx tooltip's cost: the reported cost as is; with an estimate (an
+// older worker or saved file has none) the total with "~" and both parts.
+function costLine(tokens) {
+  const reported = num(tokens.cost_sum) || 0;
+  const estimated = num(tokens.cost_estimate_sum) || 0;
+  if (estimated <= 0) return reported > 0 ? `cost: ${costText(reported)}` : "";
+  const total = costText(reported + estimated, { estimate: true });
+  const parts = reported > 0 ? `${costText(reported)} reported, ${costText(estimated, { estimate: true })} estimated` : "estimated";
+  return `cost: ${total} (${parts})`;
 }
 
 function count(n) {
@@ -99,23 +129,33 @@ 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
 // (in summed over every request, cached with its share, out with the
-// reasoning part) and its cost, when it has any, and the memory indexes
+// reasoning part) and its cost, when it has any (an estimated part with
+// "~", costLine), and the memory indexes
 // its prompt holds (+memoryIndex+, the snapshot's memory_index); with
 // +window+ (ctxWindowText's) the window line under the title. A
 // delegated session keeps its own metrics, so these are this session's only.
@@ -133,8 +173,8 @@ export function tokensTipText(tokens, title = "Context used after the last turn"
   if (cached > 0 && prompt > 0) parts.push(`cached ${count(cached)} (${Math.round((cached * 100) / prompt)}%)`);
   parts.push(`out ${count(completion)}${reasoning > 0 ? ` (reasoning ${count(reasoning)})` : ""}`);
   const lines = [title, `tokens: ${parts.join(" · ")}`];
-  const cost = costText(tokens.cost_sum);
-  if (cost) lines.push(`cost: ${cost}`);
+  const cost = costLine(tokens);
+  if (cost) lines.push(cost);
   lines.push("this session only, all requests");
   return `${lines.join("\n")}${memoryLine}`;
 }