samagotchi 0.155.0 → 0.156.0

data/lib/samagotchi/turn_stages/objectives.rb

@@ -14,78 +14,62 @@ module Samagotchi
     # audit of what comes in at a turn's start and what goes out at its end
     # (ObjectivesAudit), the view announced when it changed, and the model's
     # proposals kept as cards until the turn is over. Its state is those
-    # proposals under their mutex, the last view announced and the audit.
+    # proposals under their mutex and the last view announced (under the
+    # event lock); the audit is built per call.
     class Objectives
       # @param side_judgments [SideJudgments] the Engine's side asks (the audit's kinds)
       # @param host_registry [HostRegistry] System 1's client resolves its host here
-      # @param state_dir [#call] the sessions dir
-      # @param recording [#call] (client, judgment, session, mode:) → the client saving its runs
-      # @param runs [#call] the Engine's SystemOne::Runs
-      # @param synchronize [#call] (&block) runs the block under the event lock (Engine#synchronize_events)
-      # @param announce [#call] (event) tells the observers (Engine#announce)
-      # @param running [#call] the running turn's conversation, nil between turns (Engine#live_conversation)
-      # @param show_card [#call] (**card) shows a card (Engine#show_card)
-      def initialize(side_judgments:, host_registry:, state_dir:, recording:, runs:, synchronize:, announce:, running:, show_card:)
+      def initialize(side_judgments:, host_registry:)
         @side_judgments = side_judgments
-        @state_dir = state_dir
-        @synchronize = synchronize
-        @announce = announce
-        @running = running
-        @show_card = show_card
+        @host_registry = host_registry
         # The last view announced (#announce), under the event lock.
         @announced = nil
         # The model's proposals until the turn is over (#finally).
         @proposals = []
         @proposals_mutex = Mutex.new
-        # With saving off nothing would come of an ask, so none is made.
-        @audit = ObjectivesAudit.new(
-          side: side_judgments, state_dir: state_dir,
-          client_for: lambda do |judgment, session|
-            next nil unless runs.call.on?
-
-            recording.call(SystemOne::Client.from_config(host_registry: host_registry, mode: ObjectivesAudit::MODE, tag: :system_one),
-                           judgment, session, mode: nil)
-          end
-        )
       end
 
       # System 1 on the objectives, in audit (ObjectivesAudit), at a turn's
       # start: the owner's turns only, and for a message a person's: a
       # reminder's or a delegate's prompt isn't one.
-      def incoming(turn)
+      # @param recorder [SystemOne::Recorder] the audit's runs (built for this call)
+      def incoming(turn, recorder:)
         return unless turn.prompt.is_a?(String) && turn.origin.human? && OwnerPrompt.turn?(session: turn.session, author: turn.origin.author)
 
-        @audit.incoming(turn.session, turn.prompt)
+        audit(turn.context.state_dir, recorder).incoming(turn.session, turn.prompt)
       end
 
       # The turn's answer, after the end event and before :after_turn (the
       # caller skips a canceled or exhausted turn): the owner's turns only.
-      def outgoing(turn, result)
+      # @param recorder [SystemOne::Recorder] the audit's runs (built for this
+      #   call: after a before_turn hook's model switch, the new model)
+      def outgoing(turn, result, recorder:)
         return unless OwnerPrompt.turn?(session: turn.session, author: turn.origin.author)
 
-        @audit.outgoing(turn.session, result.text)
+        audit(turn.context.state_dir, recorder).outgoing(turn.session, result.text)
       end
 
       # A note added between turns (Engine#add_context_note): incoming too.
-      def note(session, note) = @audit.note(session, note)
+      # @param recorder [SystemOne::Recorder] the audit's runs (built for this call)
+      # @param state_dir [String] the sessions dir
+      def note(session, note, recorder:, state_dir:) = audit(state_dir, recorder).note(session, note)
 
       # The session's objectives as the page draws them (Objectives.view), when
       # that differs from the last announced: after an edit (its file written,
       # pending), once a list note is in, at a turn's end (its moves) and after
-      # a rollback. A session with no list announces nothing. It only informs:
-      # a failure is logged, never the turn's.
-      def announce(session)
-        return unless session
-
-        @synchronize.call do
-          view = Samagotchi::Objectives.view(session.id, session.messages, state_dir: @state_dir.call, running: @running.call&.dup)
-          next if view.nil? || view == @announced
-
-          @announced = view
-          @announce.call({ type: :objectives_updated, session_id: session.id, **view })
-        end
-      rescue StandardError => e
-        Log.warn(:turn, "objectives_announce_failed", error: e.class.name, msg: e.message)
+      # a rollback. A session with no list announces nothing. The caller
+      # (Engine#announce_objectives) holds the event lock, the one guard of
+      # the last view, announces the event and logs a failure: it only
+      # informs, never fails a turn.
+      # @param state_dir [String] the sessions dir
+      # @param running [Array<Hash>, nil] the running turn's conversation (Engine#live_conversation), nil between turns
+      # @return [Hash, nil] the :objectives_updated event to announce, nil when the view is the same
+      def announce(session, state_dir:, running:)
+        view = Samagotchi::Objectives.view(session.id, session.messages, state_dir: state_dir, running: running&.dup)
+        return if view.nil? || view == @announced
+
+        @announced = view
+        { type: :objectives_updated, session_id: session.id, **view }
       end
 
       # A change the model proposes (the objectives tool), kept until the turn
@@ -108,9 +92,15 @@ module Samagotchi
       # failed or rolled-back turn keeps none, and its proposals are dropped
       # here so the next turn does not show them either: their Apply card
       # would sit after a turn whose `objectives propose` call is not in the
-      # history (a rollback after Ctrl-C drops it).
+      # history (a rollback after Ctrl-C drops it). The caller
+      # (Engine#show_objective_proposals) shows the cards.
+      # @return [Array<Hash>] the completed turn's cards (Engine#show_card's
+      #   arguments); none for any other ending
       def finally(turn)
-        turn.completed? ? show_proposals : discard_proposals(turn)
+        return proposal_cards if turn.completed?
+
+        discard_proposals(turn)
+        []
       end
 
       # For specs: the audit's asks' thread for +kind+ (ObjectivesAudit's
@@ -122,15 +112,13 @@ module Samagotchi
 
       private
 
-      def show_proposals
-        drain_proposals.each do |proposal|
+      def proposal_cards
+        drain_proposals.map do |proposal|
           id = "objectives-#{SecureRandom.hex(4)}"
-          @show_card.call(source: Samagotchi::Objectives::SOURCE, id: id, title: proposal.title, body: proposal.body,
-                          actions: [{ label: "Apply", command: proposal.action_line(id) },
-                                    { label: "Dismiss", command: "/objectives --card #{id} dismiss" }])
+          { source: Samagotchi::Objectives::SOURCE, id: id, title: proposal.title, body: proposal.body,
+            actions: [{ label: "Apply", command: proposal.action_line(id) },
+                      { label: "Dismiss", command: "/objectives --card #{id} dismiss" }] }
         end
-      rescue StandardError => e
-        Log.warn(:turn, "objectives_proposal_failed", error: e.class.name, msg: e.message)
       end
 
       def discard_proposals(turn)
@@ -141,6 +129,22 @@ module Samagotchi
       def drain_proposals
         @proposals_mutex.synchronize { @proposals.slice!(0..) }
       end
+
+      # The audit for one call, over the values it is given: nothing of it
+      # is kept. Its client is asked for only once an active objective is
+      # there (ObjectivesAudit#ask), and with saving off nothing would come
+      # of an ask, so none is made.
+      def audit(state_dir, recorder)
+        ObjectivesAudit.new(
+          side: @side_judgments, state_dir: state_dir,
+          client_for: lambda do |judgment, session|
+            next nil unless recorder.saving?
+
+            recorder.wrap(SystemOne::Client.from_config(host_registry: @host_registry, mode: ObjectivesAudit::MODE, tag: :system_one),
+                          judgment, session, mode: nil)
+          end
+        )
+      end
     end
   end
 end

data/lib/samagotchi/turn_stages/toolkit_suggestion.rb

@@ -23,17 +23,11 @@ module Samagotchi
       # @param host_registry [HostRegistry] System 1's client resolves its host here
       # @param toolkit_binding [ToolkitBinding] the kits, #suggest and #fell_back
       # @param tools [Tools::Registry] the registered tools, for the snapshot
-      # @param state_dir [#call] the sessions dir (the suggestion log's place)
-      # @param recording [#call] (client, judgment, session, mode:) → the client saving its runs
-      # @param runs [#call] the Engine's SystemOne::Runs
-      def initialize(side_judgments:, host_registry:, toolkit_binding:, tools:, state_dir:, recording:, runs:)
+      def initialize(side_judgments:, host_registry:, toolkit_binding:, tools:)
         @side_judgments = side_judgments
         @host_registry = host_registry
         @toolkit_binding = toolkit_binding
         @tools = tools
-        @state_dir = state_dir
-        @recording = recording
-        @runs = runs
         @pending = nil
         @pending_turn = nil
         @warmup_thread = nil
@@ -52,12 +46,14 @@ module Samagotchi
       # snapshot. Audit never blocks: the thread logs its line. On mode
       # keeps the ask's Pending for +turn+, which #settle joins before
       # apply_toolkit!, with the turn's controller as the request's cancel
-      # controller.
+      # controller. The suggestion log is in the turn's sessions dir
+      # (TurnContext#state_dir).
+      # @param recorder [SystemOne::Recorder] the ask's runs (built for this call)
       # @return [ToolkitSuggest::Pending, nil] nil unless the turn joins an ask
-      def start(turn)
+      def start(turn, recorder:)
         @pending = nil
         @pending_turn = turn
-        @pending = ask(turn)
+        @pending = ask(turn, recorder)
       end
 
       # On mode, before apply_toolkit!: wait for +turn+'s ask (#start) up to
@@ -154,14 +150,14 @@ module Samagotchi
       # never reached #start) is never touched.
       def pending_for(turn) = (@pending if @pending_turn.equal?(turn))
 
-      def ask(turn)
+      def ask(turn, recorder)
         mode = Config.get("toolkit.suggest.mode").to_s
         return if mode == "off"
 
         joined = mode == "on"
         session = turn.session
         default = Toolkit.of(session.toolkit)
-        log = suggestion_log
+        log = suggestion_log(turn.context.state_dir)
         # The predicate checks the session first; the kits (memory kits are
         # read from disk) and the log (read whole) only when it gets there.
         kits = nil
@@ -185,8 +181,8 @@ module Samagotchi
           return
         end
 
-        client = @recording.call(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :toolkit),
-                                 ToolkitSuggest::JUDGMENT, session, mode: Config.get("toolkit.suggest.mode").to_s)
+        client = recorder.wrap(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :toolkit),
+                               ToolkitSuggest::JUDGMENT, session, mode: Config.get("toolkit.suggest.mode").to_s)
         return unless client
 
         # The warm-up's only value is the cache: the real ask never queues
@@ -215,7 +211,7 @@ module Samagotchi
           state: { project: state[:project].dup.freeze, prompt: state[:prompt].dup.freeze }.freeze
         )
         threshold = Config.get("toolkit.suggest.threshold")
-        runs = session.scratch ? nil : @runs.call
+        runs = session.scratch ? nil : recorder.runs
         pending = ToolkitSuggest::Pending.new(log: log, joined: joined,
                                               acted: runs && ->(judged, did) { runs.acted(judged.fields[:run_id], did) },
                                               timeout_seconds: SystemOne::Client.configured_timeout_ms / 1000.0)
@@ -253,8 +249,8 @@ module Samagotchi
         end
       end
 
-      def suggestion_log
-        SideJudgments.log(ToolkitSuggest.log_path(@state_dir.call), tag: :toolkit, event: "toolkit_suggest_log_failed")
+      def suggestion_log(state_dir)
+        SideJudgments.log(ToolkitSuggest.log_path(state_dir), tag: :toolkit, event: "toolkit_suggest_log_failed")
       end
     end
   end

data/lib/samagotchi/turn_stages/verify_anchors.rb

@@ -17,21 +17,20 @@ module Samagotchi
     # against its source session as the turn begins; at its end (inside
     # Engine#end_turn's event step) the opening's stamp, a Revise turn's
     # draft checked and a Verify turn's verdict recorded. No state of its
-    # own: it reads the turn, and the sessions it loads from the state dir.
+    # own: it reads the turn, and the sessions it loads from the state dir
+    # it is given.
     class VerifyAnchors
-      # @param state_dir [#call] the sessions dir (a fresh Verify child's parent is loaded from it)
-      def initialize(state_dir:)
-        @state_dir = state_dir
-      end
-
       # A Verify turn's claim (Engine#begin_turn), when its quote is in the
       # source session's answer for that turn; nil (logged) otherwise.
       # @param anchor [VerifyAnchor, nil]
+      # @param state_dir [String] the sessions dir (a fresh Verify child's
+      #   parent is loaded from it): the Engine's at the call, as no
+      #   TurnContext holds it yet
       # @return [VerifyAnchor, nil]
-      def verified(session, anchor)
+      def verified(session, anchor, state_dir:)
         return unless anchor
 
-        source = source_session(session, anchor)
+        source = source_session(session, anchor, state_dir)
         return unless source
 
         turn = AnswerTail.turn_slice(Array(source.messages), anchor.turn_id)
@@ -133,14 +132,14 @@ module Samagotchi
         comparison_text(Redact.text(answer, viewer)).include?(quote_text)
       end
 
-      def source_session(session, anchor)
+      def source_session(session, anchor, state_dir)
         return session unless session.verify_fresh
 
         fresh = session.verify_fresh
         return reject_verify(anchor, :fresh_anchor_mismatch) unless fresh.anchor == anchor
         return reject_verify(anchor, :fresh_parent_missing) unless session.parent_id
 
-        Session.load(session.parent_id, state_dir: @state_dir.call)
+        Session.load(session.parent_id, state_dir: state_dir)
       rescue ArgumentError, SystemCallError, IOError => e
         Log.warn(:turn, "verify_anchor_rejected", turn_id: anchor.turn_id, reason: :source_session_unavailable,
                                                    error: e.class.name)

data/lib/samagotchi/turn_stages/warmup.rb

@@ -17,22 +17,17 @@ module Samagotchi
       # @param prompt_warmup [PromptWarmup] the Engine's warm-up (the kernel asks it for a slot pin)
       # @param kernel [KernelLoop] the warm-up prompt, the last slot, warmed_up!
       # @param turn_state [TurnState] whether steers are carried to the next turn
-      # @param model_settings [SessionModelSettings] the next turn's LLM context strategy
-      # @param model [#call] the effective model now (Engine#effective_model)
-      # @param system_prompt [#call] (model) the system prompt (Engine#system_prompt)
-      # @param reminders_due [#call] whether a reminder is due (Engine#reminders_due?)
-      # @param next_turn_waiting [#call] whether the next turn starts at once or none follows
-      #   (Engine#next_turn_waiting, called)
-      def initialize(prompt_warmup:, kernel:, turn_state:, model_settings:, model:, system_prompt:, reminders_due:,
-                     next_turn_waiting:)
+      # @param model_settings [SessionModelSettings] the effective model now, the next turn's LLM context strategy
+      # @param reminder_queue [ReminderQueue] whether a reminder is due
+      # @param system_prompt [#call] (model) the system prompt (Engine#system_prompt): called last, only
+      #   once every check passed, as building it has side effects (the memory index metric, the prompt notes)
+      def initialize(prompt_warmup:, kernel:, turn_state:, model_settings:, reminder_queue:, system_prompt:)
         @prompt_warmup = prompt_warmup
         @kernel = kernel
         @turn_state = turn_state
         @model_settings = model_settings
-        @model = model
+        @reminder_queue = reminder_queue
         @system_prompt = system_prompt
-        @reminders_due = reminders_due
-        @next_turn_waiting = next_turn_waiting
       end
 
       # After a completed turn, prefill the next turn's prompt up to its user
@@ -40,14 +35,18 @@ module Samagotchi
       # local llama.cpp host on the native loop, and not when the next turn's
       # start differs anyway or starts at once: a reminder due, a continue
       # offer (the turn ran out of steps), a carried steer or queued input.
-      # Never fails the turn.
-      def after(turn, result)
+      # Never fails the turn. Each read comes only once the checks before it
+      # passed: the model resolved after the turn's own outcome, the probe
+      # and the prompt only on a target.
+      # @param next_turn_waiting [#call, nil] the host's probe: true when the next turn starts at once or none
+      #   follows (Engine#next_turn_waiting); nil: neither
+      def after(turn, result, next_turn_waiting:)
         return if result.canceled? || result.resumable?
 
-        model = @model.call
+        model = @model_settings.effective_model
         client = model.client
         return unless target?(model, client)
-        return if @reminders_due.call || @turn_state.carried_steers? || @next_turn_waiting.call
+        return if @reminder_queue.due? || @turn_state.carried_steers? || next_turn_waiting&.call
 
         messages = ContextNote.with_system_head(turn.session.messages.dup, { role: "system", content: @system_prompt.call(model) })
         # Under the next turn's strategy (a /model switch may have changed it);

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/vision_support.rb

@@ -24,7 +24,7 @@ module Samagotchi
     # @param target [HostRegistry::ModelTarget]
     # @param profile [ModelProfile, nil] the model's prompt profile (native)
     # @param adapter [LLM::OpenAIChat, nil] the chat host's adapter
-    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @param models [Hash{String => ModelSettings}, nil] ModelSettings.all (specs)
     # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
     # @return [Answer]
     def self.for(target, names:, profile: nil, adapter: nil, models: nil)
@@ -47,11 +47,11 @@ module Samagotchi
 
     def self.configured(_target, entry, models, names)
       models ||= begin
-        ConfigFile.model_settings
+        ModelSettings.all
       rescue StandardError
         {}
       end
-      if (setting = ConfigFile.model_setting(names, :vision, models: models))
+      if (setting = ModelSettings.find(names, :vision, models: models))
         return Answer.new(value: setting.value, reason: setting.value ? nil : "models: #{setting.key} sets vision: false")
       end
       return nil if entry.vision.nil?

data/lib/samagotchi/web/app.rb

@@ -353,10 +353,10 @@ module Samagotchi
           # "..", a %2F) is an unknown session before any handler makes a path.
           # (/api/sessions/resolve and /summaries take no id.)
           if req.path_info.start_with?("/api/sessions/") && !m.captures.empty? && !Session.valid_id?(m.captures.first)
-            return error_response(404, "not_found", "Session not found: #{m.captures.first.to_s[0, 80]}")
+            return session_not_found(m.captures.first)
           end
 
-          return session_route(principal) { send(handler, req, *m.captures) } if kind == :session
+          return session_route(principal, m.captures.first) { send(handler, req, *m.captures) } if kind == :session
 
           return send(handler, req, *m.captures)
         end
@@ -383,11 +383,14 @@ module Samagotchi
       # raises (Session.load, the manager's find) is a 404 not_found with
       # its message. Only these routes: elsewhere an ArgumentError is a bug,
       # #route's 500. A handler's own rescues run first.
-      def session_route(principal = nil)
+      def session_route(principal = nil, id = nil)
         yield
       rescue ArgumentError => e
-        # A participant's 404 never carries the lookup's words (a path).
-        error_response(404, "not_found", principal.nil? || principal.owner? ? e.message : "Session not found")
+        return error_response(404, "not_found", e.message) if principal.nil? || principal.owner?
+
+        # A participant's 404 never carries a lookup's words (a path): it
+        # names their own session's id (valid_id? passed), nothing else.
+        session_not_found(id)
       end
 
       # API requests at debug level (not the page and its assets): method,
@@ -1152,7 +1155,7 @@ module Samagotchi
         Degrade.call(:web, "model_sampling_unreadable") do
           return if registry.nil? || models.empty?
 
-          settings = ConfigFile.model_settings
+          settings = ModelSettings.all
           models.each do |model|
             target = registry.resolve(model[:name])
             names = registry.lookup_names(model[:name], target: target)
@@ -1214,7 +1217,7 @@ module Samagotchi
         @models_mutex.synchronize do
           next @registry if @registry_given
 
-          hosts = ConfigFile.hosts_config
+          hosts = HostConfig.all
           if @registry.nil? || hosts != @registry_hosts
             @registry = HostRegistry.new(hosts_config: hosts)
             @registry_hosts = hosts
@@ -1560,7 +1563,7 @@ module Samagotchi
         begin
           session = @session_class.load(id, state_dir: default_state_dir)
         rescue ArgumentError
-          return error_response(404, "not_found", "Session not found: #{id}")
+          return session_not_found(id)
         end
         # Its terminal's alone: a tab's stream would keep its worker up.
         return scratch_refused(id) if session.scratch
@@ -1976,6 +1979,10 @@ module Samagotchi
         error_response(404, "not_found", "not found: #{path}")
       end
 
+      # 404 not_found for an id (or prefix) that names no session, in
+      # Session::NotFound's words (SessionAccess::Remote maps it back).
+      def session_not_found(given) = error_response(404, "not_found", Session::NotFound.new(given).message)
+
       # One tab's GET /api/events: a bounded queue behind a lambda sink,
       # subscribed and snapshotted as one step under the hub's lock, then
       # drained onto the socket. The loop ends when the hub stops or the

data/lib/samagotchi/web/participant_access.rb

@@ -185,7 +185,7 @@ module Samagotchi
       end
 
       def unknown_session(id)
-        error_response(404, "not_found", "Session not found: #{id.to_s[0, 80]}")
+        session_not_found(id)
       end
 
       # 403 not_permitted for a participant (the owner is never refused by
@@ -388,7 +388,7 @@ module Samagotchi
       def participant_resolve(grant, given)
         return json_response(200, { id: grant.session_id }) if grant.session_id.start_with?(given)
 
-        error_response(404, "not_found", "no session #{given[0, 80]}")
+        session_not_found(given)
       end
 
       # POST …/wait/prepare for a participant (an agent's chi --remote

data/lib/samagotchi/web/session_access_routes.rb

@@ -78,14 +78,14 @@ module Samagotchi
       # 404 not_found; 400 ambiguous_id with ids (the sessions it names).
       def handle_resolve(req)
         given = req.params["id"].to_s
-        return error_response(404, "not_found", "no session #{given[0, 80]}") unless Session.valid_id?(given)
+        return session_not_found(given) unless Session.valid_id?(given)
         return participant_resolve(principal(req).grant, given) unless principal(req).owner?
 
         json_response(200, { id: session_access.resolve(given) })
       rescue Session::AmbiguousId => e
         refusal_response(400, "ambiguous_id", e, ids: e.ids)
-      rescue ArgumentError
-        error_response(404, "not_found", "no session #{given[0, 80]}")
+      rescue ArgumentError # NotFound, a file that won't load
+        session_not_found(given)
       end
 
       # GET /api/sessions/:id?brief=1: the session as a session command

data/lib/samagotchi/web/session_control.rb

@@ -47,7 +47,7 @@ module Samagotchi
 
       def handle_question_answer(req, id)
         session = @session_class.load(id, state_dir: default_state_dir) rescue nil
-        return error_response(404, "not_found", "Session not found: #{id}") unless session
+        return session_not_found(id) unless session
 
         body = parse_json(request_body(req))
         return error_response(400, "invalid_json", "invalid JSON body") unless body.is_a?(Hash)
@@ -239,7 +239,7 @@ module Samagotchi
         return [] if raw.nil?
 
         session_dir = image_session_dir(id)
-        return "unknown session" unless session_dir
+        return Session::NotFound.new(id).message unless session_dir
 
         ImageStore.check_refs(session_dir, raw)
       end
@@ -259,7 +259,7 @@ module Samagotchi
       # (converted, downscaled); answers the ref the turn then names.
       def handle_image_upload(req, id)
         session_dir = image_session_dir(id)
-        return error_response(404, "not_found", "unknown session") unless session_dir
+        return session_not_found(id) unless session_dir
 
         length = req.content_length.to_i
         if length > MAX_IMAGE_UPLOAD_BYTES

data/lib/samagotchi/web/session_create.rb

@@ -140,7 +140,7 @@ module Samagotchi
       end
 
       # POST /api/sessions with continues: <id, prefix or last:id>: the next
-      # link of that session's chain (SessionManager.continue_session), in its
+      # link of that session's chain (SessionContinue.run), in its
       # folder and with its own setup (SessionSetup: llm_context, thinking
       # and reasoning_history levels, settings), so dir, llm_context, thinking and settings are
       # refused beside it (a create takes no reasoning_history). It runs on
@@ -328,11 +328,11 @@ module Samagotchi
         [level, nil]
       end
 
-      # SessionManager.continue_session, its refusals as responses: [session,
+      # SessionContinue.run, its refusals as responses: [session,
       # nil] or [nil, the response]. Only its own errors: what fails after
       # the new link started is not a refusal of it.
       def continue_from(given, prompt:, preview:, model:)
-        [@manager.continue_session(given, prompt: prompt, preview: preview, model: model, state_dir: @state_dir), nil]
+        [SessionContinue.run(given, prompt: prompt, preview: preview, model: model, state_dir: @state_dir), nil]
       rescue SessionContinue::Refused => e
         extra = e.reason == :continued ? { next_id: e.ids.first } : {}
         [nil, refusal_response(409, e.reason.to_s, e, session_id: e.session_id, reason: e.reason.to_s, ids: e.ids, **extra)]

data/lib/samagotchi/web/session_hub.rb

@@ -412,7 +412,7 @@ module Samagotchi
       # read is mtime-cached), so a host added or a window changed while
       # chi web runs is picked up on the next refresh of a card.
       def hub_registry
-        hosts = ConfigFile.hosts_config
+        hosts = HostConfig.all
         if @hub_registry.nil? || hosts != @hub_registry_hosts
           @hub_registry = HostRegistry.new(hosts_config: hosts)
           @hub_registry_hosts = hosts

data/lib/samagotchi/web/session_show.rb

@@ -184,7 +184,7 @@ module Samagotchi
       # cards from its light GET tail, else the saved ones; the session file
       # is only stat'ed (the 404), never parsed.
       def handle_cards_read(id)
-        return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
+        return session_not_found(id) unless session_exists?(id)
 
         tail = live_tail(id)
         json_response(200, { cards: cards_for_display(live_or_saved(tail, "cards") { saved_cards(id) }) })
@@ -201,7 +201,7 @@ module Samagotchi
       # are the newest turn's (#recent_timing), which the page merges by id
       # (the page still sends ?recent=1, which is accepted and not needed).
       def handle_tail_read(req, id)
-        return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
+        return session_not_found(id) unless session_exists?(id)
 
         turn_id = req.params["turn_id"].to_s.strip
         turn_id = nil if turn_id.empty?
@@ -259,7 +259,7 @@ module Samagotchi
       # the live ones) and turn_count, when the page's merge comes up short.
       # The worker's GET state, never its messages.
       def handle_timing_read(id)
-        return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
+        return session_not_found(id) unless session_exists?(id)
 
         state = bridge_get_json(id, "state")
         json_response(200, { timing: timing_payload(id, live_metrics: state && state["session_state_snapshot"]&.fetch("metrics", nil)) })

data/lib/samagotchi/web/session_summary.rb

@@ -146,13 +146,12 @@ module Samagotchi
       private_class_method :budget_resolver
 
       # status is turn state (idle/running). The live worker's snapshot is the
-      # truth; on disk, a "running" with no live owner was left by a worker
-      # that died mid-turn.
+      # truth; on disk, Session#displayed_status (a "running" with no live
+      # owner was left by a worker that died mid-turn).
       def displayed_status(session, snapshot = nil, owner:)
         return snapshot["status"] if snapshot.is_a?(Hash) && snapshot["status"]
-        return session.status unless session.status == Session::STATUS_RUNNING
 
-        owner ? session.status : Session::STATUS_IDLE
+        session.displayed_status(owner: owner)
       end
 
       def first_preview_for(session)