samagotchi 0.75.0 → 0.77.0

data/lib/samagotchi/answer_command.rb

@@ -117,7 +117,7 @@ module Samagotchi
       # turn queued behind it; nil (an older worker): the next reply.
       turn = ReplyWait.own_turn(session, session_dir: Session.session_dir(id, state_dir: @state_dir))
 
-      if pending && pending[:id].to_s == qid
+      if pending && pending.id.to_s == qid
         return failure(not_dismissable(pending)) if options[:dismiss] && ParentReport.continue?(pending)
 
         selected = selection(pending, options) or return @selection_status
@@ -140,7 +140,7 @@ module Samagotchi
     # exact label wins over a number.
     # @return [Array<String>, nil] nil after a usage error
     def selection(pending, options)
-      offered = Array(pending[:options]).map(&:to_s)
+      offered = Array(pending.options).map(&:to_s)
       labels = options[:options].map do |given|
         next given if offered.include?(given)
 
@@ -151,7 +151,7 @@ module Samagotchi
         @selection_status = usage_failure("no option #{given}; the options: #{listed}")
         return nil
       end
-      if labels.uniq.size > 1 && !pending[:multi_select]
+      if labels.uniq.size > 1 && !pending.multi_select
         @selection_status = usage_failure("one option only: the question is single-select")
         return nil
       end
@@ -163,7 +163,7 @@ module Samagotchi
     # Deny, text alone or a dismissal always passes: each one denies. The
     # worker checks it again with its own config.
     def approval_refusal(pending, selected, _id)
-      offered = Array(pending[:options]).map(&:to_s)
+      offered = Array(pending.options).map(&:to_s)
       indices = selected.map { |label| offered.index(label) }
       reason = Guardrails::ParentApprovals.refusal(pending, indices, setting: Guardrails::ParentApprovals.setting)
       reason && Guardrails::ParentApprovals.message(reason)
@@ -177,7 +177,7 @@ module Samagotchi
 
     # A step-limit question can't be left unanswered: the turn waits on it.
     def not_dismissable(pending)
-      "the step-limit question can't be dismissed: answer #{Array(pending[:options]).join(" or ")} " \
+      "the step-limit question can't be dismissed: answer #{Array(pending.options).join(" or ")} " \
         "(--option Stop --text WHY stops it)"
     end
 

data/lib/samagotchi/bridge.rb

@@ -260,7 +260,7 @@ module Samagotchi
           recap: @accumulator.recap,
           saved_recap: @engine.saved_recap,
           continue_offer: @accumulator.continue_offer,
-          pending_question: @engine.pending_question,
+          pending_question: @engine.pending_question&.to_h,
           guardrail_warning: @engine.guardrail_warning,
           plugin_warning: @engine.plugin_warning,
           init_tasks: @engine.init_tasks,
@@ -1178,8 +1178,8 @@ module Samagotchi
     # still that relay's.
     def relay_closed(qid, relay_id, reason)
       pending = @engine.pending_question
-      relay = pending && pending[:relayed_to]
-      unless pending && pending[:id].to_s == qid && relay && (relay[:relay_id] || relay["relay_id"]).to_s == relay_id
+      relay = pending&.relayed_to
+      unless pending && pending.id.to_s == qid && relay && (relay[:relay_id] || relay["relay_id"]).to_s == relay_id
         return [{}, 409, { error: "question_not_pending", detail: "no question #{qid} relayed by #{relay_id}" }]
       end
       return [{}, 409, { error: "question_not_pending", detail: "no pending question #{qid}" }] unless @engine.annotate_question(qid, relayed_to: nil, reason: reason)

data/lib/samagotchi/bundle_command.rb

@@ -146,8 +146,12 @@ module Samagotchi
         return install_profile(expanded_source, scope: scope, force: force, dry_run: false, word: "Install")
       end
 
-      bundle_name = bundle_name_or_fail(expanded_source, "Install") or return 1
-      run_installer(installer_for(expanded_source, bundle_name, scope: scope, force: force), failed: "Install") do |manifest|
+      prepared, bundle_name = prepare_or_fail(expanded_source, "Install")
+      return 1 unless prepared
+      return 1 if installed_under_another_name?(expanded_source, bundle_name, prepared, "Install")
+
+      installer = installer_for(expanded_source, bundle_name, prepared: prepared, scope: scope, force: force)
+      run_installer(installer, failed: "Install") do |manifest|
         print_hooks_and_plugin(manifest)
         print_provenance(bundle_name, manifest)
       end
@@ -164,7 +168,7 @@ module Samagotchi
       dry_run = opts.fetch(:dry_run, false)
       agent = opts[:agent]
       if source.nil? || source.empty?
-        @stderr.puts "Usage: chi bundle upgrade <source> [--scope system|project] [--force] [--dry-run]"
+        @stderr.puts UPGRADE_HELP
         return CLI::Exit::USAGE
       end
       expanded_source = expand_source(source)
@@ -172,18 +176,21 @@ module Samagotchi
         return install_profile(expanded_source, scope: scope, force: force, dry_run: dry_run, word: "Upgrade")
       end
 
-      bundle_name = bundle_name_or_fail(expanded_source, "Upgrade") or return 1
+      prepared, bundle_name = prepare_or_fail(expanded_source, "Upgrade")
+      return 1 unless prepared
+      return 1 if installed_under_another_name?(expanded_source, bundle_name, prepared, "Upgrade")
+
       unless Samagotchi::MemoryBundle::Provenance.new(name: bundle_name).installed?
         @stderr.puts "Bundle '#{bundle_name}' not installed — falling back to install"
         # (no Hooks/Plugin lines here)
-        installer = installer_for(expanded_source, bundle_name, scope: scope, force: force, dry_run: dry_run)
+        installer = installer_for(expanded_source, bundle_name, prepared: prepared, scope: scope, force: force, dry_run: dry_run)
         return run_installer(installer, failed: "Install") do |manifest|
           next dry_run_done if dry_run
 
           print_provenance(bundle_name, manifest)
         end
       end
-      installer = installer_for(expanded_source, bundle_name, scope: scope, force: force, upgrade: true, dry_run: dry_run)
+      installer = installer_for(expanded_source, bundle_name, prepared: prepared, scope: scope, force: force, upgrade: true, dry_run: dry_run)
       run_installer(installer, failed: "Upgrade") do |manifest|
         print_hooks_and_plugin(manifest, plugin: !dry_run)
         next dry_run_done if dry_run
@@ -193,12 +200,44 @@ module Samagotchi
       end
     end
 
-    # The bundle's name, or nil after "<word> failed: …".
-    def bundle_name_or_fail(expanded_source, word)
-      bundle_name_for(expanded_source)
-    rescue Samagotchi::MemoryBundle::SourceNormalizer::UnknownSourceError => e
+    # The source normalized once (a git clone, a zip or tar extract) and the
+    # bundle's name, its manifest's name: for every kind of source, a git URL
+    # too. The Installer installs from that extract and removes it. Nil
+    # after "<word> failed: …" (an unknown source, or a missing or invalid
+    # manifest: an install needs one anyway), the extract removed.
+    # @return [Array(MemoryBundle::PreparedSource, String), nil]
+    def prepare_or_fail(expanded_source, word)
+      prepared = Samagotchi::MemoryBundle::PreparedSource.prepare(expanded_source)
+      named = [prepared, Samagotchi::MemoryBundle::Manifest.read(dir: prepared.dir).name]
+    rescue Samagotchi::MemoryBundle::SourceNormalizer::UnknownSourceError,
+           Samagotchi::MemoryBundle::Manifest::ValidationError => e
       @stderr.puts "#{word} failed: #{e.message}"
-      nil
+    ensure
+      # Any failure (an unexpected error too) removes the extract.
+      prepared&.cleanup unless named
+    end
+
+    # A bundle installed from this source under another name: a git URL
+    # bundle recorded before chi named it by its manifest (it took the
+    # repo's name, chi-foo for name: foo). Installing it again would load
+    # both copies' plugin and hooks, so "<word> failed: … installed as
+    # chi-foo" instead (the extract removed). Only when no bundle has the
+    # manifest's name; sources compare by SourceIdentity.
+    # @return [Boolean] refused
+    def installed_under_another_name?(expanded_source, bundle_name, prepared, word)
+      return false if Samagotchi::MemoryBundle::Provenance.new(name: bundle_name).installed?
+
+      identity = Samagotchi::MemoryBundle::SourceIdentity.of(expanded_source)
+      return false unless identity
+
+      other, = Samagotchi::MemoryBundle::Provenance.each_installed.find do |name, bundle|
+        name != bundle_name && !bundle.error? && Samagotchi::MemoryBundle::SourceIdentity.of(bundle.source) == identity
+      end
+      return false unless other
+
+      prepared.cleanup
+      @stderr.puts "#{word} failed: #{expanded_source} is installed as #{other}: `chi bundle uninstall #{other}`, then install it again"
+      true
     end
 
     def installer_for(source, name, scope:, force:, **)
@@ -728,40 +767,14 @@ module Samagotchi
       parsed
     end
 
-    # helpers for bundle_name derivation
+    # The source as given: a git URL as is, a shipped bundle's name as its
+    # dir, anything else as an expanded path.
     def expand_source(src)
       return src if Samagotchi::MemoryBundle::SourceNormalizer.git_url?(src)
 
       Samagotchi::MemoryBundle::SourceNormalizer.shipped_bundle_dir(src) || File.expand_path(src)
     end
 
-    def bundle_name_for(expanded_src)
-      # Try to derive from manifest if possible (skip git clone for speed if possible)
-      if Samagotchi::MemoryBundle::SourceNormalizer.git_url?(expanded_src)
-        # For git URLs, avoid double clone: derive name from URL basename if no manifest yet
-        # Let Installer do the real manifest read; fallback to URL basename
-        base = expanded_src.split("/").last.to_s.split("#").first.to_s
-        base = base.sub(/\.git\z/i, "")
-        return base.empty? ? "bundle" : base
-      end
-      require "yaml"
-      nd = nil
-      owned = false
-      begin
-        nd, owned = Samagotchi::MemoryBundle::SourceNormalizer.normalize(expanded_src)
-        m = Samagotchi::MemoryBundle::Manifest.read(dir: nd)
-        m.name
-      rescue Samagotchi::MemoryBundle::Manifest::ValidationError
-        # Fallback to source basename without archive extensions
-        src = expanded_src
-        name = File.basename(src)
-        name = name.sub(/\.tar\.gz\z/i, "").sub(/\.tgz\z/i, "").sub(/\.zip\z/i, "").sub(/\.tar\z/i, "")
-        name.empty? ? File.basename(nd || src) : name
-      ensure
-        Samagotchi::MemoryBundle::SourceNormalizer.cleanup(nd) if owned
-      end
-    end
-
     def build_conflict_prompt(bundle_name, conflicts, expanded_source)
       lines = []
       lines << "Memory bundle upgrade has conflicts that need interactive resolution."

data/lib/samagotchi/bundles/codex-peer/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: codex-peer
-version: 0.3.1
+version: 0.3.2
 scope: system
 description: "Pair this session with an OpenAI Codex CLI session you work with: the codex_send tool and /codex send it a part of the work (a plan step, a diff, a finding) to validate or as context, with codex queue, and Codex's answer comes back as the codex-outbox context; /codex install-skill installs Codex's chi-peer skill, which pairs"
 trust_level: reviewed
@@ -10,7 +10,7 @@ files:
     description: "Send a part of the work to the paired Codex CLI session (codex_send): only when the user asks, or to reply to its answer in a peer turn; validate, context or question; Codex's answer comes as the codex-outbox context"
 plugin:
   file: plugin.rb
-  sha256: sha256:eb6888e3611b8ed42498cfecab5b430e0ef7a4c2dc7b3c090d015336aa039b11
+  sha256: sha256:b03465566272891237ac1906980ff6956579a4703d3a42c414ce50a81de551f6
 scripts:
   pair: sha256:251448a31959b5c916400eff7909e85c696855d5c16b6b10973ada40915c8051
   chi-peer-SKILL.md: sha256:7c392ac04c115ea1e762ad562b5c4c44c3eca71558ba5d9dfeaeabdd533b6a82

data/lib/samagotchi/bundles/codex-peer/plugin.rb

@@ -168,10 +168,16 @@ class Plugin < Samagotchi::Plugin::Peer
   # [stdout, stderr, status]; both pipes read on threads, so a full one
   # can't block the command.
   def run(*command)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + QUEUE_SECONDS
     Open3.popen3(*command, pgroup: true) do |stdin, stdout, stderr, wait|
       stdin.close
       out, err = [stdout, stderr].map { |io| Thread.new { io.read }.tap { |t| t.report_on_exception = false } }
-      unless wait.join(QUEUE_SECONDS)
+      threads = [wait, out, err]
+      within_deadline = lambda do |thread|
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        thread.join([remaining, 0].max)
+      end
+      unless threads.all?(&within_deadline)
         begin
           Process.kill("KILL", -wait.pid)
         rescue SystemCallError
@@ -179,7 +185,18 @@ class Plugin < Samagotchi::Plugin::Peer
         end
         # The group is gone, so the pipes end: let the readers finish
         # before popen3 closes them.
-        [wait, out, err].each { |t| t.join(1) }
+        cleanup_deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 1
+        threads.each do |thread|
+          remaining = cleanup_deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          thread.join([remaining, 0].max)
+        end
+        # The queue itself finished fine, and only a process it left held
+        # the pipes: the message is likely queued, so don't say "try again"
+        # (a retry would deliver it twice).
+        if wait.join(0) && wait.value.success?
+          raise SendError, "codex queue exited but left a process holding its output (stopped after " \
+                           "#{QUEUE_SECONDS} s): the message may already be queued, check Codex before sending again"
+        end
         raise SendError, "Codex didn't take the message in #{QUEUE_SECONDS} s (codex queue was stopped): try " \
                          "again, or pair again from Codex"
       end

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

@@ -1,10 +1,10 @@
 ---
 name: core
-version: 0.3.0
+version: 0.3.1
 scope: system
 description: "Recommended safety set"
 trust_level: reviewed
-requires_chi: ">= 0.8.0"
+requires_chi: ">= 0.60.0"
 includes:
 - loop-guard
 - check-in

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

@@ -1,10 +1,10 @@
 ---
 name: dev
-version: 0.5.0
+version: 0.5.1
 scope: system
 description: "Developer tools"
 trust_level: reviewed
-requires_chi: ">= 0.34.0"
+requires_chi: ">= 0.72.0"
 includes:
 - known-names
 - mcp

data/lib/samagotchi/bundles/source-links/hooks/source_links.rb

@@ -76,6 +76,7 @@ class SourceLinks
   # A bare URL (scheme-anchored, so it can't start inside a markdown label),
   # and a markdown link (label in group 1, target in group 2).
   URL_SPAN = %r{[a-z][a-z0-9+.-]*://\S+}i
+  TRAILING_URL_PUNCTUATION = /[.,;:!?'"]+\z/
   MARKDOWN_LINK = /\[([^\]]*)\]\(([^)]*)\)/
   # A fenced code block's opening line (up to 3 spaces, then ``` or ~~~).
   FENCE_OPEN = /\A {0,3}(`{3,}|~{3,})/
@@ -328,35 +329,36 @@ class SourceLinks
 
   # The [start, end) character ranges of the answer that are a bare URL
   # (scheme-anchored, `[a-z][a-z0-9+.\-]*://\S+`). A ref inside one is not
-  # linked again. The span stops at the first `)` that no `(` inside the URL
-  # balances — so `(https://x.com/a)` ends before the `)`, while
-  # `…/Foo_(bar)` keeps it.
+  # linked again. Trailing punctuation and a trailing `]` without a `[` are
+  # excluded; balanced parentheses and brackets stay part of the URL.
   def bare_url_spans(text)
     spans = []
     text.scan(URL_SPAN) do
       match = Regexp.last_match
-      finish = trim_url_end(match[0], match.begin(0), match.end(0))
+      finish = trim_url_end(match[0], match.begin(0))
       spans << [match.begin(0), finish] if finish > match.begin(0)
     end
     spans
   end
 
-  # The end offset of a URL match after trimming its tail: the span stops at
-  # the first `)` that no `(` inside the URL balances.
-  def trim_url_end(url, start, finish)
+  # The end offset of a URL match after trimming it like notice_links.js.
+  def trim_url_end(url, start)
+    trimmed = url.sub(TRAILING_URL_PUNCTUATION, "")
     depth = 0
-    url.each_char.with_index do |char, index|
+    trimmed.each_char.with_index do |char, index|
       if char == "("
         depth += 1
       elsif char == ")"
         if depth.zero?
-          finish = start + index
+          trimmed = trimmed[0...index]
           break
         end
         depth -= 1
       end
     end
-    finish
+    trimmed = trimmed.sub(/\]+\z/, "") if trimmed.end_with?("]") && !trimmed.include?("[")
+    trimmed = trimmed.sub(TRAILING_URL_PUNCTUATION, "")
+    start + trimmed.length
   end
 
   # A markdown link's label and target ranges, with the target text. A ref in

data/lib/samagotchi/bundles/source-links/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: source-links
-version: 0.5.0
+version: 0.5.1
 scope: system
 description: Links source refs (JIRA tickets, GitHub issues, …) in the model's answer — inline links in the web, and a one-line note after the turn (note false turns it off); sources are configured patterns
 trust_level: reviewed
@@ -9,7 +9,7 @@ files:
   source_links.md: sha256:ace01a0f7c308a0ae54ece714c31c0e6d7a49c372d98111030e6d268320bed3a
 hooks:
   source_links.rb:
-    sha256: sha256:8d84c68be88972737905925bc9fc4bd941007fb945e8104e9f6b3d61a1186b89
+    sha256: sha256:c41249ec0bbb708ec7827e1d0f66689dfbbc415c1da5fe33f5d3a8ec8e5eaa2f
     event: after_turn
     on_error: log
     priority: 90

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

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

data/lib/samagotchi/child_reports.rb

@@ -254,7 +254,7 @@ module Samagotchi
     def reportable?(wait)
       case wait.status
       when :done, :no_reply, :error then true
-      when :waiting_for_answer then [nil, "", "continue"].include?(wait.question&.dig(:kind)&.to_s)
+      when :waiting_for_answer then [nil, "", "continue"].include?(wait.question&.kind&.to_s)
       else false
       end
     end

data/lib/samagotchi/desktop/macos.rb

@@ -152,8 +152,7 @@ module Samagotchi
       def launch_config
         env = { "LANG" => LANG }
         ENV_ALLOWLIST.each { |name| env[name] = @env[name] unless @env[name].to_s.empty? }
-        env["XDG_CONFIG_HOME"] = Paths.config_home(env: @env) if env.key?("XDG_CONFIG_HOME")
-        env["XDG_STATE_HOME"] = Paths.state_home(env: @env) if env.key?("XDG_STATE_HOME")
+        env.merge!(Paths.absolute_xdg(env: env, set: :key))
         config = { "version" => @version, "argv" => [@ruby, @chi_path], "env" => env, "sources_sha" => sources_sha }
         TERMINALS.each { |name| config[name] = @terminals[name] if @terminals[name] }
         config["broadcast_timeout"] = @broadcast_timeout if @broadcast_timeout

data/lib/samagotchi/effective_model.rb

@@ -168,6 +168,11 @@ module Samagotchi
       unresolved(:window_unresolved, e, nil)
     end
 
+    # The window config.yml gives this model or its host
+    # (ContextWindow.setting), never asking a server: a session loaded on
+    # it (Engine#session=, before a worker's Bridge serves). nil when none.
+    def configured_context_window = ContextWindow.setting(target, names: names)
+
     # The window as its loop would see it (ChatLoop#context_window: a remote
     # chat host has no /props, only its model list); nil when it can't be
     # resolved.

data/lib/samagotchi/engine.rb

@@ -242,10 +242,7 @@ module Samagotchi
       wire_kernel(kernel, muted_memories)
       Log.debug(:model, "backend", provider: backend.provider) if Log.level?(:debug)
       @resume_session = session_id ? Session.load(session_id) : nil
-      @prompt_builder = SystemPrompt.new(profile: -> { self.profile }, tools: -> { @tools }, session: -> { @session },
-                                         thinking: -> { turn_thinking }, model: -> { model_identity },
-                                         model_notes: -> { model_notes }, memories: memories,
-                                         muted_memory_names: @muted_memory_names, appended_files: appended_prompt_files)
+      @prompt_builder = build_system_prompt(memories, appended_prompt_files)
       @session = nil
       @session_observer = SessionObserver.new
       @metrics = SessionMetrics.new
@@ -268,10 +265,7 @@ module Samagotchi
       # One shared poller for the whole idle layer (reminders + optional
       # recap). Both jobs read the activity seam above; the scheduler owns
       # the single background thread and isolates per-job failures.
-      @idle_scheduler = IdleScheduler.new(
-        engine: self,
-        jobs: [@reminders, @recap].compact
-      )
+      @idle_scheduler = build_idle_scheduler
       subscribe_session_observers
     end
 
@@ -388,6 +382,21 @@ module Samagotchi
     end
     private :build_plugin_tasks
 
+    # The system prompt's live sources and this session's fixed inputs.
+    def build_system_prompt(memories, appended_prompt_files)
+      SystemPrompt.new(profile: -> { profile }, tools: -> { @tools }, session: -> { @session },
+                       thinking: -> { turn_thinking }, model: -> { model_identity },
+                       model_notes: -> { model_notes }, memories: memories,
+                       muted_memory_names: @muted_memory_names, appended_files: appended_prompt_files)
+    end
+    private :build_system_prompt
+
+    # The idle layer's shared scheduler (see #initialize for when).
+    def build_idle_scheduler
+      IdleScheduler.new(engine: self, jobs: [@reminders, @recap].compact)
+    end
+    private :build_idle_scheduler
+
     # A monotonically-increasing clock (wall clock can jump backwards; the idle
     # detector must never treat a jump as "activity"). Injectable for specs.
     def monotonic_now
@@ -1005,6 +1014,9 @@ module Samagotchi
       sync_kernel_client!
       @client.invalidate_context_window!
       @metrics.forget_model_reports!
+      # The last turn's ctx % was the old model's window's
+      # (#announce_switched_context! sends the new one's).
+      @last_context_status = nil
       ref = effective_model_ref
       if persist_default
         ConfigFile.write_default_model!(ref)
@@ -1013,6 +1025,42 @@ module Samagotchi
       ref
     end
 
+    # After /model: how full the context is on the new model's window,
+    # before its first turn: the last turn's count (the old model's
+    # tokenizer's, replaced at the next generation) against the new model's
+    # window (EffectiveModel#context_window, ContextWindow.resolve: the
+    # running server first, one /props GET that a remote chat host is
+    # spared; else the host's cached model list; else the configured
+    # window) and the
+    # session's budget. Sent as a :context_status event (the web's ctx
+    # meter, the attached TUI's status row) with context_window_tokens, and
+    # kept for a client that joins later (#session_state_snapshot; the
+    # window in the metrics' context too, which a page counts from). A window
+    # that can't be resolved sends usage nil: the UIs clear the % until the
+    # next generation. Nothing before the session's first counted turn.
+    # +configured_only+: the configured window only, never asking a server
+    # (EffectiveModel#configured_context_window): a loaded session's (#session=).
+    # @return [Hash, nil] the event sent
+    def announce_switched_context!(configured_only: false)
+      used = @metrics.snapshot.dig(:context, :used_tokens)
+      return nil unless used.is_a?(Integer)
+
+      model = effective_model
+      window = configured_only ? model.configured_context_window : current_context_window(model)
+      display = window && saved_context_status({ used_tokens: used, window_tokens: window.tokens })
+      @last_context_status = display&.dup
+      @metrics.note_context_window(window.tokens, window.source) if window
+      usage = display && { estimated_pct: display[:est_pct], estimated_used_tokens: used, window_tokens: window.tokens,
+                           window_source: window.source.to_s, source: "switch" }
+      event = { type: :context_status, usage: usage, bucket: display&.dig(:bucket),
+                context_window_tokens: window&.tokens, context_window_source: window&.source&.to_s }
+      @session_observer.notify(event)
+      event
+    rescue StandardError => e
+      Log.warn(:model, "switched_context_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      nil
+    end
+
     # ── Hooks API ──────────────────────────────────────────────────────────────
 
     # Register a hook callback for a named lifecycle event.
@@ -1179,7 +1227,7 @@ module Samagotchi
     #   :last_prompt   [String, nil] the last user prompt (empty string if none)
     #   :event_seq     [Integer]   @session_observer.event_count
     #   :metrics       [Hash]      @metrics.snapshot (per-session analytics)
-    #   :pending_question [Hash, nil] current pending structured question
+    #   :pending_question [Hash, nil] the pending question (PendingQuestion#to_h)
     #   :used_memory_names [Array<String>] deduped memory names active this session
     #   :prompt_notes  [Array<Hash>] the model notes the prompt carried
     #     ({name:, scope:, chars:, digest:}; #prompt_notes)
@@ -1205,7 +1253,7 @@ module Samagotchi
         last_prompt: @session&.last_prompt,
         event_seq: @session_observer&.event_count,
         metrics: metrics,
-        pending_question: @question_desk.pending,
+        pending_question: @question_desk.pending&.to_h,
         used_memory_names: @used_memories.names,
         preloaded_memory_names: preloaded_memory_names,
         muted_memory_names: @muted_memory_names.dup,
@@ -1515,7 +1563,7 @@ module Samagotchi
 
     # ── Ask-user-question (structured qualification) ──────────────────────────
 
-    # @return [Hash, nil] current pending question (thread-safe copy)
+    # @return [PendingQuestion, nil] the question pending now
     def pending_question
       @question_desk.pending
     end
@@ -1541,7 +1589,7 @@ module Samagotchi
 
     # Publish a standing question that blocks nobody (QuestionDesk#post: a
     # worker's step-limit question).
-    # @return [Hash, nil] the pending question, nil while another is open
+    # @return [PendingQuestion, nil] the pending question, nil while another is open
     def post_question(fields, on_answer:, on_superseded_close: nil)
       @question_desk.post(fields, on_answer: on_answer, on_superseded_close: on_superseded_close)
     end
@@ -1640,7 +1688,29 @@ module Samagotchi
       # A woken worker's /stats and status line count the turns before it.
       bind_metrics(session)
       @used_memories.absorb(session)
+      # Loaded on another model than its last turn ran on (a --resume'd
+      # REPL's --model, a worker woken after a /model with no turn since):
+      # the saved ctx % was that model's window's. Drop it and count it as
+      # /model does, on a configured window only: this runs before a
+      # worker's Bridge serves, so no /props GET or model list here (a slow
+      # or hung host would hold up the worker's start). No configured
+      # window: no % (ctx ?) until the first generation reports one.
+      return unless model_switched_since_last_turn?
+
+      @metrics.forget_model_reports!
+      announce_switched_context!(configured_only: true)
+    end
+
+    # Whether the last turn that named its model ran on another one than
+    # the effective model; false before any (or when the ref can't be told).
+    def model_switched_since_last_turn?
+      last = @metrics.last_model_ref
+      !last.nil? && last != effective_model_ref
+    rescue StandardError => e
+      Log.warn(:model, "switch_check_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      false
     end
+    private :model_switched_since_last_turn?
 
     # @return [IdleRecap, nil] the idle recap detector, or nil when disabled
     attr_reader :recap
@@ -2047,7 +2117,8 @@ module Samagotchi
       result = backend(model).complete(
         messages: turn.messages,
         max_iterations: turn.limit,
-        on_stream_event: build_stream_event_handler(turn.on_event, cancel_controller: turn.controller),
+        on_stream_event: build_stream_event_handler(turn.on_event, cancel_controller: turn.controller,
+                                                    model_ref: generation_model_ref(model)),
         cancel_controller: turn.controller,
         model_name: bare_for_backend,
         max_tool_output_chars: max_tool_output_chars,
@@ -2059,6 +2130,18 @@ module Samagotchi
     end
     private :generate
 
+    # The ref (host:model, as asked) a turn's generations ran on: the model
+    # #generate resolved, after the before_turn hooks (which may switch it).
+    # SessionMetrics keys its per-model segments on it. nil when it can't be
+    # named (the turn's record then has none).
+    def generation_model_ref(model)
+      model.ref
+    rescue StandardError => e
+      Log.warn(:turn, "model_ref_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      nil
+    end
+    private :generation_model_ref
+
     # A step-limit Continue's resume_from, when it is inside the messages the
     # run gets (a wrong one only drops reasoning: it is ignored, logged).
     # Entries before it never move between the turns (#turn_messages adds
@@ -2594,13 +2677,17 @@ module Samagotchi
     #
     # With a :generation_progress hook registered, a Hooks::StreamWatch gets
     # each chunk's thinking and text after the UIs had it.
-    def build_stream_event_handler(on_event, cancel_controller: nil)
+    #
+    # +model_ref+: the turn's model (#generation_model_ref), added to each
+    # :generation_started as `model_ref:` (both loops send through here).
+    def build_stream_event_handler(on_event, cancel_controller: nil, model_ref: nil)
       watch = stream_watch(cancel_controller)
       proc do |event|
         progress = SteerCut.lanes(event) if event[:type] == :generation_chunk
         @steer_cut.observe(event, progress)
         case event[:type]
         when :generation_started
+          event = event.merge(model_ref: model_ref) if model_ref
           @thinking_notices.generation_started
           watch&.started(event[:iteration])
         when :generation_retrying
@@ -2626,13 +2713,15 @@ module Samagotchi
 
     # A :generation_completed with the generation's decode speed (`speed:`
     # {decode_tps:, source:}, nil without one), the session's running
-    # token totals (`tokens:`, the snapshot's block) and whether its served
+    # token totals (`tokens:`, the snapshot's block) and its per-model rows
+    # (`model_segments:`, the snapshot's) and whether its served
     # model is an expected one (`served_expected_by:`, its host): the web's info bar
     # reads them from the stream. SessionMetrics closes the generation here,
     # so the event it gets next finds it closed.
     def with_generation_report(event)
       report = @metrics.finish_generation
-      event.merge(speed: report.speed&.to_h, tokens: report.tokens, served_expected_by: served_expected_by(event[:served_model]))
+      event.merge(speed: report.speed&.to_h, tokens: report.tokens, model_segments: report.model_segments,
+                  served_expected_by: served_expected_by(event[:served_model]))
     rescue StandardError => e
       Log.warn(:turn, "generation_report_failed", error: e.class.name, msg: e.message.to_s[0, 200])
       event