samagotchi 0.43.0 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '019e204c3cd98489376bc61446efc6c576d5eb31f73ca97331c23b2d551b015f'
-  data.tar.gz: 20b4127aae83e29bfb00d67762ea443b78b2961622502df32458d9d6f9d89068
+  metadata.gz: 684d8e5c169b4ce5df4cd21c4c46d0ef8524230e530d3e90ec2076f5b674e905
+  data.tar.gz: 54dbaf8bd2ad38b78e16aca155414748491912bdaebe1069f128e6182df7bfe5
 SHA512:
-  metadata.gz: cdd1bbcef93ae1d57db0fde19927ac5b1c3dbb2e0fe36ff6bc93296044ce305fb2b75c1cc62b6a96c84720d9cb6e288135b69f2aaa624f949282355f360c2ab6
-  data.tar.gz: 91d1f3c0d5e2145135045e5f8fd79335142bc99bdccea708a608a541f72401812d1b965a4ec2e03e05a07d109664e40c9826d2573d51ec4cc918cc00b7d7400a
+  metadata.gz: de459298c279f571db785d374e1752a58060d26a13c4f7a6d22f8c4e4a5c82acbcffecd5784712eda405908cc3a8fd7bf1526952878b3791017088ebb62f120e
+  data.tar.gz: a99cf35d53b0a9fb7b3ed568a73d3383252ba334e4c8efd50efd9d97ded3cb716432fd51ee069e066ce3d21d137f1fadf49e20f2b99e9a769e430c8274278a64

data/CHANGELOG.md

@@ -8,6 +8,24 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.44.0] - 2026-10-08
+
+### Added
+
+- LLM context edits are visible: each batch of stubs that reaches the prompt gets a ✂ row in its step, in the web
+  and the terminal (`✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid off)`), whose web hover
+  lists the outputs, a stale stub's reason, a forget's note and kept lines, and the cost. After a reload a stubbed
+  output's tool row carries a ✂ mark (`✂ stubbed: superseded by a later read · ~1.0k tokens`, `✂ forgotten: <note>`,
+  `✂ forget staged`). The stream has a new event, `llm_context_edited`. See
+  [docs/configuration.md](docs/configuration.md) ("LLM context: what you see (✂)").
+
+### Fixed
+
+- Under an `llm_context.budget_tokens` budget without the forget layer (strategy `none` or `stale`), the model's
+  `[CONTEXT: …]` line said "of the context window" for a percentage of the budget; it now reads "about 62% of the
+  context budget (64k tokens) is in use", and its top bucket no longer asks the model to "summarize aggressively"
+  ("context budget critical — avoid large outputs and re-reads, delegate broad work to subagents").
+
 ## [0.43.0] - 2026-10-08
 
 ### Added
@@ -2008,7 +2026,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.43.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.44.0...HEAD
+[0.44.0]: https://github.com/dm1try/samagotchi/compare/v0.43.0...v0.44.0
 [0.43.0]: https://github.com/dm1try/samagotchi/compare/v0.42.0...v0.43.0
 [0.42.0]: https://github.com/dm1try/samagotchi/compare/v0.41.0...v0.42.0
 [0.41.0]: https://github.com/dm1try/samagotchi/compare/v0.40.0...v0.41.0

data/docs/configuration.md

@@ -900,6 +900,24 @@ models:
 - `/stats` counts the re-prefilled tokens each applied batch costs; `script/llm_context_bench.rb --strategy
   forget_outputs` replays the offer on stored sessions (docs/internals/llm-context-bench.md).
 
+## LLM context: what you see (✂)
+
+Every edit is shown; the session keeps the originals.
+
+- **A ✂ row** for each batch of stubs that reaches the prompt (`stale`'s, a `forget_outputs` call's, or the ones
+  staged until a turn's end), in the step it came in, in the web and the terminal alike:
+  `✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid off)`. It says why it went now (`paid off`,
+  `the context is nearly full`, `at turn end`; nothing under `next_request`) and how many stubs stay staged. In the
+  web, its hover lists each output (its id, tool and path or command), a stale stub's reason, a forget's note once
+  with the lines it keeps, the tokens it frees and the tail the server reads again. A batch held back, the warm-up's
+  own copy and a restore show no row (the `forget_outputs` row says what a restore did). A reload puts the rows back
+  where they were (`cards.json`, its own cap of 20, apart from hook notices).
+- **A ✂ mark** on a tool row after a reload, above its output, when the model is sent a stub for it:
+  `✂ stubbed: superseded by a later read · ~1.0k tokens`, `✂ forgotten: <note>`, `✂ forgotten with t41` (the
+  other outputs of the call whose row carries the note), `✂ forget staged`, and `· lines 12-40 kept`.
+  The running turn's rows get theirs on the next reload.
+- Tokens are estimates (chars/4), hence the `~`.
+
 ## LLM context: a session's own strategy
 
 A session can set its own `llm_context` strategy, apply rule and budget, which come before the model's, its host's

data/docs/internals/context-telemetry.md

@@ -36,7 +36,10 @@ both loops):
 
 - `llm_context.budget_tokens` (or a model's or host's `llm_context_budget_tokens`): the buckets count against the
   budget instead of the window, the smaller of the two. The event's `window_tokens` and the status line's percentage
-  are of it too, and so is `payoff`'s top bucket.
+  are of it too, and so is `payoff`'s top bucket. Without the forget layer the model's line names it, `[CONTEXT:
+  about 62% of the context budget (64k tokens) is in use (…)]` (the window when that is the smaller), and its top
+  bucket reads "context budget critical — avoid large outputs and re-reads, delegate broad work to subagents": no
+  "summarize", as nothing in the model's hands shrinks the context.
 - The forget layer replaces the guidance with tiered offers of `forget_outputs`, each line a readout,
   `[CONTEXT: ~52k/64k tokens in use (bucket=60plus). …]`: the readout alone in the guided buckets below the top two
   (CLM: how-to at low pressure makes a model wipe everything); "Finish the unit of work in flight, then tidy once

data/docs/internals/engine.md

@@ -298,6 +298,7 @@ Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):
 | `:generation_cancelled` | the turn was cancelled mid-loop | `{iteration, reason, stopped_by}` |
 | `:empty_answer_retry` | an empty, cut or malformed answer is asked again | `{iteration, attempt, of, finish_reason, thinking_chars, stopped_by?, malformed?}` |
 | `:steer_cut` | a steer cut the generation | `{iteration, source}` |
+| `:llm_context_edited` | the apply rule applied a batch of LLM context edits (a request, a forget_outputs call, turn end; never the warm-up) | `{moment, why, freed_tokens, tail_tokens, staged, text, groups}` (`LLMContextNotice`) |
 | `:pending_input_merged` | queued input joined the conversation | `{iteration, count, content, steers?, answer}` |
 | `:tool_dispatch_started` / `:tool_dispatch_completed` | around a batch | `{iteration, call_count}` |
 | `:tool_call_started` | before a call runs | see ToolRunner |

data/lib/samagotchi/bridge/card_store.rb

@@ -16,7 +16,8 @@ module Samagotchi
     # iteration started before it (a before_tool_call hook's notice comes
     # before its call's row, so the web puts it above row calls + 1). The
     # loop's "asking again" row (:empty_answer_retry, after an empty or cut
-    # answer) and a steer's cut row (:steer_cut) are kept the same way, and so is a question the turn asked
+    # answer), a steer's cut row (:steer_cut) and a ✂ row (:llm_context_edited,
+    # LLMContextNotice) are kept the same way, and so is a question the turn asked
     # (:question_requested), with how it was answered or cancelled, so a
     # reload draws the resolved card where it was.
     #
@@ -28,9 +29,10 @@ module Samagotchi
     # as /btw) goes after that turn: its prompt is already in the history.
     # A failed turn leaves no prompt, so its cards stay before the next one.
     #
-    # Notices (hook notices, load warnings, "asking again" rows) and cards
-    # (with questions) are capped apart, +capacity+ each, so a burst of
-    # notices can't push out a card. An open question (an approval too) is
+    # Notices (hook notices, load warnings, "asking again" rows), ✂ rows
+    # and cards (with questions) are capped apart, +capacity+ each, so a
+    # burst of notices can't push out a card, nor a long turn's ✂ rows a
+    # hook's notice. An open question (an approval too) is
     # never pushed out: the oldest other card or answered question goes.
     #
     # With a +path+ (the Bridge's: FILE in the session's folder) the store
@@ -47,11 +49,14 @@ module Samagotchi
     class CardStore
       CAPACITY = 20
       NOTICE_TYPES = %i[hook_notice guardrail_warning empty_answer_retry steer_cut].freeze
+      # Capped apart from the notices.
+      LLM_CONTEXT_TYPES = %i[llm_context_edited].freeze
+      LLM_CONTEXT_FIELDS = %i[type moment why freed_tokens tail_tokens staged text groups].freeze
       FILE = "cards.json"
       # The events after which the file is written again: the ones that
       # change an entry or the turn count.
-      SAVED_ON = (%i[card hook_notice empty_answer_retry steer_cut question_requested question_answered question_cancelled
-                     question_relay turn_failed] + Events::TURN_KEPT).freeze
+      SAVED_ON = (%i[card hook_notice empty_answer_retry steer_cut llm_context_edited question_requested question_answered
+                     question_cancelled question_relay turn_failed] + Events::TURN_KEPT).freeze
 
       # What a session's saved file lists, as a store started from it lists
       # (no turn running): the web's cards for a session no worker runs.
@@ -167,6 +172,7 @@ module Samagotchi
                                             .compact.merge(in_turn: false, turns: @turns_done))
         when :empty_answer_retry then add_turn_row(event.slice(:type, :attempt, :of, :stopped_by, :malformed)) if @running
         when :steer_cut then add_turn_row(event.slice(:type, :source)) if @running
+        when :llm_context_edited then add_turn_row(Marshal.load(Marshal.dump(event.slice(*LLM_CONTEXT_FIELDS)))) if @running
         when :question_requested
           add_turn_row({ type: :question, pending_question: Marshal.load(Marshal.dump(event[:pending_question])) }) if @running
         when :question_answered then resolve_question(event[:id], answer: event[:answer])
@@ -236,15 +242,20 @@ module Samagotchi
 
       def push(entry)
         @entries << entry
-        notice = notice?(entry)
-        kind = @entries.select { |e| notice?(e) == notice }
+        cap = cap_class(entry)
+        kind = @entries.select { |e| cap_class(e) == cap }
         return if kind.size <= @capacity
 
         evict = kind.find { |e| !open_question?(e) }
         @entries.delete_at(@entries.index { |e| e.equal?(evict) }) if evict
       end
 
-      def notice?(entry) = NOTICE_TYPES.include?(entry[:type])
+      # Which cap +entry+ counts against: :notice, :llm_context or :card.
+      def cap_class(entry)
+        return :llm_context if LLM_CONTEXT_TYPES.include?(entry[:type])
+
+        NOTICE_TYPES.include?(entry[:type]) ? :notice : :card
+      end
 
       def open_question?(entry)
         entry[:type] == :question && !entry.key?(:answer) && !entry[:cancelled]

data/lib/samagotchi/bridge/turn_notice.rb

@@ -4,7 +4,8 @@ module Samagotchi
   class Bridge
     # The events a running turn shows as rows of its own (not text, thinking
     # or a tool call): a hook's notice, the loop asking again after an empty
-    # or cut answer, a question and how it was answered. A UI that joins the
+    # or cut answer, a batch of LLM context edits (✂), a question and how it
+    # was answered. A UI that joins the
     # turn mid-way (TurnAccumulator's "notice" part) and one that reloads a
     # finished turn (CardStore) get the event back with the fields listed
     # here, and draw it with the handler that drew it live, where it was.
@@ -13,6 +14,7 @@ module Samagotchi
         hook_notice: %i[hook text level fallback_for],
         empty_answer_retry: %i[iteration attempt of stopped_by malformed],
         steer_cut: %i[iteration source],
+        llm_context_edited: %i[moment why freed_tokens tail_tokens staged text groups],
         question_requested: %i[pending_question],
         question_answered: %i[id answer],
         question_cancelled: %i[id reason]

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.43.0
+version: 0.44.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/context_status.rb

@@ -63,13 +63,21 @@ module Samagotchi
       "context elevated — be concise, prefer range reads, avoid re-reading large files",
       "context critical — summarize aggressively, avoid large outputs, delegate broad work to subagents"
     ].freeze
+    # The top level's words when the buckets count against a budget
+    # (llm_context.budget_tokens) and no forget layer: nothing in the
+    # model's hands shrinks the context, so no "summarize".
+    BUDGET_CRITICAL = "context budget critical — avoid large outputs and re-reads, delegate broad work to subagents"
 
     # @param bucket [String] "under<N>" or "<N>plus"
     # @param thresholds [Array<Integer>] the configured ones, sorted
-    def self.guidance(bucket, thresholds = DEFAULT_THRESHOLDS)
+    # @param budget [Boolean] the buckets count against a budget
+    def self.guidance(bucket, thresholds = DEFAULT_THRESHOLDS, budget: false)
       rank = bucket_rank(bucket, thresholds)
       level = rank < GUIDANCE_FROM_RANK ? 0 : GUIDANCE.size - 1 - (thresholds.size - rank)
-      GUIDANCE[level.clamp(0, GUIDANCE.size - 1)]
+      level = level.clamp(0, GUIDANCE.size - 1)
+      return BUDGET_CRITICAL if budget && level == GUIDANCE.size - 1
+
+      GUIDANCE[level]
     end
 
     # 0 for the bucket under the first threshold, then one per threshold.
@@ -331,11 +339,16 @@ module Samagotchi
 
     def k(tokens) = tokens >= 1000 ? "#{(tokens / 1000.0).round}k" : tokens.to_s
 
+    # The buckets count against the budget (set, and not over the window).
+    def budget_counted?(usage) = !@budget.nil? && usage[:window_tokens] == @budget
+
     def guidance_message(usage:, bucket:)
       how = usage[:source].to_s == "server" ? "as the server reports" : "estimated"
+      budget = budget_counted?(usage)
+      of = budget ? "the context budget (#{k(@budget)} tokens)" : "the context window"
       { role: "system", kind: LINE_KIND,
-        content: "#{LINE_PREFIX}about #{usage[:estimated_pct].to_f.round}% of the context window is in use " \
-                 "(#{how}; bucket=#{bucket}). #{self.class.guidance(bucket, @thresholds)}]" }
+        content: "#{LINE_PREFIX}about #{usage[:estimated_pct].to_f.round}% of #{of} is in use " \
+                 "(#{how}; bucket=#{bucket}). #{self.class.guidance(bucket, @thresholds, budget: budget)}]" }
     end
 
     def status_message(usage:, bucket:)
@@ -350,7 +363,7 @@ module Samagotchi
         bucket: bucket,
         thresholds: @thresholds.join(","),
         src: usage[:source],
-        guidance: self.class.guidance(bucket, @thresholds)
+        guidance: self.class.guidance(bucket, @thresholds, budget: budget_counted?(usage))
       )
     end
   end

data/lib/samagotchi/kernel_loop.rb

@@ -28,6 +28,7 @@ require_relative "tool_ids"
 require_relative "llm_context_view"
 require_relative "llm_context_apply"
 require_relative "llm_context_forget"
+require_relative "llm_context_notice"
 require_relative "answer_display"
 require_relative "llm/model_result"
 require_relative "llm/turn_settings"
@@ -279,7 +280,8 @@ module Samagotchi
     def start_turn(messages, on_stream_event:, cancel_controller:, pending_input:, cap:)
       conversation = prepare_conversation(messages)
       context = ContextStatus.new(conversation: conversation, llm_context: @turn_settings.llm_context)
-      @llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: context)
+      emit = ->(event) { emit_stream_event(on_stream_event, event) }
+      @llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: context, emit: emit)
       Turn.new(
         conversation: conversation, context: context,
         empty_retry: EmptyAnswerRetry.new, empty_steps: [], tool_activity: [], buffer: +"", streamed_thinking: +"",
@@ -290,7 +292,7 @@ module Samagotchi
         prefill: Thinking.native(@turn_settings.thinking || Thinking::DEFAULT, @profile).prefill,
         pending_tool_calls: false, model_name: @turn_settings.model_name, pending_input: pending_input,
         on_stream_event: on_stream_event, cancel_controller: cancel_controller, cap: cap,
-        emit: ->(event) { emit_stream_event(on_stream_event, event) }
+        emit: emit
       )
     end
 
@@ -321,7 +323,7 @@ module Samagotchi
     # (the prompt cache keeps its prefix), and the prompt is formatted again
     # with it.
     def prepare_request(turn)
-      apply_llm_context!(turn.conversation, context: turn.context)
+      apply_llm_context!(turn.conversation, context: turn.context, emit: turn.emit)
       prompt, images = format_prompt(turn)
       image_tokens = images.empty? ? 0 : ImagePlan.estimated_tokens(turn.conversation)
       window = ContextWindow.resolve(client: @client, model: turn.model_name, setting: @turn_settings.window_setting)
@@ -580,7 +582,7 @@ module Samagotchi
       # The model answered: the staged edits reach the session now (a turn
       # that ran out of steps, on tool results or on a retry's nudge, is
       # mid-task; they wait).
-      apply_llm_context!(turn.conversation, moment: :turn_end) if turn.answered
+      apply_llm_context!(turn.conversation, moment: :turn_end, emit: turn.emit) if turn.answered
       # An empty answer left the conversation: an earlier model message
       # isn't this turn's answer.
       output = turn.ended_empty ? "" : strip_thought_blocks(last_model_content(turn.conversation))
@@ -784,8 +786,8 @@ module Samagotchi
         return "Error: forget_outputs is off (the llm_context strategy has no forget layer)"
       end
 
-      LLMContextForget.call(turn, call, llm_context: llm_context,
-                                        apply: -> { apply_llm_context!(turn.conversation, llm_context, context: turn.context) })
+      apply = -> { apply_llm_context!(turn.conversation, llm_context, context: turn.context, emit: turn.emit) }
+      LLMContextForget.call(turn, call, llm_context: llm_context, apply: apply)
     end
 
     # Before each request of both loops (+moment+ :request; the warm-up
@@ -797,10 +799,12 @@ module Samagotchi
     # first, and the warm-up) is the first with the stubs. +context+: the
     # turn's ContextStatus (payoff applies in its top bucket; an applied
     # batch rebases its estimate, ContextStatus#edited!). none changes
-    # nothing. Logged as llm_context_apply when a batch is applied.
+    # nothing. Logged as llm_context_apply when a batch is applied, and
+    # shown to the user as a ✂ row (+emit+ takes the :llm_context_edited
+    # event, LLMContextNotice; the warm-up's own copy has none).
     # @return [LLMContextApply::Outcome]
     def apply_llm_context!(conversation, llm_context = @turn_settings&.llm_context, moment: :request, context: nil,
-                           warmup: false)
+                           warmup: false, emit: nil)
       view = llm_context_view(llm_context)
       return LLMContextApply::Outcome.none if view.none?
 
@@ -811,7 +815,10 @@ module Samagotchi
       if outcome.applied?
         # The prompt just shrank: the context estimate counts from it.
         context&.edited!
-        log_llm_context(outcome, llm_context, moment) unless warmup
+        unless warmup
+          log_llm_context(outcome, llm_context, moment)
+          emit_llm_context(emit, conversation, outcome, moment) if emit
+        end
       end
       outcome
     end
@@ -825,6 +832,14 @@ module Samagotchi
     end
     private :log_llm_context
 
+    # The batch's ✂ row; a row that can't be built never breaks the turn.
+    def emit_llm_context(emit, conversation, outcome, moment)
+      emit.call(LLMContextNotice.event(conversation, outcome, moment: moment))
+    rescue StandardError => e
+      Log.warn(:model, "llm_context_notice_failed", error: e.class.name, message: e.message)
+    end
+    private :emit_llm_context
+
     # A request's re-prefilled tokens, for both loops: of the prompt the
     # last request on +model+ sent (this kernel's, any turn), what the
     # server didn't reuse from its cache this time (that prompt less

data/lib/samagotchi/llm/chat_loop.rb

@@ -358,7 +358,8 @@ module Samagotchi
           # steps from them (ModelResult#empty_steps).
           @empty_steps = []
           @context = ContextStatus.new(conversation: conversation, llm_context: loop.llm_context)
-          loop.llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: @context)
+          loop.llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: @context,
+                                                             emit: method(:emit))
         end
 
         def call(max_iterations:, cap:)
@@ -455,7 +456,7 @@ module Samagotchi
         def generate(iteration)
           # The strategy's edits the apply rule lets through first (stale):
           # this request sends them.
-          @loop.apply_llm_context!(@conversation, context: @context)
+          @loop.apply_llm_context!(@conversation, context: @context, emit: method(:emit))
           window = @window = @loop.context_window(@model_name)
           observe_context(iteration, window)
           retry_generation = @empty_retry.take_sampling!
@@ -640,7 +641,7 @@ module Samagotchi
         def result(text, exhausted:)
           # The model answered: the staged edits reach the session now (a
           # turn that ran out of steps is mid-task; they wait).
-          @loop.apply_llm_context!(@conversation, moment: :turn_end) unless exhausted
+          @loop.apply_llm_context!(@conversation, moment: :turn_end, emit: method(:emit)) unless exhausted
           ModelResult.new(text: text, conversation: @loop.plain(@conversation), exhausted: exhausted,
                           tool_activity: @tool_activity, empty_steps: @empty_steps, empty_retries: @empty_retry.attempts,
                           context_status: @context.display)

data/lib/samagotchi/llm_context_forget.rb

@@ -44,8 +44,12 @@ module Samagotchi
     SMALL = 80
 
     # The turn a forget_outputs call runs in: its conversation (the
-    # entries the edits are saved on) and its ContextStatus (nil: none).
-    Turn = Data.define(:conversation, :context)
+    # entries the edits are saved on), its ContextStatus (nil: none) and
+    # its stream (+emit+, nil: none), which gets an applied batch's ✂ row
+    # (LLMContextNotice).
+    Turn = Data.define(:conversation, :context, :emit) do
+      def initialize(emit: nil, **fields) = super
+    end
 
     # One output a call may name: its entry, its ToolIds ref, its tool,
     # its text (without the "[name]" lead) and its step; +offset+: what

data/lib/samagotchi/llm_context_notice.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "llm_context_stale"
+require_relative "tool_activity"
+require_relative "token_usage"
+
+module Samagotchi
+  # The ✂ row a turn gets for a batch of LLM context edits the apply rule
+  # let through (LLMContextApply::Outcome#applied?): the :llm_context_edited
+  # event both loops emit (KernelLoop#apply_llm_context!, its +emit+), at a
+  # request (+moment+ :request; a forget_outputs call's batch too) or at the
+  # end of a turn (:turn_end); never for the warm-up, a held or a staged
+  # batch, or a restore (the forget_outputs row says it). The web and the
+  # TUI print +text+ as it is; the web's hover lists +groups+.
+  #
+  # {type: :llm_context_edited, moment:, why:, freed_tokens:, tail_tokens:,
+  #  staged:, text: "✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k
+  #  tokens (paid off)", groups: [{kind: "stale", items: [{id, tool, title,
+  #  note}]}, {kind: "forget", note:, by:, items: [{id, tool, title, kept}]}]}
+  #
+  # The stale items share one group, each with its own note; a forget group
+  # is one forget_outputs call's (the view's key: note, by and staged_at),
+  # its note once. Tokens are chars/4, so "~".
+  module LLMContextNotice
+    TYPE = :llm_context_edited
+    # A forget's note on the row, at most (the stub keeps all of it).
+    NOTE_MAX = 300
+    WHY = { payoff: "paid off", top_bucket: "the context is nearly full", turn_end: "at turn end" }.freeze
+
+    module_function
+
+    # @param outcome [LLMContextApply::Outcome] an applied one
+    # @param moment [Symbol] :request or :turn_end
+    # @return [Hash] the event
+    def event(conversation, outcome, moment:, cwd: Dir.pwd)
+      calls = LLMContextStale.paired_runs(conversation).to_h { |run| [run.ref.id, run.call] }
+      groups = groups(outcome.applied, calls, cwd)
+      freed = tokens(outcome.freed_chars)
+      { type: TYPE, moment: moment.to_s, why: outcome.why.to_s, freed_tokens: freed,
+        tail_tokens: tokens(outcome.tail_chars), staged: outcome.staged,
+        text: text(groups, freed, outcome.why, outcome.staged), groups: groups }
+    end
+
+    def groups(edits, calls, cwd)
+      stale = edits.select { |edit| edit.kind == :stale }
+      forgets = edits.select { |edit| edit.kind == :forget }.group_by { |edit| [edit.note, edit.by, edit.staged_at] }
+      groups = []
+      unless stale.empty?
+        groups << { kind: "stale", items: stale.map { |edit| item(edit, calls, cwd).merge(note: edit.note) } }
+      end
+      forgets.each do |(note, by, _), group|
+        items = group.map do |edit|
+          kept = edit.keep.map { |first, last| first == last ? first.to_s : "#{first}-#{last}" }
+          item(edit, calls, cwd).merge(kept: kept.empty? ? nil : kept.join(", ")).compact
+        end
+        groups << { kind: "forget", note: cut(note.to_s), by: by, items: items }
+      end
+      groups
+    end
+
+    # An output's id, its tool and its row's title (ToolActivity.tool_title;
+    # none when its call can't be told).
+    def item(edit, calls, cwd)
+      call = calls[edit.id]
+      return { id: edit.id } unless call
+
+      name = call[:name].to_s
+      { id: edit.id, tool: name, title: ToolActivity.tool_title(name, call, cwd: cwd) }.compact
+    end
+
+    # "✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid
+    # off) · 1 more staged".
+    def text(groups, freed, why, staged)
+      forgot = groups.select { |group| group[:kind] == "forget" }.sum { |group| group[:items].size }
+      stale = groups.select { |group| group[:kind] == "stale" }.sum { |group| group[:items].size }
+      done = []
+      done << "forgot #{count(forgot, "output")}" if forgot.positive?
+      done << "stubbed #{count(stale, "stale read")}" if stale.positive?
+      frees = freed.positive? ? "frees ~#{k(freed)}" : "frees nothing"
+      frees += " (#{WHY[why]})" if WHY.key?(why)
+      line = "✂ #{done.join(", ")} · #{frees}"
+      staged.positive? ? "#{line} · #{staged} more staged" : line
+    end
+
+    def count(number, noun) = "#{number} #{noun}#{"s" unless number == 1}"
+
+    def tokens(chars) = [(chars / TokenUsage::CHARS_PER_TOKEN).ceil, 0].max
+
+    # "4.1k tokens", "640 tokens".
+    def k(tokens) = tokens >= 1000 ? format("%.1fk tokens", tokens / 1000.0) : "#{tokens} tokens"
+
+    def cut(note) = note.length > NOTE_MAX ? "#{note[0, NOTE_MAX - 1]}…" : note
+
+    private_class_method :groups, :item, :text, :count, :tokens, :k, :cut
+  end
+end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1222,7 +1222,8 @@ module Samagotchi
           # hook's notice, a retry's line), as they were drawn live.
           # Questions are left out: the pending one is asked after the
           # replay, answered ones showed no line.
-          when :turn_started, :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut then @renderer.call(event)
+          when :turn_started, :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut, :llm_context_edited
+            @renderer.call(event)
           end
         end
         @view.resume(tail: tail, lane: lane, tool: running_tool, parts: turn[:parts])

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -83,6 +83,9 @@ module Samagotchi
         when :steer_cut
           @view.finish_thinking_spinner
           @view.print_line(@view.format_steer_cut_line(event))
+        when :llm_context_edited
+          @view.finish_thinking_spinner
+          @view.print_line(@view.format_llm_context_line(event))
         when :turn_completed
           render_turn_summary(event[:turn_summary]) if event[:turn_summary]
         when :turn_canceled

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)

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/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -1658,6 +1658,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 +1691,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 +1759,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");
@@ -1527,11 +1527,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 +1629,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");
@@ -2191,6 +2199,9 @@ const streamHandlers = {
   // (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) }); },
+  // 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)),

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

@@ -172,6 +172,8 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .activity-output{flex:1 1 100%;min-width:0}
 /* An edit/write's change: a closed "diff +3 −1" under the output, lined up with it. */
 .activity-diff{flex:1 1 100%;min-width:0;margin:2px 0 2px var(--row-gutter)}
+/* A reloaded row's ✂ mark (an LLM context edit on its output), one line above the output. */
+.activity-edit{flex:1 1 100%;min-width:0;margin:2px 0 0 var(--row-gutter);font-size:12px;color:var(--text-3);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;cursor:help}
 .activity-diff>summary{cursor:pointer;font-size:12px;color:var(--text-muted);width:max-content;font-variant-numeric:tabular-nums}
 .activity-diff>summary:hover{color:var(--text-2)}
 .activity-diff[open]>summary{margin-bottom:4px}
@@ -212,6 +214,7 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
   .activity-params{flex:1 1 0}
   .activity-output{margin-left:0}
   .activity-diff{margin-left:0}
+  .activity-edit{margin-left:0}
   .activity-row>.activity-command{margin-left:0}
 }
 .bubble.thinking{border-left:3px solid var(--think);background:color-mix(in srgb,var(--think) 6%,var(--bg-panel));padding:8px 12px}
@@ -374,6 +377,7 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .gen .hook-notice{font-size:13px;color:var(--text-3);padding:5px 2px 5px 8px;border-top:1px solid var(--border);border-left:2px solid var(--text-faint);white-space:pre-wrap;word-break:break-word}
 .gen .activity-body>.hook-notice:first-child{border-top:none}
 .gen .hook-notice.warn{border-left-color:var(--warn);color:var(--warn-text)}
+.hook-notice.llm-context{border-left-style:dashed;cursor:help}
 /* A plugin's steer (a nudge into the running turn): a row of its step, or a bubble; its text collapsed. */
 .steer-row{font-size:13px;color:var(--text-3);border-left:2px solid var(--accent-border)}
 .steer-row>summary{cursor:pointer;list-style:none;font-style:italic}

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

@@ -156,6 +156,39 @@ export function steerCutLine({ source } = {}) {
   return `↪ cut in for ${STEER_CUT_FOR[source] || "your message"}`;
 }
 
+// The ✂ row of a batch of LLM context edits the server applied
+// (llm_context_edited, LLMContextNotice): its line as the server built
+// it ("✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens"),
+// so the web and the TUI say the same.
+export function llmContextLine({ text } = {}) {
+  return text || "✂ LLM context edited";
+}
+
+// The ✂ row's hover: what each group did, one line per output (its id,
+// tool and title), and what the batch costs ("~": chars/4).
+export function llmContextHover({ groups = [], freed_tokens: freed, tail_tokens: tail, staged, moment } = {}) {
+  const lines = [];
+  const output = (item) => [item.id, item.tool, item.title].filter(Boolean).join(" ");
+  for (const group of Array.isArray(groups) ? groups : []) {
+    const items = Array.isArray(group.items) ? group.items : [];
+    if (group.kind === "stale") {
+      lines.push("Stubbed as stale:");
+      for (const item of items) lines.push(`  ${output(item)}${item.note ? ` — ${item.note}` : ""}`);
+    } else if (group.kind === "forget") {
+      lines.push(`Forgotten by the ${group.by || "model"}: ${group.note || ""}`);
+      for (const item of items) lines.push(`  ${output(item)}${item.kept ? ` · lines ${item.kept} kept` : ""}`);
+    }
+  }
+  const cost = [];
+  if (Number(freed) > 0) cost.push(`frees ~${freed} tokens`);
+  if (Number(tail) > 0) cost.push(`the server reads ~${tail} tokens again`);
+  if (cost.length) lines.push(cost.join("; "));
+  if (Number(staged) > 0) lines.push(`${staged} more staged until the turn ends`);
+  lines.push(moment === "turn_end" ? "Sent from the next turn on." : "Sent from the next request on.");
+  lines.push("The session keeps the originals.");
+  return lines.join("\n");
+}
+
 // The one muted line for a turn that ended with no answer (turn_completed's
 // turn_summary.empty_answer, or a reloaded turn's marker): the TUI words
 // it the same (TurnNote.empty_answer_line; spec/shared/labels_matrix.json).
@@ -170,6 +203,7 @@ export function emptyAnswerLine({ retries = 0 } = {}) {
 export function noticeLine(entry = {}) {
   if (entry.type === "empty_answer_retry") return emptyRetryLine(entry);
   if (entry.type === "steer_cut") return steerCutLine(entry);
+  if (entry.type === "llm_context_edited") return llmContextLine(entry);
   return `${hookNoticeLabel(entry.hook)}: ${entry.text || ""}`;
 }
 

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

@@ -33,12 +33,43 @@ function statusWordHtml({ cls, word }) {
   return word ? `<span class="activity-state ${cls}">${word}</span>` : "";
 }
 
+// A reloaded row's ✂ mark: what an LLM context edit saved on its output
+// sends the model instead (MessageParts.edit_marks): a stale stub and
+// what it frees, a forget's note (or the output whose row carries it) and
+// its kept lines, a forget still staged. The live rows get none (a reload
+// shows them).
+export function llmEditLine(edit) {
+  if (!edit || typeof edit !== "object") return "";
+  const kept = edit.kept ? ` · lines ${edit.kept} kept` : "";
+  if (edit.kind === "forget") {
+    if (edit.staged) return `✂ forget staged${kept}`;
+    return `${edit.with ? `✂ forgotten with ${edit.with}` : `✂ forgotten: ${edit.note || ""}`}${kept}`;
+  }
+  if (edit.kind === "stale") {
+    const tokens = Number(edit.tokens) > 0 ? ` · ~${compactTokens(Number(edit.tokens))}` : "";
+    return `✂ stubbed: ${edit.note || "stale"}${tokens}`;
+  }
+  return "";
+}
+
+function compactTokens(n) {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}k tokens` : `${n} tokens`;
+}
+
+function llmEditHtml(row) {
+  const line = llmEditLine(row.edit);
+  if (!line) return "";
+  const hover = `${row.tool_id ? `${row.tool_id}: ` : ""}${line}\nThe model is sent this instead of the output; the session keeps it.`;
+  return `<div class="activity-edit" title="${escapeHtml(hover)}">${escapeHtml(line)}</div>`;
+}
+
 // A tool row: its status mark, tool, title (else params; the full command,
 // else the full params line, on hover), the word an exception shows, the
 // call's duration, the full command (an execute/task_create's view, also
 // while it runs), the output once done (its "[tool]" tag dropped, 300 chars,
 // the rest on hover), its images (+thumbs+(images) draws them) and an
-// edit's collapsed diff. A part with nothing to say is left out.
+// edit's collapsed diff, and a reloaded row's ✂ mark above its output. A
+// part with nothing to say is left out.
 export function toolRowHtml(row, { thumbs = () => "" } = {}) {
   return `<div class="activity-row" data-key="${escapeHtml(row.key)}">${toolRowInnerHtml(row, { thumbs })}</div>`;
 }
@@ -55,7 +86,7 @@ export function toolRowInnerHtml(row, { thumbs = () => "" } = {}) {
   const status = statusParts(row.status);
   return `${statusMarkHtml(status)}<span class="activity-tool">${escapeHtml(toolName(row))}</span>${params}${statusWordHtml(status)}` +
     `${duration ? `<span class="activity-duration">${escapeHtml(duration)}</span>` : ""}` +
-    `${commandBlockHtml(row.view, row.title)}${output}` +
+    `${commandBlockHtml(row.view, row.title)}${llmEditHtml(row)}${output}` +
     `${row.images?.length ? thumbs(row.images) : ""}${row.diff ? activityDiffHtml(row.diff) : ""}`;
 }
 

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

@@ -422,15 +422,17 @@ export function createTurnView({
   // A hook's line (hook_notice) as a row of the current step, above the row
   // of the call it judged; false with no running turn (app.js shows the
   // bubble then). data.line is a whole row of chi's own (an empty-answer
-  // retry), shown as is.
+  // retry), shown as is; data.cls a class of its own and data.title its
+  // hover (a ✂ row's).
   function notice(data) {
     const r = turn && model.notice(turn, data);
     if (!r) return false;
     const entry = genEls.get(r.gen);
     if (!r.gen.text) entry.text.textContent = "";
     const el = document.createElement("div");
-    el.className = "hook-notice" + (data.level === "warn" ? " warn" : "");
+    el.className = "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 stick = isNearBottom();
     activityEl(r.gen).appendChild(el);
     if (stick) follow();

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.43.0
+  version: 0.44.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -315,6 +315,7 @@ files:
 - lib/samagotchi/llm_context_command.rb
 - lib/samagotchi/llm_context_edit.rb
 - lib/samagotchi/llm_context_forget.rb
+- lib/samagotchi/llm_context_notice.rb
 - lib/samagotchi/llm_context_override.rb
 - lib/samagotchi/llm_context_stale.rb
 - lib/samagotchi/llm_context_strategy.rb