samagotchi 0.154.0 → 0.155.0

data/lib/samagotchi/bridge/card_store.rb

@@ -26,7 +26,9 @@ module Samagotchi
     # holds the id of the turn it belongs to or follows (+turn_id+: the running
     # turn's, else the last one's, nil before any) and lists with +turns_since+,
     # the turns drawn after it, counted from the messages the page draws
-    # (CardPlaces, with the turn log the store keeps), and +current+ for a card
+    # (CardPlaces, with the turn log the store keeps), +opening_id+, the same
+    # place as a stamp (the id of the opening it comes after, which the page
+    # finds by its bubble; none where only the count can say), and +current+ for a card
     # of the turn running now. A card that isn't the turn's but comes while one
     # runs (an anytime command's, such as /btw) goes after that turn: its prompt
     # is already in the history. Listed against messages, an in-turn entry of a
@@ -70,7 +72,7 @@ module Samagotchi
       SAVED_ON = (%i[turn_started card hook_notice empty_answer_retry steer_cut llm_context_edited question_requested question_answered
                      question_cancelled question_relay] + Events::TURN_END).freeze
       # What only the store reads: never listed.
-      INTERNAL_FIELDS = %i[turn_id continued base_since past_idless during after_failed command].freeze
+      INTERNAL_FIELDS = %i[turn_id continued base_since past_idless after_opening during after_failed command].freeze
 
       # What a session's saved file lists, as a store started from it lists
       # (no turn running): the web's cards for a session no worker runs.
@@ -118,7 +120,8 @@ module Samagotchi
       #   them (a body re-read, a trace): no turns_since:, nothing to tell a turn
       #   that left nothing by.
       # @return [Array<Hash>] oldest first: the card's (or notice's) fields
-      #   plus current:, turns_since: with +messages+, earlier: true for one an
+      #   plus current:, turns_since: and opening_id: (CardPlaces#opening_of,
+      #   when it has one) with +messages+, earlier: true for one an
       #   earlier worker saved, during: true for a card that came while the
       #   running turn runs but isn't that turn's (it goes after the running
       #   turn's prompt), and after_failed: true for one shown after the last
@@ -141,6 +144,8 @@ module Samagotchi
 
         out = shown.except(*INTERNAL_FIELDS)
         out[:turns_since] = places.turns_since(entry) if places
+        stamp = places&.opening_of(entry)
+        out[:opening_id] = stamp if stamp
         out[:current] = current
         out[:during] = true if entry[:during]
         out[:after_failed] = true if entry[:after_failed] && entry[:turn_id] == @failed_turn
@@ -255,7 +260,7 @@ module Samagotchi
       # A hand-edited or foreign file's entry goes, rather than break every later
       # listing of the session.
       def sound_place?(entry)
-        return false unless entry[:turn_id].nil? || entry[:turn_id].is_a?(String)
+        return false unless [entry[:turn_id], entry[:after_opening]].all? { |id| id.nil? || id.is_a?(String) }
 
         entry.values_at(:base_since, :past_idless).compact.all? { |count| count.is_a?(Integer) && !count.negative? }
       end
@@ -315,8 +320,8 @@ module Samagotchi
         shown = @entries.select { |entry| entry[:turn_id] == @running_turn && !entry[:in_turn] }
         return if shown.empty? || !@messages
 
-        run = CardPlaces.new(@turn_log, @messages.call).idless_after(@running_turn)
-        shown.each { |entry| entry[:past_idless] = run if run.positive? }
+        places = CardPlaces.new(@turn_log, @messages.call)
+        shown.each { |entry| note_idless(entry, places) }
       end
 
       # The entry's anchor: the running turn, else the last one.
@@ -331,7 +336,7 @@ module Samagotchi
           # button's command replaced, which nobody typed).
           old = @entries[index]
           @entries[index] = card.except(:command).merge(updated: true, **old.slice(:in_turn, :turn_id, :during, :continued, :base_since,
-                                                                                   :past_idless, :after_failed, :command))
+                                                                                   :past_idless, :after_opening, :after_failed, :command))
         else
           entry = card.merge(in_turn: event[:in_turn] ? true : false, turn_id: anchor)
           entry[:during] = true if @running_turn && !event[:in_turn]
@@ -393,8 +398,18 @@ module Samagotchi
       def note_past_idless(entry)
         return unless @messages
 
-        run = CardPlaces.new(@turn_log, @messages.call).idless_after(entry[:turn_id])
-        entry[:past_idless] = run if run.positive?
+        note_idless(entry, CardPlaces.new(@turn_log, @messages.call))
+      end
+
+      # How many openings with no turn id +entry+ came after, and the last
+      # one's own id when it has one (+after_opening+: its stamp, #list).
+      def note_idless(entry, places)
+        run = places.idless_after(entry[:turn_id])
+        return unless run.positive?
+
+        entry[:past_idless] = run
+        after = places.after_opening(entry[:turn_id])
+        entry[:after_opening] = after if after
       end
 
       # Which cap +entry+ counts against: :notice, :llm_context or :card.

data/lib/samagotchi/bridge.rb

@@ -196,6 +196,15 @@ module Samagotchi
       @mutex.synchronize { @open_streams - (client_id ? @streams_by_client[client_id] : 0) }
     end
 
+    # Streams held by the clients whose id starts with +prefix+
+    # (ClientId::TUI_PREFIX: the attached terminals, which a scratch worker
+    # counts, Worker#scratch_unattended?). A stream that named no client
+    # (a web tab's, through the chi web proxy) is none of them.
+    # @return [Integer]
+    def open_streams_of(prefix)
+      @mutex.synchronize { @streams_by_client.sum { |client_id, count| client_id.start_with?(prefix) ? count : 0 } }
+    end
+
     # Monotonic time of the last request, stream open or stream close. The
     # worker's idle exit counts from it. A connect that sends no request (the
     # sidecar liveness probe) doesn't count.

data/lib/samagotchi/bridge_client.rb

@@ -309,12 +309,16 @@ module Samagotchi
     # older worker's 404 for a route it lacks from a refused connect, a
     # timeout or a 500.
     # @return [Array(Integer, Object)] the status and the parsed JSON body
-    #   (nil when it isn't JSON); [nil, nil] when no reply came
+    #   (nil when it isn't JSON); [nil, nil] when no reply came (a refused
+    #   connect, a timeout, a cut or garbled reply), and when anything else
+    #   failed, which is logged
     def get(path)
-      response = get_response(path)
-      [response.status, response.json]
-    rescue StandardError
-      [nil, nil]
+      Degrade.call(:bridge, "get_failed", fallback: [nil, nil], path: path) do
+        response = get_response(path)
+        [response.status, response.json]
+      rescue SystemCallError, IOError
+        [nil, nil]
+      end
     end
 
     # GET /session/:id/<path>, preserving the raw response and raising on I/O.

data/lib/samagotchi/bundle_command/check.rb

@@ -421,7 +421,7 @@ module Samagotchi
           end
         end
         { "init" => registered.inits, "toolkit" => registered.toolkits, "tool source" => registered.tool_sources,
-          "peer source" => registered.peer_sources }.each do |what, names|
+          "peer source" => registered.peer_sources, "prompt section" => registered.prompt_sections }.each do |what, names|
           names.each { |name| add(:info, :registered, plugin, "#{what} #{name}") }
         end
       end

data/lib/samagotchi/bundle_command/try/trace.rb

@@ -124,7 +124,7 @@ module Samagotchi
         end
 
         # The listing's placement fields: nothing to place in a one-turn run.
-        LISTING_FIELDS = %w[turns_since current earlier after_failed label].freeze
+        LISTING_FIELDS = %w[turns_since opening_id current earlier after_failed label].freeze
 
         # The saved cards as the web reads them (CardStore.saved), with
         # string keys and values, as the JSON trace prints them.

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

@@ -1,12 +1,12 @@
 ---
 name: btw
-version: 0.1.4
+version: 0.1.5
 scope: system
 description: "/btw <question>: a side answer about the conversation, as a card in every UI, even mid-turn; Keep as session forks it into a child session"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:6497129b06d1c3061c1d7d9d7a9c3dfdbcf790e8f2049addad0c26d24771015f
+  sha256: sha256:d4c0d6309308270a1430d64f9713e46c15d71ace1b068fefc22916aa8cc2d043
 requires_chi: ">= 0.143.0"
 # config.yml bundles: btw: (another key warns; an older chi ignores this)
 settings: [max_tokens, timeout]

data/lib/samagotchi/bundles/btw/plugin.rb

@@ -15,7 +15,7 @@ class Plugin
   SYSTEM = "Answer the user's question about the conversation below, briefly. The user asks it on the side: " \
            "don't continue the conversation's task, and don't say what you would do next."
   # How many answers /btw keep can still fork: the last ones, for the
-  # worker's (or the REPL's) life.
+  # worker's life.
   KEPT = 10
   TITLE_CHARS = 72
   EARLIER = "(About the conversation before the running turn.)"

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

@@ -1,6 +1,6 @@
 ---
 name: coordinator
-version: 0.8.0
+version: 0.8.1
 scope: system
 description: "Coordinate parallel work: the coordinator skill (split the work, one worktree and child session per task, check each report, merges under a guardrail approval (the git-merge rule) or a question, a handoff memory to resume from), /coordinate <goal>, /coordinate resume, /coordinate end, /coordinate review (experimental: a sprint review session to share) and /children; the coordinator toolkit (lean + delegate, delegate_result, list_sessions, objectives) and the coding toolkit for build children (child + be concise)"
 trust_level: reviewed
@@ -10,7 +10,7 @@ files:
     description: "Coordinate parallel work: split it, delegate each task wait:false in its own worktree (cwd:), check each report, merge under the git-merge approval or ask the user; resume from a handoff_* memory"
 plugin:
   file: plugin.rb
-  sha256: sha256:84535a86b754f3a12cdb2f2591027ea71bbf9ffb74734b1050899b9a4fde07ac
+  sha256: sha256:540dd6369342ea4dcbc6ba5ee17fb20d980b880df614a475668c70115e7ec6b8
 # the coordinator toolkit needs chi.toolkit and ctx.use_toolkit (0.66.0); the
 # coding toolkit (chi.toolkit prompt:) and the skill's delegate toolkit: need
 # the next chi.

data/lib/samagotchi/bundles/coordinator/plugin.rb

@@ -16,8 +16,9 @@
 # (ctx.sessions.stop, by session id) and shows the card again.
 #
 # /coordinate <goal> asks the model, in this session, to follow the skill
-# for the goal. A REPL session (--no-shared) takes no messages: the request
-# is shown for the user to send.
+# for the goal. A session a one-turn run holds (-p --non-interactive, or an
+# older chi's terminal) takes no messages: the request is shown for the user
+# to send.
 #
 # /coordinate resume picks up a coordinator handoff: the open handoff_*
 # memories of this project (an index line whose description doesn't start

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

@@ -1,10 +1,10 @@
 ---
 name: dev
-version: 0.7.7
+version: 0.7.8
 scope: system
 description: "Developer tools"
 trust_level: reviewed
-requires_chi: ">= 0.154.0"
+requires_chi: ">= 0.155.0"
 includes:
 - known-names
 - mcp
@@ -18,3 +18,4 @@ includes:
 - ruby
 - model-notes
 - decision-card
+- inline-widgets

data/lib/samagotchi/bundles/github-pr/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: github-pr
-version: 0.6.3
+version: 0.6.4
 scope: system
 description: Proposes the branch's open GitHub pull request to a session, attached once you mention it (#N, the branch or its URL), and attaches any PR URL with chi context add or the web's "+ URL"; the agent gets a note when reviews, comments, checks or its state change; in the web, a path:line in an answer links to that line of the PR; the auto_attach setting can attach the PR at once instead, or do nothing
 trust_level: reviewed
@@ -11,7 +11,7 @@ needs:
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:82f8c76d38f314c3503eef3a5de0f8c0b20d0bb5bf4a3daebca43b60d00f8c7a
+  sha256: sha256:87678c39565a3d586b462d0449a27ee3da4a96f53ef5b352dea959256f6c1eda
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers:

data/lib/samagotchi/bundles/github-pr/plugin.rb

@@ -29,11 +29,11 @@ require "samagotchi/git_env"
 # diff" (or "File at head") action the web's ref menu offers. The
 # after_turn hook links from a per-PR cache and never runs gh (the web holds the answer until the hooks are
 # done); before_turn, before_generation and the init task fill the cache
-# off the turn's thread (`gh api`), in a session worker only: the REPL and
-# -p --non-interactive show no web page while they run (ctx.frontend; a chi
+# off the turn's thread (`gh api`), in a session worker only: -p
+# --non-interactive shows no web page while it runs (ctx.frontend; a chi
 # without it counts as a worker), and a scratch session never fetches.
 # `bundles: github-pr: line_links:` false turns it off, "always" fetches in
-# the REPL and -p too (still not for a scratch session).
+# -p --non-interactive too (still not for a scratch session).
 #
 # `bundles: github-pr: auto_attach:` says what the init task does with the
 # branch's open PR: `propose` (the default, above), `attach` (attached at

data/lib/samagotchi/bundles/inline-widgets/manifest.yml

@@ -0,0 +1,11 @@
+---
+name: inline-widgets
+version: 0.1.0
+scope: system
+description: "Teaches the model the chi-ui blocks chi web draws: picks (rows of options that fill your reply) and walk (a scenario stepped through)"
+trust_level: reviewed
+plugin:
+  file: plugin.rb
+  sha256: sha256:24ad0c3f0ffb592826b4a7389111d76723e9f28ea4d94ab63abda7986d3311bb
+# chi.prompt_section is 0.132.0's; the web draws chi-ui blocks only from the next release
+requires_chi: ">= 0.155.0"

data/lib/samagotchi/bundles/inline-widgets/plugin.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# The inline-widgets bundle (docs/bundles.md, The inline-widgets bundle): two
+# prompt sections that teach the model the ```chi-ui blocks chi web draws
+# (docs/internals/inline-widgets.md): picks, rows of options that fill the
+# user's reply, and walk, a scenario stepped through. The drawing is core's; this
+# bundle only says the blocks exist. Uninstalled, the prompt loses the sections
+# and blocks already in a history still draw.
+#
+# The text is eval 0013's round-2 hint, split in two. It is static, so the
+# prompt cache keeps: same text at every build. A delegate child's answer is
+# read by its parent, not drawn for a user, and a one-shot (-p --non-interactive)
+# prints to a terminal: neither gets a section.
+class Plugin
+  PICKS = <<~TEXT
+    The web UI draws fenced ```chi-ui code blocks (YAML inside) as interactive widgets; the terminal shows their source. Use one whenever it helps the user more than prose: a widget replaces the long explanation, it doesn't sit beside one. Never use one for what markdown shows well (tables, lists, key-value). At most one widget per answer; keep the prose around it to a few sentences and don't repeat the widget's content.
+
+    picks: whenever your answer leaves the user two or more things to decide (review findings, a plan's open decisions, which of several fixes to do), even if they didn't ask you to list them. The user clicks one option per row, can add a note, and the UI fills their reply.
+    ```chi-ui
+    type: picks
+    title: What to do with the findings
+    rows:
+      - id: "1"                       # unique, short; the user's reply names it
+        text: Bridge drops the replay buffer on reset    # the item, <= 80 chars
+        options:                      # 2-4 short options, one per line
+          - fix now
+          - skip
+          - later
+        recommended: fix now          # exactly one of the options
+        why: loses events a slow tab still needs        # optional, one short line
+    ```
+    Every row id unique; a row's options unique. Quote a value that starts with a quote or contains ": ".
+  TEXT
+
+  WALK = <<~TEXT
+    walk is the other ```chi-ui widget (the same rules: the web UI draws it, at most one widget per answer): a scenario the user steps through one step at a time: who does what, what the user sees, what happens behind it. Use it for "when does this happen / how does this work / what does the user go through" questions.
+    ```chi-ui
+    type: walk
+    title: A tab reconnects
+    actors: [user, web, worker]       # 2-5 short ids, unique
+    steps:
+      - id: s1                        # unique
+        actor: user                   # one of actors
+        does: reopens the laptop      # the action, <= 80 chars
+        sees: the page shows "reconnecting"     # optional: what the user sees at this step
+        behind: the tab sends GET /events with Last-Event-ID     # optional: what happens out of sight
+      - id: s2
+        actor: worker
+        does: checks the event id
+        cases:                        # optional: the step forks. List EVERY case, the usual one too
+          - when: the id is still buffered
+            goto: s3
+          - when: the id is too old
+            goto: s4
+      - id: s3
+        actor: worker
+        does: replays the missed events
+        next: end                     # optional: where to go after this step (default: the step below); end ends the walk here
+      - id: s4
+        actor: web
+        does: reloads the whole session
+        sees: the page redraws from the top
+    ```
+    A step needs `does` or `sees` (or both). Steps run in order unless `next` or `cases` say otherwise. Every id unique; every goto names a step; a next names another step or is `end`. Quote a value that starts with a quote or contains ": ".
+  TEXT
+
+  def register(chi)
+    chi.prompt_section("picks") { |ctx| PICKS if drawn?(ctx) }
+    chi.prompt_section("walk") { |ctx| WALK if drawn?(ctx) }
+  end
+
+  private
+
+  # Whether the session's answers reach a web page that draws them.
+  def drawn?(ctx) = ctx.frontend != :one_shot && !ctx.delegate?
+end

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

@@ -1,12 +1,12 @@
 ---
 name: skills
-version: 0.1.9
+version: 0.1.10
 scope: system
 description: "Skills (skill_<name> memories, the steps of a task done together): /skill save, list, show and diff; older versions kept with a short diff line on every update; a nudge when a followed skill's step fails"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:781d943749d59ade0e24d04ba774449d31267eb8ca435835c36c67a3e523e632
+  sha256: sha256:8d72d29286d0807c18d2c37225455ca06d45f4f974f9335b76cc77916043838c
 requires_chi: ">= 0.143.0"
 # config.yml bundles: skills: (another key warns; an older chi ignores this)
 settings: [history_keep, nudge]

data/lib/samagotchi/bundles/skills/plugin.rb

@@ -242,8 +242,9 @@ class Plugin
   # what was just done (the model has seen the commands; a side answer
   # wouldn't). The request runs as a turn; sent while a turn runs it joins
   # that turn at its next step, and the request says to finish the task
-  # first. A REPL session (--no-shared) takes no messages: the request is
-  # shown for the user to send.
+  # first. A session a one-turn run holds (-p --non-interactive, or an older
+  # chi's terminal) takes no messages: the request is shown for the user to
+  # send.
   def save(rest, ctx)
     words = rest.split
     scope = words.delete("--system") ? "system" : "project"

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

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

data/lib/samagotchi/desktop/macos/ChiRunner.swift

@@ -199,7 +199,7 @@ final class ChiRunner {
   private static let recentFlags = ["--limit", "20"]
 
   /// The live rows, then up to +recentCount+ of the recent list that are
-  /// neither live nor a REPL's; a failed recent list adds none.
+  /// neither live nor held by an owner (a one-turn run); a failed recent list adds none.
   private static func rows(live: [LiveSession], recent: Result<[LiveSession], ChiError>, recentCount: Int) -> [LiveSession] {
     let liveIds = Set(live.map(\.id))
     let stopped = ((try? recent.get()) ?? [])

data/lib/samagotchi/engine/context_judge.rb

@@ -2,137 +2,31 @@
 
 module Samagotchi
   class Engine
-    # The attached-context candidate judge (ContextJudge): its pass at an
-    # owner turn's start and for a late candidate, the asks it starts, and
-    # the cards it shows after the turn. Reads @context_cards_after_turn
-    # under @context_cards_mutex, @side_judgments, @host_registry, @session.
+    # The attached-context candidate judge (TurnStages::ContextJudge,
+    # forwarded): prepare_turn starts its pass, run_turn's ensure shows the
+    # cards it held, and a plugin's late candidate asks it. Reads
+    # @context_judge, @side_judgments, @host_registry.
     module ContextJudgePart
       private
 
-      # The candidate judge (ContextJudge) at an owner turn's start, after
-      # the toolkit's ask settled: the session's candidates' status changes
-      # are logged (ContextCandidatesLog#look) and, unless
-      # context.candidates.mode is off, the proposed candidates due an ask
-      # are asked about the owner's prompts so far, this one included. Never
-      # a participant's turn, a review session or a Continue (no new prompt).
-      def start_context_judge(turn)
-        session = turn.session
-        return unless turn.prompt.is_a?(String) && OwnerPrompt.turn?(session: session, author: turn.origin.author)
-
-        context_judge_pass(session, ContextCandidates.owner_texts(session.messages) + [turn.prompt], phase: "turn")
-      end
-      private :start_context_judge
+      # The judge's stage (TurnStages::ContextJudge).
+      attr_reader :context_judge
 
       # A late proposal no owner prompt mentions (Plugin::Host
-      # #candidate_proposed: github-pr's init task runs beside the first
-      # turn): judged on the owner's prompts so far, the running turn's too.
-      def judge_late_candidates
-        session = @session
-        return if session.nil? || session.review?
-
-        texts = ContextCandidates.owner_texts(plugin_messages)
-        context_judge_pass(session, texts, phase: "late") unless texts.empty?
-      end
-      private :judge_late_candidates
-
-      # One look at +session+'s candidates; the asks go to SideJudgments'
-      # :context kind, one thread asking each due candidate in turn.
-      def context_judge_pass(session, texts, phase:)
-        return if session.id.nil? || session.scratch
-
-        rows = ContextCandidates.with_status(session.id, project_root: session.project_root, state_dir: session_state_dir)
-        return if rows.empty?
-
-        log = ContextCandidatesLog.log_for(session_state_dir)
-        records = ContextCandidatesLog.records_for(log, session.id)
-        ContextCandidatesLog.look(log, session.id, rows, records) if phase == "turn"
-        settings = ContextJudge::Settings.from_config
-        return if settings.mode == "off"
-
-        jobs = ContextJudge.jobs(rows, records, session_id: session.id, texts: texts, settings: settings, phase: phase,
-                                                parent_attached: context_parent_attached(session))
-        return if jobs.empty?
-
-        client = system_one_recording(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :context),
-                                      ContextJudge::JUDGMENT, session, mode: settings.mode)
-        return unless client
-
-        start_context_asks(client, jobs, log, settings, context_choice(session, log, settings))
-      rescue StandardError => e
-        ContextJudge.warn(e)
-      end
-      private :context_judge_pass
-
-      # @return [Thread, nil] the asks' thread, nil when none started
-      def start_context_asks(client, jobs, log, settings, choice)
-        if @side_judgments.in_flight?(:context)
-          Log.info(:context, "context_judge_in_flight_skipped", session_id: jobs.first.session_id)
-          return nil
-        end
-
-        @side_judgments.start(:context, warn: ContextJudge.method(:warn)) do
-          jobs.each { |job| choice.call(job, ContextJudge.ask(client: client, job: job, log: log, settings: settings)) }
-        end
-      end
-      private :start_context_asks
-
-      # What an answer does on the asks' thread (ContextCandidateChoice
-      # #after_judged: on mode attaches or cards; audit nothing). Taken on
-      # the caller's thread. The attach only writes the session's folder: its
-      # note comes with the next between-turn delivery, never into a running
-      # turn. A card shows only while this Engine is still on that session,
-      # and not in a running turn (it isn't the turn's: no "waiting for you"
-      # on it), but once it has ended.
-      # @return [#call] (job, fields)
-      def context_choice(session, log, settings)
-        session_id = session.id
-        project_root = session.project_root
-        state_dir = session_state_dir
-        show = lambda do |**card|
-          current = @session
-          next nil unless current.nil? || current.id == session_id
-
-          @context_cards_mutex.synchronize do
-            next @context_cards_after_turn << card if turn_running?
-
-            show_card(**card)
-          end
-        end
-        lambda do |job, fields|
-          ContextCandidateChoice.after_judged(job: job, fields: fields, settings: settings, project_root: project_root,
-                                              state_dir: state_dir, log: log, show_card: show)
-        end
-      end
-      private :context_choice
-
-      # The cards #context_choice held while a turn ran (#run_turn's ensure,
-      # after the turn flag is released).
-      def show_context_cards_after_turn
-        cards = @context_cards_mutex.synchronize { @context_cards_after_turn.slice!(0..) }
-        cards.each { |card| show_card(**card) }
-      rescue StandardError => e
-        ContextJudge.warn(e)
-      end
-      private :show_context_cards_after_turn
-
-      # A delegate child's parent's sources, by title (else name): the
-      # judge's started_from. nil for any other session (a chi send --new
-      # session has no parent; a fork isn't a delegate).
-      def context_parent_attached(session)
-        return nil unless session.delegate? && session.parent_id
-
-        parent_root = if Session.exist?(session.parent_id, state_dir: session_state_dir)
-                        Session.load(session.parent_id, state_dir: session_state_dir).project_root
-                      else
-                        session.project_root
-                      end
-        ContextSources.attached(session.parent_id, project_root: parent_root, state_dir: session_state_dir)
-                      .map { |attached| attached.source.title || attached.name }
-      rescue StandardError => e
-        Log.warn(:context, "context_parent_attached_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-        []
+      # #candidate_proposed): TurnStages::ContextJudge#late_candidates.
+      def judge_late_candidates = @context_judge.late_candidates
+
+      # The stage over this Engine's side asks and its session (built in
+      # #build_tools_and_plugins, before the plugins load: one may propose a
+      # candidate as it loads).
+      def build_context_judge
+        TurnStages::ContextJudge.new(
+          side_judgments: @side_judgments, host_registry: @host_registry, state_dir: -> { session_state_dir },
+          recording: ->(client, judgment, session, mode:) { system_one_recording(client, judgment, session, mode: mode) },
+          session: -> { session }, messages: -> { plugin_messages }, turn_running: -> { turn_running? },
+          show_card: ->(**card) { show_card(**card) }
+        )
       end
-      private :context_parent_attached
     end
   end
 end

data/lib/samagotchi/engine/guardrails.rb

@@ -76,11 +76,13 @@ module Samagotchi
       end
 
       # Ask the user to approve a call the gate voted `ask` on
-      # (GuardrailWiring#request_approval).
+      # (GuardrailWiring#request_approval), for the running turn (its
+      # author), else the last one. The gate's own asks come with their
+      # call's TurnContext instead.
       # @param verdict [Guardrails::Verdict]
       # @return [Guardrails::Verdict]
       def request_approval(verdict)
-        @guardrail_wiring.request_approval(verdict)
+        @guardrail_wiring.request_approval(verdict, turn_context || last_turn_context)
       end
     end
   end

data/lib/samagotchi/engine/messages.rb

@@ -46,7 +46,7 @@ module Samagotchi
                      from_cwd: note[:from_cwd], text: note[:text], context_source: note[:context_source],
                      created_at: note[:created_at], objectives: entry }.compact)
           announce_objectives(session) if entry
-          objectives_audit.note(session, note)
+          @objectives_stage.note(session, note)
           message
         end
       end
@@ -76,14 +76,17 @@ module Samagotchi
       # register it on the kernel's llm_context_turn): the same array the loop
       # appends to, not a copy, so read it on the turn's thread (the pending
       # input drain, at an iteration boundary: TurnCheckpoint), or from another
-      # only as a dup, read only (/objectives). nil when no
-      # turn runs (llm_context_turn is never cleared, and still holds the
-      # last turn's then).
+      # only as a dup, read only (/objectives). nil when no turn runs, and
+      # while the running turn's loop has yet to register its own
+      # (llm_context_turn is never cleared, and still holds the last turn's
+      # then: its turn_id tells them apart).
       # @return [Array<Hash>, nil]
       def live_conversation
-        return nil unless turn_running? && @kernel.respond_to?(:llm_context_turn)
+        running = turn_context
+        return nil unless running && @kernel.respond_to?(:llm_context_turn)
 
-        @kernel.llm_context_turn&.conversation
+        forget = @kernel.llm_context_turn
+        forget&.turn_id == running.id ? forget.conversation : nil
       end
 
       # Append messages to the current session's conversation.