samagotchi 0.155.0 → 0.157.0

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)
@@ -207,7 +207,7 @@ module Samagotchi
         when :accepted
           record_history(body, prompt)
           # via: bridge or file (the worker was gone: its input file), which
-          # names the turn a remote chi send --wait follows (WaitTarget).
+          # names the turn a remote chi send --wait follows (ReplyWait::Target).
           json_response(202, result.ack.merge("via" => result.via.to_s))
         when :refused then json_response(result.code, result.ack)
         when :timeout then error_response(504, "worker_timeout", result.detail)
@@ -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

@@ -343,8 +343,8 @@ module Samagotchi
         return if dir_stat.mtime == @dir_mtime
 
         @dir_mtime = dir_stat.mtime
-        on_disk = Dir.glob(File.join(@state_dir, "*#{Session::FILE_EXT}")).to_h do |path|
-          [File.basename(path, Session::FILE_EXT), path]
+        on_disk = Dir.glob(File.join(@state_dir, "*#{SessionPaths::FILE_EXT}")).to_h do |path|
+          [File.basename(path, SessionPaths::FILE_EXT), path]
         end.select { |id, _| Session.valid_id?(id) }
         (@sessions.keys - on_disk.keys).each { |id| drop(id) }
         on_disk.each_key { |id| @sessions[id] ||= Entry.new }
@@ -404,21 +404,13 @@ module Samagotchi
         emit("session", session: summary)
       end
 
-      # One HostRegistry kept across scans: every session's ctx_pct may
-      # need its llm_context budget resolved, and the registry's config read
-      # is what would otherwise repeat per scan and per session. Built on
-      # the first summary that needs it, and built again when config.yml's
-      # hosts: changed (compared as read, like App#host_registry: the YAML
-      # 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
-        if @hub_registry.nil? || hosts != @hub_registry_hosts
-          @hub_registry = HostRegistry.new(hosts_config: hosts)
-          @hub_registry_hosts = hosts
-        end
-        @hub_registry
-      end
+      # The registry kept across scans (HostRegistry.current, built again
+      # when config.yml's hosts: changed): every session's ctx_pct may need
+      # its llm_context budget resolved, and the registry's config read is
+      # what would otherwise repeat per scan and per session; a host added
+      # or a window changed while chi web runs is picked up on the next
+      # refresh of a card.
+      def hub_registry = HostRegistry.current
 
       def drop(id)
         entry = @sessions.delete(id)

data/lib/samagotchi/web/session_show.rb

@@ -4,6 +4,8 @@ require "time" # Time.iso8601
 require "uri"
 
 require_relative "../analytics_file"
+require_relative "../bridge/turn_accumulator"
+require_relative "../bridge/turn_drawings"
 require_relative "../answer_refs"
 require_relative "../answer_tail"
 require_relative "../objectives"
@@ -67,13 +69,27 @@ module Samagotchi
         session_json = shown_session_json(session, snapshot, owner, persisted)
         raw_messages = live_or_saved(turn_snapshot, "messages") { session.messages }
         timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"], persisted: persisted)
+        parts = req.params["parts"] == "1"
+        # A page that draws finished turns from their drawings (drawings=1,
+        # with parts=1): the valid lines stamp their items, which lose their
+        # parts. An older page (no drawings=1) reads what it always did.
+        # A live worker from before turn drawings lists no of_turn on its
+        # cards: its turns all draw as before.
+        drawings = parts && req.params["drawings"] == "1" && (!live || worker_draws?(id))
+        drawn = drawings ? drawn_lines(id, raw_messages) : []
+        messages = messages_for_display(raw_messages, parts: parts, cwd: session.working_directory,
+                                                      drawings: drawn, strip_drawn: true)
         json_response(200, {
           session: session_json,
           history: read_history(id),
-          messages: messages_for_display(raw_messages, parts: req.params["parts"] == "1",
-                                                       cwd: session.working_directory),
+          messages: messages,
+          **turn_drawings_field(drawn, messages),
           failed_turn: failed_turn_for(session, raw_messages),
           current_turn: current_turn,
+          # The page's join: the turn in progress and the queue behind it as
+          # the live events that draw them (TurnAccumulator.join_events, one
+          # unfold, here: any worker's snapshot works).
+          replay: replay_events_for(turn_snapshot, timing),
           queued: snapshot_list(turn_snapshot, "queued"),
           # Commands waiting for the running turn's end (their bubbles).
           queued_commands: snapshot_list(turn_snapshot, "queued_commands"),
@@ -110,6 +126,52 @@ module Samagotchi
         view ? { objectives: view } : {}
       end
 
+      # The live events a joining page replays (`replay`): the worker's
+      # +turn_snapshot+'s turn, queued prompts and commands, the turn's start
+      # from +timing+'s active_turn; [] without a worker or with nothing.
+      def replay_events_for(turn_snapshot, timing)
+        return [] unless turn_snapshot
+
+        wire = Bridge::TurnAccumulator.from_wire(turn_snapshot.slice("current_turn", "queued", "queued_commands"))
+        active = timing[:active_turn]
+        Bridge::TurnAccumulator.join_events(current_turn: wire[:current_turn], queued: wire[:queued],
+                                            queued_commands: wire[:queued_commands],
+                                            started_at: active.is_a?(Hash) ? active["started_at"] : nil)
+      end
+
+      # Whether the session's live worker names turn drawings in its
+      # sidecar's features (Bridge::TurnDrawings::FEATURE); false when its
+      # link can't be read as live.
+      def worker_draws?(id)
+        link = worker_link(id)
+        link.live? && Array(link.sidecar.features).include?(Bridge::TurnDrawings::FEATURE)
+      end
+
+      # The session's turn drawings that hold against +messages+ (the live
+      # snapshot's, else the file's): Bridge::TurnDrawings, cached by the
+      # file's size and mtime; the newest SHOWN_MAX of them.
+      # A drawing that can't be read draws its turn as before.
+      def drawn_lines(id, messages)
+        Degrade.call(:web, "turn_drawings_unreadable", fallback: []) do
+          dir = @session_class.session_dir(id, state_dir: default_state_dir)
+          Bridge::TurnDrawings.valid(Bridge::TurnDrawings.read(dir), messages).last(Bridge::TurnDrawings::SHOWN_MAX)
+        end
+      end
+
+      # {turn_drawings: {turn_id => {events:, end:}}} for the stamped turns
+      # (chi web's one unfold of a drawing, its cards too); nothing without
+      # one.
+      def turn_drawings_field(lines, messages)
+        stamped = messages.filter_map { |item| item[:drawn] }.uniq
+        shown = lines.select { |line| stamped.include?(line.turn_id) }
+        return {} if shown.empty?
+
+        { turn_drawings: shown.to_h do |line|
+          turn = Bridge::TurnAccumulator.from_wire(line.drawing)
+          [line.turn_id, { events: Bridge::TurnAccumulator.replay_events(turn, cards: true), end: line.end }]
+        end }
+      end
+
       # A list in the worker's turn +snapshot+ (queued prompts, commands,
       # init tasks); [] without a worker.
       def snapshot_list(snapshot, key) = Array(snapshot&.[](key))
@@ -184,7 +246,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 +263,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 +321,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

@@ -7,10 +7,11 @@ require_relative "../verify_fresh"
 require_relative "../recap_store"
 require_relative "../archive_store"
 require_relative "../session_metrics"
-require_relative "../llm_context_strategy"
+require_relative "../effective_model"
 require_relative "../host_registry"
 require_relative "../bridge_client"
 require_relative "../worker_link"
+require_relative "../session_row"
 require_relative "../bridge/pending_card"
 
 module Samagotchi
@@ -20,6 +21,14 @@ module Samagotchi
     # session is answered (GET /api/sessions, the session view, the session
     # hub's events), so every path agrees on status, owner and bridge_up.
     module SessionSummary
+      # The page's keys, in the order it has always had them (a hub event
+      # compares with ==, a 0.156 page reads them by name).
+      WEB_KEYS = %i[id status mode model_name working_directory created_at updated_at last_prompt short_id test_run
+                    used_memory_names preloaded_memory_names muted_memory_names prompt_notes parent_id delegate
+                    continues review first_preview title owner recap auto_title ctx_pct tokens memory_index side
+                    archived project_root bridge_up worker_version worker_features pending_question pending_card
+                    last_turn verdicts verify_fresh last_verdict].freeze
+
       module_function
 
       # @param session [Session] a saved session (messages may be empty)
@@ -39,64 +48,66 @@ module Samagotchi
       # @return [Hash] symbol keys
       def build(session, owner:, session_dir:, status: displayed_status(session, owner: owner), root_cache: nil,
                 registry: nil)
-        used = Array(session.used_memory_names)
         link = WorkerLink.resolve(session_dir, unlink: false, owner: owner)
         up = link.live?
         sidecar = up ? link.sidecar : nil
         saved = SessionMetrics.saved_summary(session_dir, budget_tokens: budget_resolver(session, registry))
-        recap_card = RecapStore.card(session_dir)
-        {
-          id: session.id,
+        # The facts every list shares (SessionRow), from this one link,
+        # analytics and recap read.
+        row = SessionRow.build(session, session_dir: session_dir, owner: owner, link: link, roots: root_cache || {},
+                                        saved: saved, card: RecapStore.card(session_dir))
+        values = {
+          id: row.id,
           status: status,
           mode: session.mode,
           model_name: session.model_name,
-          working_directory: session.working_directory,
+          working_directory: row.cwd,
           created_at: session.created_at,
-          updated_at: session.updated_at,
+          updated_at: row.updated_at,
           last_prompt: session.last_prompt,
-          short_id: session.id.to_s[0, 8],
-          test_run: !!session.test_run,
-          used_memory_names: used,
+          short_id: row.short_id,
+          test_run: !!row.test_run,
+          used_memory_names: Array(session.used_memory_names),
           # The session's --memory and --mute lists (info-bar tooltip).
           preloaded_memory_names: Array(session.preloaded_memory_names),
           muted_memory_names: Array(session.muted_memory_names),
           # The model notes its prompt carried (the info bar's notes chip).
           prompt_notes: Array(session.prompt_notes).map(&:to_h),
           # The session that delegated this one (the `delegate` tool), else nil.
-          parent_id: session.parent_id,
+          parent_id: row.parent_id,
           # Started by the delegate tool (Session#delegate?); a fork has a
           # parent_id too but isn't one. The parent's children chip counts
           # delegates only, as the TUI's segment and /children do.
-          delegate: session.delegate?,
+          delegate: row.delegate,
           # The session this one continues (the previous link of its
           # chain), else nil: the lists draw chains from it.
-          continues: session.continues,
+          continues: row.continues,
           # A review session's {subjects, from} (SessionReview), else nil:
           # the session bar offers Start review on the others.
           review: session.review&.to_file,
           first_preview: first_preview_for(session),
           # The session's own name (/title), else nil: the pages show it in
           # place of the first message.
-          title: session.title,
-          owner: owner&.kind,
+          title: row.title,
+          owner: row.owner,
           # The saved recap's first sentence, for the session card, and the
           # auto title its reply led with (RecapTitle), else nil: an untitled
           # session's name on the pages and its pushes (never in a model
           # request).
-          recap: recap_card.preview,
-          auto_title: recap_card.title,
+          recap: row.recap,
+          auto_title: row.auto_title,
           # How full the context was after the last turn (%), or nil, and
           # the session's token sums and cost (the card's ctx tooltip), from
           # one read of analytics.json.
-          ctx_pct: saved&.ctx_pct&.round(1),
+          ctx_pct: row.ctx_pct,
           tokens: saved&.tokens,
           # The memory indexes its prompt held (the card's ctx tooltip).
           memory_index: saved&.memory_index,
           # Its side requests, apart from the tokens (the tooltip's own line).
           side: saved&.side,
           # Hidden from the strip and the list unless the all view's "archived" toggle is on.
-          archived: ArchiveStore.archived?(session_dir),
-          project_root: session.project_root(cache: root_cache),
+          archived: row.archived,
+          project_root: row.project,
           # A worker is reachable: WorkerLink answers Live (the lock held by
           # a worker whose sidecar names its pid). A sidecar a dead worker
           # left is not up.
@@ -108,8 +119,8 @@ module Samagotchi
           # For the tab's notifications (notify.js): an open question, the
           # running turn's open card with actions, and how the last turn
           # ended. A question saved by a worker that died is not open, nor a
-          # one-turn chi run's (only a worker shares it).
-          pending_question: session.waiting_question(live: !!owner&.worker?),
+          # one-turn chi run's (only a worker shares it): the row's live.
+          pending_question: session.waiting_question(live: row.live),
           pending_card: up ? Bridge::PendingCard.read(session_dir) : nil,
           last_turn: session.last_turn&.to_file,
           # Its Verify verdicts, the fresh ones its worker hasn't taken yet
@@ -117,9 +128,10 @@ module Samagotchi
           # ({of, child_id}: the card's "verifying fresh" and its link).
           verdicts: VerifyFresh.verdicts_of(session, session_dir),
           verify_fresh: VerifyFresh.running(session.id, state_dir: File.dirname(session_dir))
-                                   .map { |row| { of: row[:of], child_id: row[:child_id] } },
+                                   .map { |entry| { of: entry[:of], child_id: entry[:child_id] } },
           last_verdict: last_verdict(session, session_dir)
         }
+        WEB_KEYS.to_h { |key| [key, values.fetch(key)] }
       end
 
       def last_verdict(session, session_dir)
@@ -141,18 +153,17 @@ module Samagotchi
       # no network) is resolved only for a session that has a saved context
       # to count. One registry per caller (the hub) or one built here.
       def budget_resolver(session, registry)
-        -> { LLMContextStrategy.session_budget(session, registry: registry ||= HostRegistry.new) }
+        -> { EffectiveModel.session_budget(session, registry: registry ||= HostRegistry.current) }
       end
       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)

data/lib/samagotchi/worker.rb

@@ -37,6 +37,7 @@ require_relative "model_profile"
 require_relative "child_reports"
 require_relative "verify_fresh"
 require_relative "child_move"
+require_relative "starting_marker"
 require_relative "context_absorber"
 require_relative "context_candidates"
 require_relative "context_poller"
@@ -47,7 +48,7 @@ require_relative "participant_name"
 
 module Samagotchi
   # The loop of a background session worker, once it owns the session (see
-  # SessionManager.run_session_loop, which takes the OwnerLock around #run).
+  # WorkerBoot.run_session_loop, which takes the OwnerLock around #run).
   #
   # It runs the session's Engine and Bridge, takes queued prompts from the
   # input dir one turn at a time, and returns when nobody has used it for the
@@ -57,8 +58,8 @@ module Samagotchi
   # exits with 1.
   #
   # The file IPC stays behind SessionInbox's functions (find_new_input_files,
-  # claim_input_file, ...) and the Bridge behind SessionManager.start_bridge,
-  # which specs stub as seams.
+  # claim_input_file, ...) and the Bridge behind #start_bridge, which specs
+  # stub as seams.
   #
   # The loop sleeps on a Waker, which the Bridge wakes when it queues a turn
   # or a command, and the reminder callback when it queues one. A fallback
@@ -132,11 +133,11 @@ module Samagotchi
     # @param idle_exit_minutes [Numeric, nil] nil: session.idle_exit_minutes
     # @param poll_interval [Numeric, nil] seconds between fallback ticks
     # @param signals [WorkerSignals, WorkerSignals::None] the process's
-    #   trapped signals (SessionManager.run_session_loop); none by default
+    #   trapped signals (WorkerBoot.run_session_loop); none by default
     # @param signal_grace [Array(Numeric, Numeric, Numeric)] the grace, the
     #   short grace and the hard exit's delay (specs shorten them)
     # @param owner_lock [OwnerLock, nil] the session's, which this process
-    #   holds (SessionManager.run_session_loop): marked leaving as the Bridge
+    #   holds (WorkerBoot.run_session_loop): marked leaving as the Bridge
     #   stops, so an attach waits for the recap on leave (OwnerLock.await_release)
     def initialize(session_id:, state_dir:, session_dir:, idle_exit_minutes: nil, poll_interval: nil,
                    signals: WorkerSignals::NONE, signal_grace: [SIGNAL_GRACE, SIGNAL_SHORT_GRACE, SIGNAL_HARD_EXIT],
@@ -185,16 +186,16 @@ module Samagotchi
     end
 
     # Whether the session was empty as the worker left it, so the caller
-    # deletes it once the lock is free (SessionManager.run_session_loop
+    # deletes it once the lock is free (WorkerBoot.run_session_loop
     # checks again then).
     def discard? = @discard
 
     # Whether this worker runs a `chi scratch` session: deleted as it leaves
-    # (SessionManager.run_session_loop).
+    # (WorkerBoot.run_session_loop).
     def scratch? = !!@session&.scratch
 
     # Whether delegate reports wait that an idle parent runs a turn for
-    # (#wake_state): SessionManager.run_session_loop starts a new worker
+    # (#wake_state): WorkerBoot.run_session_loop starts a new worker
     # for them after this one leaves. Reports the budget or a failure held
     # back wait for the next human input instead.
     def wake_due? = wake_state == :due
@@ -208,7 +209,7 @@ module Samagotchi
     #   (chi stop), :signal when a signal stopped it (WorkerSignals),
     #   :crashed when the loop raised (the session is marked errored),
     #   :scratch_left when a scratch session's terminal is gone (the caller
-    #   deletes it); SessionManager.run_session_loop turns it into the exit
+    #   deletes it); WorkerBoot.run_session_loop turns it into the exit
     def run
       # The thread a signal's expired grace raises in (the main thread in a
       # worker process).
@@ -261,7 +262,7 @@ module Samagotchi
       # This worker holds the session now (a continue's starting marker held
       # off any other until it did), and a continue that died moving
       # delegates here left its intent: finish it.
-      ChildMove.clear_starting(@session_id, state_dir: @state_dir)
+      StartingMarker.clear(@session_id, state_dir: @state_dir)
       ChildMove.adopt(@session_id, state_dir: @state_dir)
       @session = Session.load(@session_id, state_dir: @state_dir)
       # A newer chi saved it: this worker keeps the fields it doesn't know
@@ -362,25 +363,25 @@ module Samagotchi
     # The Bridge (UIs and clients reach the worker from here on), then the
     # idle-exit policy.
     def serve
-      @bridge = SessionManager.start_bridge(engine: @engine, state_dir: @state_dir, session_id: @session_id,
-                                            on_input: -> { @waker.wake },
-                                            on_command: method(:on_command),
-                                            on_exit_request: method(:exit_request),
-                                            # Decided again as it leaves (a note may still come in).
-                                            exit_discards: method(:empty_session?),
-                                            # What a stop-all /exit stopped, for its 200.
-                                            exit_stopped: method(:stopped_holds),
-                                            # chi web's Stop asks about these before TERMed-ing
-                                            # the worker (its own holds routes).
-                                            on_holds: -> { @idle_exit&.stoppable_holds },
-                                            on_holds_stop: -> { @hold_stop&.stop_all })
+      @bridge = start_bridge(engine: @engine, state_dir: @state_dir, session_id: @session_id,
+                             on_input: -> { @waker.wake },
+                             on_command: method(:on_command),
+                             on_exit_request: method(:exit_request),
+                             # Decided again as it leaves (a note may still come in).
+                             exit_discards: method(:empty_session?),
+                             # What a stop-all /exit stopped, for its 200.
+                             exit_stopped: method(:stopped_holds),
+                             # chi web's Stop asks about these before TERMed-ing
+                             # the worker (its own holds routes).
+                             on_holds: -> { @idle_exit&.stoppable_holds },
+                             on_holds_stop: -> { @hold_stop&.stop_all })
       # What failed to load and what plugins showed as they loaded, now that
       # a UI can be there (a late one gets them in the snapshot).
       @engine.announce_load_events!
       announce_session_warnings
       @idle_exit = WorkerIdleExit.new(
         engine: @engine, bridge: @bridge,
-        timeout_minutes: @idle_exit_minutes || SessionManager.config_idle_exit_minutes,
+        timeout_minutes: @idle_exit_minutes || config_idle_exit_minutes,
         input_pending: method(:input_pending?),
         awaiting_continue: -> { @turn_flow.awaiting_continue? },
         running_tasks: -> { Tools::TaskRuntime.running_created_in(@engine.messages_checkpoint) },
@@ -398,6 +399,33 @@ module Samagotchi
                                 state_dir: @state_dir)
     end
 
+    # Start the in-process Bridge transport for this worker. The bridge is
+    # the single live client transport, so every worker starts it. Bridge
+    # creation happens *before* the loop so the capture observer is in place
+    # for the whole session; the caller stops the returned instance on exit
+    # (see #run's ensure).
+    #
+    # @return [Samagotchi::Bridge, nil] nil when the transport failed to start
+    #   (the worker degrades: turns still flow through the input-dir loop, but
+    #   there is no live SSE or in-process cancel/answer).
+    # @param on_input [#call, nil] called after the Bridge queues a turn
+    def start_bridge(engine:, state_dir:, session_id:, on_input: nil, on_command: nil, on_exit_request: nil,
+                     exit_discards: nil, exit_stopped: nil, on_holds: nil, on_holds_stop: nil)
+      require_relative "bridge"
+      Samagotchi::Bridge.new(
+        engine: engine, state_dir: state_dir, session_id: session_id, input_format: SessionInbox::INPUT_FORMAT,
+        on_input: on_input, on_command: on_command, on_exit_request: on_exit_request, exit_discards: exit_discards,
+        exit_stopped: exit_stopped, on_holds: on_holds, on_holds_stop: on_holds_stop
+      ).start
+    rescue StandardError => e
+      Log.error(:bridge, "start_failed", echo: "Bridge: failed to start for session #{session_id}: #{e.class}: #{e.message}", sid: session_id, error: e.class.name)
+      nil
+    end
+
+    def config_idle_exit_minutes
+      Degrade.call(:config, "idle_exit_minutes_unreadable") { Samagotchi::Config.get("session.idle_exit_minutes") }
+    end
+
     # The delegate children of this session that are running a turn or have
     # a live worker. ChildrenStatus.of scans the session files; this runs on
     # an exit request, not every pass.
@@ -648,13 +676,14 @@ module Samagotchi
       save_or_log(:interrupted_turn) { save_session }
     end
 
-    # The per-input tombstones (removed, settled) older than
+    # The per-input tombstones (removed, settled, merged) older than
     # SessionInbox::TOMBSTONE_MAX_AGE, once per worker start: they only go
     # with the session dir otherwise.
     def prune_tombstones
       removed = SessionInbox.prune_removed(@session_dir)
       settled = TurnCheckpoint.prune_settled(@session_dir)
-      Log.info(:worker, "tombstones_pruned", removed: removed, settled: settled) if (removed + settled).positive?
+      merged = SessionInbox.prune_merged(@session_dir)
+      Log.info(:worker, "tombstones_pruned", removed: removed, settled: settled, merged: merged) if (removed + settled + merged).positive?
     end
 
     # A saved parent_answers that isn't a level reads as hard on every
@@ -882,14 +911,31 @@ module Samagotchi
       # A failure has no prompt to hand back (the Engine announced
       # :turn_failed). The offer went before the turn
       # (ContinueOffer#drop); either way the rollback window closes.
-      run_engine_turn(nil, continue: true, origin: REMINDER_ORIGIN,
+      run_engine_turn(nil, continue: true, origin: wake_origin(REMINDER_ORIGIN),
                            max_iterations: IterationLimit.for) { @turn_flow.after_reminder_turn }
       true
     end
 
-    # A reminder turn's origin: chi's own (system:reminder).
+    # A reminder turn's origin: chi's own (system:reminder). Its run gets
+    # an id of its own (#wake_origin); this constant has none.
     REMINDER_ORIGIN = TurnOrigin.new(client_id: ClientId::REMINDER)
 
+    # A turn nobody typed (a reminder, a wake) with an enqueued_id of its
+    # own, minted here as it runs, so its checkpoint mark, last_turn, reply
+    # file and settle name it (a wait with no message binds it:
+    # ReplyWait.own_turn). Never on the origin constants nor on
+    # ChildReports::Report#origin: a report merged into a turn keeps an
+    # id-less origin, which the web page reads as a report (turn_events.js
+    # promptOps), not as an unmatched steer.
+    # @return [TurnOrigin] +origin+ with an id ("wake-<16 hex>")
+    def wake_origin(origin)
+      origin.enqueued_id ? origin : origin.with(enqueued_id: "#{WAKE_ID_PREFIX}#{SecureRandom.hex(8)}")
+    end
+
+    # A wake turn's minted enqueued_id starts with this
+    # (SessionInbox::ENQUEUED_ID_NAME).
+    WAKE_ID_PREFIX = "wake-"
+
     # :due when an idle parent should run a turn for its delegate
     # children's reports now (session.delegate_reports: wake): rings wait,
     # no continue offer does (they merge into its turn), wakes aren't paused
@@ -948,7 +994,7 @@ module Samagotchi
     def run_wake(origin:, failed:, kept: nil, mark: nil)
       @turn_flow.before_prompt_turn
       restores = @turn_flow.restores
-      run_engine_turn(nil, continue: true, origin: origin, id: mark&.turn_id,
+      run_engine_turn(nil, continue: true, origin: wake_origin(origin), id: mark&.turn_id,
                            max_iterations: IterationLimit.for) do |result, error|
         if error
           steps_kept = @turn_flow.prompt_turn_failed(error: error, wake: failed, wake_kept: kept) == :kept
@@ -1303,6 +1349,8 @@ module Samagotchi
       origin = fresh_origin(turn_args[:origin])
       # Settled here: the checkpoint's prompt carries it from the start.
       turn_args = turn_args.merge(origin: origin, id: turn_args[:id] || SecureRandom.uuid)
+      # The id its drain's merge records name (SessionInbox.mark_merged).
+      @turn_enqueued_id = origin.enqueued_id
       verdicts_before = @session.verdicts.size
       @reporting_turn = reports_to_parent?(origin)
       # A participant's review turn merges no input (#pending_input_drain).
@@ -1512,6 +1560,9 @@ module Samagotchi
           begin
             input = SessionInbox.read_input(claimed_file)
             prompt = input.prompt.to_s.strip
+            # Which turn took it, on disk before its file goes (a wait for
+            # it reads this, not an inference: ReplyWait::Poll#follow_merge).
+            SessionInbox.mark_merged(@session_dir, input.origin.enqueued_id, into: @turn_enqueued_id) unless prompt.empty?
             prompt.empty? ? nil : [prompt, input.origin]
           ensure
             FileUtils.rm_f(claimed_file)
@@ -1634,7 +1685,7 @@ module Samagotchi
 
     # #leave_idle for a scratch worker its terminal left: checked again with
     # the event log held, then the intake closes. The session is deleted
-    # once the lock is free (SessionManager.run_session_loop: :scratch_left).
+    # once the lock is free (WorkerBoot.run_session_loop: :scratch_left).
     # @return [Boolean] false when a client came back since
     def leave_scratch
       stop_bridge_after do
@@ -1842,8 +1893,8 @@ module Samagotchi
     # A restart hands the reminders to the next worker (ReminderCarry), while
     # the event log is held: no turn can register or fire one from here. A
     # write that fails keeps this worker up with them rather than losing them.
-    # A session stopped meanwhile drops them (run_session_loop then starts no
-    # successor): nothing is written.
+    # A session stopped meanwhile drops them (WorkerBoot.run_session_loop
+    # then starts no successor): nothing is written.
     # @return [Boolean] false when the write failed
     def carry_reminders
       if stopped_on_disk?
@@ -1881,7 +1932,7 @@ module Samagotchi
     # @return [Symbol] +result+, with #discard? decided and, for a session
     #   kept, its recap written: the Bridge is closed and the idle jobs are
     #   stopped by now, and nothing waits on this (the TUI has detached). A
-    #   `chi send` meanwhile is picked up after the exit (run_session_loop);
+    #   `chi send` meanwhile is picked up after the exit (WorkerBoot.run_session_loop);
     #   a `chi --attach` finds no Bridge until then.
     # A restart keeps even an empty session (a new worker takes it over at
     # once) and leaves the recap to the conversation's next real pause.