samagotchi 0.87.0 → 0.88.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bfd7070b1c55cbb0e0647a79ec729996a78318ca2b2f4ccbf19c24ce7240eb9
-  data.tar.gz: 5fa4d754f3c9bb79767978d3b9fa6ac1c7091c84897a9043f3ad3129bd98c24c
+  metadata.gz: f395ab65a9e00861ae1dda52090efbbe363946df8098702f14c41cdc665f7bb3
+  data.tar.gz: 9f22902c72237fd51481b78f1cc91197fdc474e7f5b816e0a4429d354eb5c0aa
 SHA512:
-  metadata.gz: 787b7debd71f8a408ffaa801bd7d352de1f3769d018959b35e3933b16641efb194220630482d14f5ec32d4c50b5fce8f56c8a78b88a1fc1c2de58c2e05e6b361
-  data.tar.gz: 5f3759bd7c6e1e9fea4e5b7af8eab1c107d5296f9eba85b0b99fd42381c5a1c3dbb01b7efb86b52ec14b11958333110a97cfab80b5d8fd5a3a1489cab2f50bdd
+  metadata.gz: 2db614ca70a821eb84905eef2d8a8fead4ac4c95b9521cb32417e034fd9f6c923dd97974f25aa2a401d3131fa479ac1911bc8e8f41aa1f383b4e34f925c51078
+  data.tar.gz: 0a2625e7ce2e7022628f5a1e14c6277eeab21caf21ae4968e908cfe68735be5c39dea2f638137f96b63a0d0ed0796f60bc7c1d3a4e71db87dc453716012957cc

data/CHANGELOG.md

@@ -8,6 +8,20 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.88.0] - 2026-10-19
+
+### Added
+
+- A `delegate` child's hook question (the cost cap's Continue/Stop, a bundle's `ctx.ask_user`) now reaches its parent,
+  in the background too: reported to the parent's model when it may pick something other than a deny under the
+  child's `parent_answers` (so under the default `soft` a background parent may Continue its child's cost cap), else
+  relayed to the parent's user as a card, as approvals are.
+
+### Fixed
+
+- A session file whose `parent_answers` isn't `hard`, `standard` or `soft` (a hand edit) now gets one warning when
+  its worker loads it, instead of being read as `hard` silently.
+
 ## [0.87.0] - 2026-10-19
 
 ### Added
@@ -3481,7 +3495,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.87.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.88.0...HEAD
+[0.88.0]: https://github.com/dm1try/samagotchi/compare/v0.87.0...v0.88.0
 [0.87.0]: https://github.com/dm1try/samagotchi/compare/v0.86.0...v0.87.0
 [0.86.0]: https://github.com/dm1try/samagotchi/compare/v0.85.0...v0.86.0
 [0.85.0]: https://github.com/dm1try/samagotchi/compare/v0.84.0...v0.85.0

data/docs/cli.md

@@ -491,9 +491,9 @@ file and index line stay as they are; only this session doesn't see it.
 - Names are checked before the launch, warnings only: `Warning: --memory 'x'
   not found`, `Warning: --mute 'x' matches no memory`, `Warning: 'x' is both
   --memory and --mute; muted`.
-- `--attach ID` or `--resume ID` with either flag: the session's prompt is
-  already built, so the flags are ignored with one line,
-  `(--mute applies to a new session; <id>'s prompt is already built)`.
+- `--attach ID` or `--resume ID` with either flag: the session keeps its
+  own, so the flags are ignored with one line,
+  `(--mute applies to a new session; <id> keeps its own)`.
 - The status row shows `mem: <used and preloaded>` and `muted: <names>`; the
   Web UI's info-bar tooltip shows `memories: … · preloaded: … · muted: …`.
 - The `read` tool on `memories/<name>.md` is not refused (a guardrails rule

data/docs/guardrails.md

@@ -103,7 +103,12 @@ The file tools can't write the store.
 ### Answers from a parent agent
 
 A chi parent's `delegate` children don't need any of this for approvals: they
-go to the user on the parent's own card (the approval relay). This section is
+go to the user on the parent's own card (the approval relay), as do the hook
+questions (the cost cap's Continue/Stop, a bundle's `ctx.ask_user`) where the
+parent may pick nothing but a deny under the child's `parent_answers`; the
+others come back to the parent's model with the block below. A dismissal
+always passes (the hook decides what no answer means): the strategy is a
+convention for an honest parent, not a barrier. This section is
 the path for other agents, and for a chi parent that can't host the relay (a
 `--no-shared` REPL, `--non-interactive`): there the model gets the question
 block and the rules below. With the relay, the same rules still hold for a

data/docs/sessions.md

@@ -278,13 +278,13 @@ The `delegate` tool hands a task to a **child session**: an ordinary chi session
 - A wait that timed out or was canceled still gets its delegate report: neither moves the parent's cursor, so the child's reply comes as a report when its turn ends. The result says so (`chi brings its reply here by itself as a delegate report …`; with `queue`, that it joins the next step or turn) and that `delegate_result` waits again only if the turn needs the reply now. A parent that gets no reports (`session.delegate_reports: off`, a `--no-shared` REPL, `--non-interactive`) is told `delegate_result <id> waits again` instead, and `wait: false`'s result says `delegate_result waits for its reply`.
 - What a wait returns, `session: <id>` then `status:` and the text, with the status words `chi send --wait --format json` uses: `answered` with the reply after a `---` line; `question` as soon as the child opens a question (the model's own, or a hook's), with the question's text, options and the `chi answer` command for it (nothing is answered for it: `chi answer`, attach or use the web, then wait again); `failed`, `canceled` or `no_answer` when the child's turn ended with nothing to say (its session shows what happened); `error` (its worker crashed) or `stopped` (`chi sessions stop`) at once; `worker_gone` when the child has had no worker for 15 seconds (it crashed without saying so, or idle-exited): `delegate` with `session:` starts it again; `running` on timeout, or when the parent's own turn is canceled (the child keeps running; the next turn can wait again). A reply saved before the child's worker idle-exited is returned at once.
 - **A child's step-limit question goes back to the parent model**, not to its user: `delegate_result` returns `status: question` with the `chi answer` commands for Continue and Stop, and says the model may instead send a narrower follow-up (`delegate session:`, which drops the question) or report back. A parent's `chi answer` follows `guardrails.parent_answers`, or the child's own when stricter (`hard`: Stop only; see [chi as a sub-agent](sub-agent.md#the-step-limit)).
-- **A child at its cost cap** (the [cost-cap bundle](plugins.md#the-cost-cap-bundle), the child's own cap: `child:` in its settings, or `/cap`) asks a `hook` question, "Cost cap": a parent waiting on it (`delegate`, `delegate_result`) gets it back as `status: question` with the `chi answer` commands, `--option Continue` or `--option Stop` (under `guardrails.parent_answers: hard`, config.yml's or the child's own, a parent's Continue is refused: Stop only). A **background** child (`wait: false`) paused at its cap does not wake its parent: delegate reports skip hook questions (they are the user's, on the child's card) and the approval relay carries approvals only, so the child waits on its card, with the web's bell. The parent sees it at its next `delegate_result`.
-- **A child's approvals go to the parent's user** (the approval relay). While the parent waits (`delegate`, `delegate_result`), a guardrail approval the child opens reopens as the parent session's own approval: the same card in the parent's web page and attached terminal, with the same facts and diff, a line naming the delegate and its task (`delegate ab12 · fix the flaky spec…`, linked to its session) and the header `Approve delegate ab12's tool call?`. The options are the child's, by index; "for the session" says it is the delegate's session (the session scope keys on the child; repo and rule approvals are one shared store). The user answers once there; the parent's model never sees the approval, only one line per relayed approval in the tool's result, before the reply: `approval relayed to your user: execute: git push origin main → allowed once` (or `denied ("why")`, `dismissed (denied)`, `answered on the child`, `not delivered (the child's worker is gone)`, `refused by the child …`, `still open (your turn was stopped)`). The time the card is open doesn't count against `timeout`. While the parent waits on one child, its other running children's approvals are relayed too, oldest first, one card at a time (`+1 more delegate waiting`); each outcome comes in that child's next result.
+- **A child at its cost cap** (the [cost-cap bundle](plugins.md#the-cost-cap-bundle), the child's own cap: `child:` in its settings, or `/cap`) asks a `hook` question, "Cost cap", `Continue` or `Stop`. Like every hook's question on a `delegate` child, it goes where it can be decided, under the child's `guardrails.parent_answers` (config.yml's, or the child's own when stricter): when the parent may pick an option other than a deny (Stop) there, `standard` and `soft` here, it comes back to the parent's model as `status: question` with the `chi answer` commands; when it may not, `hard` here (a parent's Continue is refused), it goes to the parent's user as a card, as approvals do (the relay below), and the model sees one line: `hook question relayed to your user: Cost cap → Stop` (or `dismissed`, which the hook reads as it likes, cost-cap as Stop; `refused by the child …`, `answered on the child`, `still open (your turn was stopped)`). Free text alone doesn't count as an option the parent may pick. A **background** child (`wait: false`) paused at its cap rings its parent as a question does (delegate reports, below): the parent's model gets it as a report when it may answer; otherwise the parent's worker relays it to its user at its next step boundary, or in a wake turn's first boundary when idle (before the model is called), and the report the model gets is the outcome line. While that card is open the parent's turn waits on it; a Stop closes it and leaves the question for your next input (or a `delegate_result`): no wake turn offers that question again meanwhile, while other children's reports and attached-context wakes go on. Under the default `soft` that means a background parent's model now hears its child's cost cap, and may Continue it.
+- **A child's approvals go to the parent's user** (the approval relay), and so do the hook questions its parent can't usefully answer (above: a card headed `delegate ab12 asks: Cost cap`, the child's options and kind, no approval facts). While the parent waits (`delegate`, `delegate_result`), a guardrail approval the child opens reopens as the parent session's own approval: the same card in the parent's web page and attached terminal, with the same facts and diff, a line naming the delegate and its task (`delegate ab12 · fix the flaky spec…`, linked to its session) and the header `Approve delegate ab12's tool call?`. The options are the child's, by index; "for the session" says it is the delegate's session (the session scope keys on the child; repo and rule approvals are one shared store). The user answers once there; the parent's model never sees the approval, only one line per relayed approval in the tool's result, before the reply: `approval relayed to your user: execute: git push origin main → allowed once` (or `denied ("why")`, `dismissed (denied)`, `answered on the child`, `not delivered (the child's worker is gone)`, `refused by the child …`, `still open (your turn was stopped)`). The time the card is open doesn't count against `timeout`. While the parent waits on one child, its other running children's approvals are relayed too, oldest first, one card at a time (`+1 more delegate waiting`); each outcome comes in that child's next result.
   - The child's own card stays answerable (the first answer wins: answered there, the parent's card closes as "answered in ab12"). While relayed it says `Waiting for approval in parent ab12: answering here works too`; `chi sessions list` shows the child as `waiting (in parent ab12)` (`--format json`: `relayed_to`), and the web's bell rings for the parent's card, not the child's.
   - How the child trusts it: the parent's POST that says "answered" (Bridge `POST /session/<child>/relay`) carries no answer. The child asks its parent session's live Bridge (`POST /session/<parent>/relay/status`), which reports only what the parent's question flow took from a UI (`RelayDesk`, in memory only), and takes it only for this child, the question pending now, answered. A parent agent's answer on the relay card (a piped or marked `chi --attach PARENT`, `chi answer`) is held to `guardrails.parent_answers` (each session's own, when stricter) by the parent and again by the child.
   - A Stop of the parent's turn closes its card; the child's approval stays open there. A child's worker that goes closes the card (`… worker is gone`); a parent's worker that goes clears the child's "waiting in parent" line within 2 s. A later `delegate_result` relays it again.
-  - No relay where the parent can't host one (a `--no-shared` REPL, `--non-interactive`) or isn't waiting (`wait: false` until the next `delegate_result`): the approval waits on the child, with the web's bell, and the result's question block says to deny it or leave it for the user. The model's own questions and hooks' questions come back to the model as before. A grandchild's (a plugin's `ctx.sessions.fork` can make one) is relayed hop by hop: `delegate ab12 → cd34 asks:`.
-- **Delegate reports: a child's reply comes back by itself.** When a child ends a turn that was its parent's (its task, a follow-up, a continue the parent answered, a reminder: not a turn its user typed into it directly), it rings the parent: a small file in the parent's `children/` dir, written after the child's turn is saved. So does a question the parent's model decides (the child's own `ask_user_question`, the step-limit continue; not an approval or a hook's question, which the user answers on the child's card), the turn after such a question whoever starts it, and the child's worker crashing. The parent reads the child as `delegate_result` would and hands its model a **report**: the same text (`session:`, `status:`, the reply), under its own header (`[Delegate report, delivered by chi …; not your user's message. Tell your user what it found …]`), as an input message with `source: "delegate_report"`.
+  - No relay where the parent can't host one (a `--no-shared` REPL, `--non-interactive`) or, for an approval, isn't waiting (`wait: false` until the next `delegate_result`; a hook's question it may only deny is relayed from a delegate report instead, above): the approval waits on the child, with the web's bell, and the result's question block says to deny it or leave it for the user. The model's own questions, and the hooks' questions the parent may answer, come back to the model as before. A hook's question already answered on one of the parent's relay cards (a refused answer: it waits for the user on the child) is not relayed again; one whose card closed (a Stop, the child gone) is, and an approval always is, as before. A grandchild's (a plugin's `ctx.sessions.fork` can make one) is relayed hop by hop: `delegate ab12 → cd34 asks:`.
+- **Delegate reports: a child's reply comes back by itself.** When a child ends a turn that was its parent's (its task, a follow-up, a continue the parent answered, a reminder: not a turn its user typed into it directly), it rings the parent: a small file in the parent's `children/` dir, written after the child's turn is saved. So does a question the parent decides (the child's own `ask_user_question`, the step-limit continue, a hook's question, relayed to the parent's user first when the parent may only deny it; not an approval, which the relay or the user on the child's card answers, nor a card the child relays from its own child), the turn after such a question whoever starts it, and the child's worker crashing. The parent reads the child as `delegate_result` would and hands its model a **report**: the same text (`session:`, `status:`, the reply), under its own header (`[Delegate report, delivered by chi …; not your user's message. Tell your user what it found …]`), as an input message with `source: "delegate_report"`.
   - Parent mid-turn: the report joins the turn at its next iteration boundary (a "delegate report" bubble in the web, `delegate report> ab12cd34 answered: …` in the attached terminal).
   - Parent idle: it runs a turn for the report (a *wake turn*, `last_turn.origin: "delegate_report"`) within the worker's 5 s tick, or wakes a worker for it when the parent's has idle-exited. Several reports that wait together are one turn and one message. A stopped, archived or scratch parent, or one open in a `--no-shared` REPL, is not woken: the rings wait on disk and join the next turn it runs (the user's message first). An archived parent that a later link continues wakes that link instead, which takes the rings its moved delegates left there (see *Session chains*). A worker just started (`chi send` to a stopped parent) runs no wake turn in its first 2 s, so the message it was started for goes first.
   - The parent's cursor per child (the newest reply it was given and the child as it was then) is in its `delegates.json`, shared with `delegate_result` and `wait: true`: a reply the model already had is never reported again, also after the parent's worker restarts. A ring is deleted only when the turn that took its report stays in the conversation (completed, canceled, or failed but kept: one that got to tool steps, or a reminder or continue turn, which keep what they read); a turn rolled back (a failed one that got nowhere, a canceled continue turn) leaves it for the next one (and the report isn't handed back to the composer). So the model reads each report once, unless a later `!rollback` erases a kept turn (what it read goes with it).

data/docs/sub-agent.md

@@ -13,6 +13,15 @@ worker keeps the turn paused. The parent answers with `chi answer`, from what it
 knows or after asking its own user, and chi goes on from there. The model gets
 the answer as its tool result, as if you had answered in the web.
 
+A chi parent's own `delegate` children work the same way, with one shortcut:
+their approvals, and the hook questions the parent may only deny under the
+child's `guardrails.parent_answers`, go to the parent's user as a card in the
+parent's UIs instead (the relay, [Sessions](sessions.md#delegating)). When an
+agent runs that parent with `chi send --wait`, the relay card is the parent's
+own question: exit 3 with its text (`delegate ab12 … asks:`), options and
+`answer_with`; the JSON has no `relay` key. Its `chi answer` is held to the
+parent's setting, then to the child's.
+
 The other direction, chi sending a part of its work to a Claude Code session
 you already work with (to validate, as context, or with a question), is the
 [claude-peer bundle](plugins.md#the-claude-peer-bundle): Claude pairs with the

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

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

data/lib/samagotchi/child_reports.rb

@@ -130,7 +130,13 @@ module Samagotchi
     # (DelegateWait.finish, its report variant), the cursor it moves the child to,
     # and the cursor it was read from (a commit after the model moved it
     # itself, with delegate_result, leaves it alone).
-    Report = Data.define(:child_id, :text, :before, :after, :rings, :claim_id) do
+    # +relay+: the child's question when it goes to the parent's user
+    # (Tools::DelegateRelay.relay?): #resolve relays it on the turn thread
+    # and gives the report its outcome line; +text+ is the question's
+    # report until then (what a parent with no relay gets).
+    Report = Data.define(:child_id, :text, :before, :after, :rings, :claim_id, :relay) do
+      def initialize(relay: nil, **) = super
+
       def line(mark: nil) = Steer::Line.new(text: text, source: ChildReports::SOURCE, mark: mark)
       def origin = { client_id: "#{ClientId::CHILD_PREFIX}#{child_id[0, 8]}" }
     end
@@ -146,14 +152,19 @@ module Samagotchi
       Tools::DelegateCursors.clear_report_claims(@session_id, state_dir: @state_dir)
       # child id → the Report this turn took for it (rings merged).
       @taken = {}
+      # child id → the question id whose relay card a Stop closed (#hold_back).
+      @held = {}
     end
 
+    # The user's next input: questions held back after a Stop are offered again.
+    def release_holds = @held.clear
+
     # Whether a ring this turn hasn't taken waits (the idle loop's check).
     def waiting?
       return false if ChildRing.mode == "off"
 
       taken = taken_rings
-      ring_files.any? { |file| !taken.include?(file) }
+      ring_files.any? { |file| !taken.include?(file) && !held?(file) }
     end
 
     # The reports for rings this turn hasn't taken yet, recorded as taken.
@@ -164,7 +175,7 @@ module Samagotchi
       return [] if ChildRing.mode == "off"
 
       taken = taken_rings
-      fresh = ring_files.reject { |file| taken.include?(file) }
+      fresh = ring_files.reject { |file| taken.include?(file) || held?(file) }
       by_child = fresh.group_by { |file| SessionInbox.read_ring(file)&.dig(:child_id) }
       by_child.filter_map do |child_id, rings|
         report = child_id && report_for(child_id, rings)
@@ -207,8 +218,79 @@ module Samagotchi
       @taken = {}
     end
 
+    # A report whose question goes to the parent's user, settled: relayed
+    # through +relay+ (DelegateRelay.call: blocks until the card is
+    # answered, closed or the turn stopped) and given the outcome line as
+    # its text. Runs on the turn thread, before the boundary merges it.
+    # The child's question answered since the ring was taken opens no card;
+    # nor does one already answered on a relay (RelayDesk#settled?).
+    # @param relay [#open_question, #relay_desk, nil] Engine#relay_peer;
+    #   nil: the report's question text, as without P4's relay
+    # @return [Report, nil] nil when the parent's turn was stopped with the
+    #   card open: the report is released (its ring and the cursor stay), so
+    #   the next turn offers it again
+    def resolve(report, relay:)
+      return report unless report.relay
+      return report.with(relay: nil) unless relay
+
+      question = report.relay
+      what = question.header.to_s.empty? ? question.hook.to_s : question.header.to_s
+      line = if Session.load(report.child_id, state_dir: @state_dir).pending_question&.id.to_s != question.id.to_s
+               Tools::DelegateRelay.line(what, "answered on the child", hook: true)
+             elsif relay.relay_desk.settled?(report.child_id, question.id)
+               Tools::DelegateRelay.line(what, "answered on a relay already; it waits for the user on the child", hook: true)
+             else
+               outcome = Tools::DelegateRelay.call(report.child_id, question, relay: relay, state_dir: @state_dir)
+               return hold_back(report) if outcome.stopped
+
+               outcome.line
+             end
+      resolved = report.with(relay: nil, text: relayed_text(report.child_id, line))
+      @taken[report.child_id] = resolved if @taken[report.child_id]&.claim_id == report.claim_id
+      resolved
+    rescue ArgumentError => e
+      # The child is gone (or a bug): its question's report, as without a relay.
+      Log.info(:worker, "delegate_relay_unresolved", child: report.child_id[0, 8], error: e.message)
+      report.with(relay: nil)
+    end
+
+    # A relay report the parent's turn stopped on, or one behind it in the
+    # same take: released (its ring and the cursor stay) and held back, so
+    # no wake turn offers that question again until the user's next input
+    # (#release_holds); other children's rings go on.
+    # @return [nil]
+    def hold_back(report)
+      @held[report.child_id] = report.relay.id.to_s
+      release_report(report)
+    end
+
     private
 
+    # A ring of a child whose held-back question still waits.
+    def held?(file)
+      child_id = SessionInbox.read_ring(file)&.dig(:child_id)
+      question_id = @held[child_id] or return false
+      Session.load(child_id, state_dir: @state_dir).pending_question&.id.to_s == question_id
+    rescue ArgumentError
+      false
+    end
+
+    # A relayed question's report: the outcome line, then the next reply's
+    # promise (as a report's question text ends).
+    def relayed_text(child_id, line)
+      Tools::DelegateWait.result(child_id, "question", "#{line}\n#{Tools::DelegateWait::REPORT_NEXT_REPLY}")
+    end
+
+    # One taken report back: its cursor claim goes, its rings stay untaken.
+    # @return [nil]
+    def release_report(report)
+      @taken.delete(report.child_id)
+      Tools::DelegateCursors.update(@session_id, report.child_id, state_dir: @state_dir) do |cursor|
+        cursor.report_claim&.fetch("id", nil) == report.claim_id ? cursor.with(report_claim: nil) : cursor
+      end
+      nil
+    end
+
     def taken_rings
       @taken.values.flat_map(&:rings)
     end
@@ -260,22 +342,33 @@ module Samagotchi
       # a later wait on it would repeat its reply.
       after = after.with(report_claim: claim)
       text = Tools::DelegateWait.finish(wait, child_id, timeout: 0, report: true)
-      Report.new(child_id: child_id, text: text, before: before, after: after, rings: rings, claim_id: claim_id)
+      Report.new(child_id: child_id, text: text, before: before, after: after, rings: rings, claim_id: claim_id,
+                 relay: relay?(wait) ? wait.question : nil)
     rescue ArgumentError
       nil # the child is gone
     end
 
     # A reply, a turn that left none, a crash, or a question the parent's
-    # model decides (its own ask_user_question, the step-limit continue).
-    # Approvals and hooks' questions are the user's, on the child's card.
+    # model decides (its own ask_user_question, the step-limit continue, a
+    # hook's question). Approvals are the user's (the relay, while the
+    # parent waits; else on the child's card).
     def reportable?(wait)
       case wait.status
       when :done, :no_reply, :error then true
-      when :waiting_for_answer then [nil, "", "continue"].include?(wait.question&.kind&.to_s)
+      when :waiting_for_answer then REPORTED_KINDS.include?(wait.question&.kind&.to_s)
       else false
       end
     end
 
+    REPORTED_KINDS = [nil, "", "continue", Tools::DelegateRelay::HOOK_KIND].freeze
+
+    # Whether the child's question goes to this parent's user rather than
+    # its model (Tools::DelegateRelay.relay?, under the child's strategy).
+    def relay?(wait)
+      wait.status == :waiting_for_answer && wait.question.kind.to_s == Tools::DelegateRelay::HOOK_KIND &&
+        Tools::DelegateRelay.relay?(wait.question, strategy: Guardrails::ParentPolicy.for_session(wait.session))
+    end
+
     def delete_rings(rings)
       rings.each { |file| FileUtils.rm_f(file) }
     end

data/lib/samagotchi/guardrails/parent_policy.rb

@@ -105,6 +105,13 @@ module Samagotchi
         STRATEGIES.key?(word) ? word : HARD
       end
 
+      # Whether a session's own value is set but not a level (a hand-edited
+      # file: read as hard); the worker says so once when it loads.
+      def unknown_level?(value)
+        word = value.to_s.strip.downcase
+        !word.empty? && word != UNSET && !STRATEGIES.key?(word)
+      end
+
       # What a parent may answer on a session whose own value is
       # +session_value+: config.yml's (+config+) unless the session's is
       # stricter. Config's own object when it binds, so its label stays.
@@ -243,6 +250,19 @@ module Samagotchi
         end
       end
 
+      # Whether a parent may usefully answer +pending+ under +strategy+:
+      # some option it may pick is not a deny (free text alone is a deny
+      # with a reason). A delegate's question it may is reported to the
+      # parent's model; one it may not goes to the parent's user
+      # (Tools::DelegateRelay.relay?). Who may answer what stays #refusal's.
+      def parent_decides?(pending, strategy:)
+        deny = deny_labels(pending)
+        allowed_options(pending, strategy: strategy).any? { |label| !deny.include?(label) }
+      end
+
+      # The deny-tagged options' labels.
+      def deny_labels(pending) = Array(pending.options).zip(effects_of(pending)).filter_map { |label, tag| label.to_s if tag == DENY }
+
       # The question's deny-tagged option's label, or nil.
       def deny_label(pending)
         index = effects_of(pending).index(DENY)

data/lib/samagotchi/relay.rb

@@ -16,6 +16,8 @@ module Samagotchi
     # How much of the child's task the card keeps, and the question line.
     TASK_CHARS = 200
     TASK_LINE_CHARS = 80
+    # A hook's question (QuestionDesk#ask_for_hook), relayed as such (P4).
+    HOOK_KIND = "hook"
 
     module_function
 
@@ -33,6 +35,14 @@ module Samagotchi
       asked = inner ? inner[:asked].to_s : pending.question.to_s
       task = inner ? inner[:task].to_s : task_of(child)
       who = chain.reverse.join(" → ")
+      relay = { id: relay_id, child_id: child.id, child_short: short, child_question_id: pending.id.to_s,
+                task: task, chain: chain, asked: asked, more: more.to_i }
+      if pending.kind.to_s == HOOK_KIND
+        # The asking hook's own header, kept down a chain (a relay of a relay).
+        relay[:header] = inner ? inner[:header].to_s : pending.header.to_s
+        return hook_card(pending, who, more, relay)
+      end
+
       {
         question: question_text(who, task, asked),
         options: relabel(Array(pending.options), facts[:scopes], who),
@@ -43,11 +53,33 @@ module Samagotchi
         **{ effects: pending.effects, user_only: pending.user_only }.compact,
         kind: Guardrails::Approval::KIND,
         approval: facts,
-        relay: { id: relay_id, child_id: child.id, child_short: short, child_question_id: pending.id.to_s,
-                 task: task, chain: chain, asked: asked, more: more.to_i }
+        relay: relay
       }
     end
 
+    # A hook's question (P4: one its parent can't usefully answer): its
+    # kind, hook, options and effects as the child asked them, and no
+    # approval facts (ParentApprovals.approval? stays false on it, so the
+    # policy judges it by its own tags, as on the child).
+    def hook_card(pending, who, more, relay)
+      {
+        question: question_text(who, relay[:task], relay[:asked]),
+        options: Array(pending.options).map(&:to_s),
+        header: hook_header(who, relay[:header], more),
+        multi_select: !!pending.multi_select,
+        allow_freeform: !!pending.allow_freeform,
+        **{ effects: pending.effects, user_only: pending.user_only, hook: pending.hook }.compact,
+        kind: HOOK_KIND,
+        relay: relay
+      }
+    end
+
+    # delegate ab12 asks: Cost cap (+1 more delegate waiting)
+    def hook_header(who, header, more)
+      text = "delegate #{who} asks: #{header.to_s.strip.empty? ? "a question" : header}"
+      more.to_i.positive? ? "#{text} (+#{more} more delegate#{"s" if more.to_i > 1} waiting)" : text
+    end
+
     # delegate ab12 ("fix the flaky spec in …") asks:
     #   execute: git push origin main
     #     in /path/repo (repo samagotchi, branch main)

data/lib/samagotchi/relay_desk.rb

@@ -63,6 +63,19 @@ module Samagotchi
       end
     end
 
+    # Whether the parent's user (or a parent agent) answered or dismissed a
+    # relay of this child's question: it isn't relayed again (a refused
+    # answer leaves it on the child's card). A closed one (a Stop, the
+    # child gone) is not settled. Forgotten after KEEP_SECONDS or a restart.
+    def settled?(child_id, child_question_id)
+      @mutex.synchronize do
+        prune
+        @relays.each_value.any? do |relay|
+          relay[:state] == "answered" && relay[:child_id] == child_id.to_s && relay[:child_question_id] == child_question_id.to_s
+        end
+      end
+    end
+
     # Whether a relay is open, or settled recently enough that its child
     # may still ask about it: a restart would drop them.
     def active?

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -195,7 +195,7 @@ module Samagotchi
 
         verb = flags.size == 1 ? "applies" : "apply"
         names = flags.size > 2 ? "#{flags[0..-2].join(", ")} and #{flags.last}" : flags.join(" and ")
-        err.puts "(#{names} #{verb} to a new session; #{session_id}'s prompt is already built)"
+        err.puts "(#{names} #{verb} to a new session; #{session_id} keeps its own)"
       end
 
       # @return [BridgeClient, nil] the running worker's, or nil when none runs

data/lib/samagotchi/terminal_ui/question_prompt.rb

@@ -96,7 +96,8 @@ module Samagotchi
         case reason.to_s
         when "answered_on_child" then "(answered in #{@delegate})"
         when "child_gone" then "(#{@delegate}'s worker is gone)"
-        when "dismissed" then "(denied)"
+        # A relayed hook question's dismissal: the hook decides what it means.
+        when "dismissed" then approval? ? "(denied)" : "(dismissed)"
         else "(left open in #{@delegate})"
         end
       end

data/lib/samagotchi/terminal_ui.rb

@@ -737,7 +737,7 @@ module Samagotchi
       return if @toolkit_flags.empty?
 
       names = @toolkit_flags.size > 1 ? "#{@toolkit_flags[0..-2].join(", ")} and #{@toolkit_flags.last}" : @toolkit_flags.first
-      warn "(#{names} #{@toolkit_flags.size == 1 ? "applies" : "apply"} to a new session; #{session.id}'s prompt is already built)"
+      warn "(#{names} #{@toolkit_flags.size == 1 ? "applies" : "apply"} to a new session; #{session.id} keeps its own)"
     end
     private :warn_toolkit_flags_ignored
 

data/lib/samagotchi/tools/delegate_relay.rb

@@ -4,6 +4,7 @@ require_relative "../session"
 require_relative "../bridge_client"
 require_relative "../relay"
 require_relative "../guardrails/approval"
+require_relative "../guardrails/parent_policy"
 require_relative "../log"
 require_relative "../question_answer"
 
@@ -35,10 +36,39 @@ module Samagotchi
 
       module_function
 
+      # Kinds a relay may carry.
+      HOOK_KIND = "hook"
+
       # @param relay [#open_question, #relay_desk] Peers#relay
+      # @param strategy [Guardrails::ParentPolicy::Strategy] the child's
+      #   (ParentPolicy.for_session(child))
       # @return [Boolean] a relay can take this question
-      def relayable?(relay, question)
-        !relay.nil? && question.is_a?(PendingQuestion) && question.kind.to_s == Guardrails::Approval::KIND
+      # @param child_id [String, nil] the asking child: a hook's question
+      #   already answered on one of this parent's relays
+      #   (RelayDesk#settled?) isn't relayed again; an approval is (as before
+      #   P4: a refused or undelivered answer is offered again)
+      def relayable?(relay, question, strategy:, child_id: nil)
+        return false if relay.nil? || !relay?(question, strategy: strategy)
+        return true unless child_id && question.kind.to_s == HOOK_KIND
+
+        !relay.relay_desk.settled?(child_id, question.id)
+      end
+
+      # Whether a delegate's question goes to the parent's user rather than
+      # its model: every approval, and a hook's question the parent can't
+      # usefully answer under the child's strategy
+      # (Guardrails::ParentPolicy.parent_decides?). The one place that says
+      # which kinds the relay carries: the wait (DelegateWait.call), the
+      # look at the other children (Others#waiting) and the delegate
+      # reports (ChildReports) all ask it.
+      def relay?(question, strategy:)
+        return false unless question.is_a?(PendingQuestion)
+
+        case question.kind.to_s
+        when Guardrails::Approval::KIND then true
+        when HOOK_KIND then !Guardrails::ParentPolicy.parent_decides?(question, strategy: strategy)
+        else false
+        end
       end
 
       # Relay the child's pending approval and wait until it settles.
@@ -79,10 +109,11 @@ module Samagotchi
 
       # Record the parent's answer, tell the child, and say what came of it.
       def settle(answer, fields, client:, desk:, relay_id:, qid:)
-        what = what_text(fields[:approval])
+        what = fields[:kind] == HOOK_KIND ? hook_what(fields) : what_text(fields[:approval])
+        hook = fields[:kind] == HOOK_KIND
         if answer.is_a?(Hash) && answer[:error] == "cancelled"
           desk.close(relay_id)
-          return closed(answer[:reason].to_s, what, client: client, relay_id: relay_id, qid: qid)
+          return closed(answer[:reason].to_s, what, client: client, relay_id: relay_id, qid: qid, hook: hook)
         end
 
         dismissed = !answer.is_a?(QuestionAnswer)
@@ -90,17 +121,18 @@ module Samagotchi
         desk.record(relay_id, selected_indices: dismissed ? [] : answer.selected_indices,
                               freeform: dismissed ? nil : answer.freeform, dismissed: dismissed, by: by)
         response = post(client, "answered", relay_id, qid)
-        Outcome.new(line: line(what, delivered(response, answer, fields, dismissed)), stopped: false)
+        Outcome.new(line: line(what, delivered(response, answer, fields, dismissed), hook: hook), stopped: false)
       end
 
-      def closed(reason, what, client:, relay_id:, qid:)
+      def closed(reason, what, client:, relay_id:, qid:, hook: false)
         case reason
-        when "answered_on_child" then Outcome.new(line: line(what, "answered on the child"), stopped: false)
-        when "child_gone" then Outcome.new(line: line(what, "not delivered (the child's worker is gone)"), stopped: false)
+        when "answered_on_child" then Outcome.new(line: line(what, "answered on the child", hook: hook), stopped: false)
+        when "child_gone"
+          Outcome.new(line: line(what, "not delivered (the child's worker is gone)", hook: hook), stopped: false)
         else
           # A Stop: the child's question stays open there.
           post(client, "closed", relay_id, qid, reason: "stopped")
-          Outcome.new(line: line(what, "still open (your turn was stopped)"), stopped: true)
+          Outcome.new(line: line(what, "still open (your turn was stopped)", hook: hook), stopped: true)
         end
       end
 
@@ -108,10 +140,16 @@ module Samagotchi
       def delivered(response, answer, fields, dismissed)
         return "not delivered (the child's worker is gone)" unless response
 
+        hook = fields[:kind] == HOOK_KIND
         case response.status
-        when 200 then dismissed ? "dismissed (denied)" : verdict(answer, fields)
+        when 200
+          # A dismissed hook question: the hook decides what no answer means.
+          return dismissed ? "dismissed" : answer.selected.join(", ") if hook
+
+          dismissed ? "dismissed (denied)" : verdict(answer, fields)
         when 409 then "answered on the child"
-        when 403 then "refused by the child (a parent agent may not allow it); it waits for the user there"
+        when 403
+          "refused by the child (a parent agent may not #{hook ? "pick it" : "allow it"}); it waits for the user there"
         else "not delivered (#{response.json&.fetch("error", nil) || response.status})"
         end
       end
@@ -134,7 +172,15 @@ module Samagotchi
         why.empty? ? "denied" : "denied (#{why.inspect})"
       end
 
-      def line(what, outcome) = "approval relayed to your user: #{what} → #{outcome}"
+      def line(what, outcome, hook: false)
+        "#{hook ? "hook question" : "approval"} relayed to your user: #{what} → #{outcome}"
+      end
+
+      # A hook card's header as the child asked it (Cost cap), or its hook.
+      def hook_what(fields)
+        header = fields.dig(:relay, :header).to_s
+        header.empty? ? fields[:hook].to_s : header
+      end
 
       # execute: git push origin main
       def what_text(facts)
@@ -151,6 +197,9 @@ module Samagotchi
       # (DelegateWait.relayed_outcomes). Every question is relayed once per
       # wait.
       class Others
+        # The kinds of question a relay may carry (DelegateRelay.relay? decides).
+        KINDS = [Guardrails::Approval::KIND, HOOK_KIND].freeze
+
         # @param parent_id [String]
         # @param except [String] the child waited on (its own approvals come
         #   through ReplyWait)
@@ -191,11 +240,16 @@ module Samagotchi
         #   oldest question first
         def waiting
           rows = SessionManager.children_of(@parent_id, state_dir: @state_dir).select do |row|
-            row[:id] != @except && row[:waiting] == Guardrails::Approval::KIND && !@done[row[:waiting_id].to_s]
+            row[:id] != @except && KINDS.include?(row[:waiting].to_s) && !@done[row[:waiting_id].to_s]
           end
           rows.filter_map do |row|
-            pending = Session.load(row[:id], state_dir: @state_dir).pending_question
-            [row[:id], pending] if pending && pending.id.to_s == row[:waiting_id].to_s
+            child = Session.load(row[:id], state_dir: @state_dir)
+            pending = child.pending_question
+            next nil unless pending && pending.id.to_s == row[:waiting_id].to_s
+            next nil unless DelegateRelay.relayable?(@relay, pending, strategy: Guardrails::ParentPolicy.for_session(child),
+                                                                      child_id: row[:id])
+
+            [row[:id], pending]
           rescue ArgumentError
             nil
           end.sort_by { |_, pending| pending.created_at.to_s }

data/lib/samagotchi/tools/delegate_wait.rb

@@ -82,7 +82,9 @@ module Samagotchi
                                           owner_grace: owner_grace, interject: others && -> { others.poll },
                                           turn: cursor.turn)
           left -= monotonic - started
-          unless wait.status == :waiting_for_answer && DelegateRelay.relayable?(relay, wait.question)
+          unless wait.status == :waiting_for_answer &&
+                 DelegateRelay.relayable?(relay, wait.question, strategy: Guardrails::ParentPolicy.for_session(wait.session),
+                                                                child_id: child_id)
             outcomes.concat(relayed_outcomes.delete(key) || [])
             movement = advance(peers.session_id, child_id, wait, state_dir: sd)
             if movement&.already_reported

data/lib/samagotchi/version.rb

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

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

@@ -44,8 +44,10 @@ export function waitingOn(summary) {
 // waiting on directly is seen by its look at the others (DelegateRelay
 // OTHERS_EVERY, 2 s), and the relay reaches the page with the hub's next
 // scan (SessionHub SCAN_INTERVAL, 1 s): up to ~3 s. Only these approvals
-// wait; a child's approval nobody relays rings this late.
+// wait (and a child's hook question, which may be relayed too); one nobody
+// relays rings this late.
 export const RELAY_HOLD_MS = 3500;
+const RELAYED_KINDS = new Set(["approval", "hook"]);
 
 // What changed between two summaries of one session that needs the user.
 // @param prev the summary held before (null for a session not seen yet)
@@ -60,7 +62,9 @@ export function attentionFor(prev, next) {
     // Relayed to the parent already: the parent's card notifies.
     if (q.relayed_to) return null;
     const attention = { reason: questionReason(q), sessionId: next.id, key: `${next.id}:${q.id}` };
-    return next.parent_id && q.kind === "approval" ? { ...attention, holdMs: RELAY_HOLD_MS } : attention;
+    // A hook's question may be relayed too (when the parent may only deny it);
+    // one the parent's model answers rings as late, which does no harm.
+    return next.parent_id && RELAYED_KINDS.has(q.kind) ? { ...attention, holdMs: RELAY_HOLD_MS } : attention;
   }
   const card = next.pending_card;
   if (card && card.id && card.id !== prev?.pending_card?.id) {

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

@@ -119,6 +119,8 @@ export function resultText(pq, { answer = null, cancelled = false, reason = "" }
   const relay = relayView(pq);
   if (cancelled && Object.hasOwn(CLOSED_PLAIN, reason)) return CLOSED_PLAIN[reason];
   if (cancelled && relay && reason !== "dismissed") return relayClosedText(relay, reason);
+  // A relayed hook question's dismissal: the hook decides what it means.
+  if (cancelled && relay && !approval) return "Dismissed";
   if (isContinue(pq)) return continueResultText({ answer, cancelled, reason });
   if (cancelled) {
     const label = approval ? "Denied" : "Cancelled";

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

@@ -17,7 +17,7 @@ import { diffTemplate } from "./diff_view.js";
 import { render } from "./vendor/lit-html.js";
 import {
   answerErrorText, approvalAllowed, approvalView, CONTINUE_REASON_PLACEHOLDER, deniedReason, isContinue, keepsAskingText,
-  nextCardAction, relayedToView, resultText, summaryText,
+  nextCardAction, relayedToView, relayView, resultText, summaryText,
 } from "./question_card.js";
 import { sessionHash } from "./route.js";
 import { clientLabel, isOwn } from "./turn_events.js";
@@ -92,9 +92,12 @@ export function createQuestionCards({
     if (approval) {
       card.appendChild(renderApprovalDetails(approval));
     } else {
+      // A delegate's hook question relayed here: who asks, then its own text.
+      const relay = relayView(pq);
+      if (relay) card.appendChild(renderDelegateLine(relay));
       const q = doc.createElement("div");
       q.className = "question-text";
-      q.textContent = pq.question || "";
+      q.textContent = (relay && pq.relay.asked) || pq.question || "";
       card.appendChild(q);
     }
 
@@ -273,28 +276,32 @@ export function createQuestionCards({
     card.appendChild(err);
   }
 
+  // "delegate ab12 · its task", the name linked to its session (a relayed
+  // approval's or hook question's; relayView).
+  function renderDelegateLine(delegate) {
+    const who = doc.createElement("div");
+    who.className = "approval-delegate";
+    const label = doc.createElement("span");
+    label.className = "approval-label";
+    label.textContent = "delegate ";
+    who.appendChild(label);
+    const name = doc.createElement("a");
+    name.className = "approval-delegate-link";
+    name.href = sessionHash(delegate.childId);
+    name.title = "Open the delegate's session";
+    name.textContent = delegate.who;
+    who.appendChild(name);
+    if (delegate.task) who.appendChild(doc.createTextNode(` · ${delegate.task}`));
+    return who;
+  }
+
   // The tool, the command (or paths, or args) as code, where and why; no
   // code box when there is nothing to show.
   function renderApprovalDetails(view) {
     const box = doc.createElement("div");
     box.className = "approval-details";
     // A delegate's approval: who asks, and its task.
-    if (view.delegate) {
-      const who = doc.createElement("div");
-      who.className = "approval-delegate";
-      const label = doc.createElement("span");
-      label.className = "approval-label";
-      label.textContent = "delegate ";
-      who.appendChild(label);
-      const name = doc.createElement("a");
-      name.className = "approval-delegate-link";
-      name.href = sessionHash(view.delegate.childId);
-      name.title = "Open the delegate's session";
-      name.textContent = view.delegate.who;
-      who.appendChild(name);
-      if (view.delegate.task) who.appendChild(doc.createTextNode(` · ${view.delegate.task}`));
-      box.appendChild(who);
-    }
+    if (view.delegate) box.appendChild(renderDelegateLine(view.delegate));
     const tool = doc.createElement("div");
     tool.className = "approval-tool";
     tool.textContent = view.tool;

data/lib/samagotchi/worker.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require_relative "client_id"
 require_relative "config"
 require_relative "engine"
+require_relative "guardrails/parent_policy"
 require_relative "events"
 require_relative "session"
 require_relative "session_inbox"
@@ -308,6 +309,7 @@ module Samagotchi
       # 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,
@@ -468,6 +470,16 @@ module Samagotchi
       save_or_log(:interrupted_turn) { save_session }
     end
 
+    # A saved parent_answers that isn't a level reads as hard on every
+    # answer without a word; said once here, as the session loads.
+    def announce_session_warnings
+      value = @session.parent_answers
+      return unless Guardrails::ParentPolicy.unknown_level?(value)
+
+      @engine.announce({ type: :guardrail_warning, label: "parent_answers",
+                         message: "parent_answers #{value.inspect} in session #{@session_id} isn't hard/standard/soft; hard applies" })
+    end
+
     # A question saved by a worker that died while it waited (an
     # ask_user_question, an approval, a hook's question): the turn that
     # asked is gone, so nobody can answer it, and left in the file it
@@ -600,7 +612,9 @@ module Samagotchi
       budget_notice if state == :budget
       return false unless state == :due
 
-      reports, = take_child_reports
+      # Unresolved: a relay among them opens its card at the turn's first
+      # boundary, on the turn thread (a Stop closes it).
+      reports, = take_child_reports(resolve: false)
       # The turn must not generate with nothing to say: the drain gets this
       # exact list at its first boundary.
       return false if reports.empty?
@@ -1011,19 +1025,26 @@ module Samagotchi
     end
 
     # The Engine published a question (after the question desk saved it).
-    # In a turn that reports to the parent, the model's own question and
-    # the step-limit continue ring it; approvals and hooks' questions are
-    # the user's, on this session's card.
+    # In a turn that reports to the parent, the model's own question, the
+    # step-limit continue and a hook's question ring it (the parent reports
+    # or relays a hook's: ChildReports). Approvals don't: the relay takes
+    # them while the parent waits. Nor does a card relayed from this
+    # session's own child (relay set): the hop is the parent's wait.
     def ring_question(event)
       return unless @reporting_turn
 
-      kind = event.dig(:pending_question, :kind).to_s
-      return unless ["", ContinueOffer::KIND].include?(kind)
+      pending = event[:pending_question] || {}
+      kind = pending[:kind].to_s
+      return unless RINGING_KINDS.include?(kind)
+      return if pending[:relay]
 
       ChildRing.ring(@session, why: "question", state_dir: @state_dir)
       @asked_parent = true
     end
 
+    # The kinds of question that ring a delegate child's parent (#ring_question).
+    RINGING_KINDS = ["", ContinueOffer::KIND, "hook"].freeze
+
     # WorkerInbound.save_or_log: a failed save between turns is logged.
     def save_or_log(at, &) = WorkerInbound.save_or_log(at, &)
 
@@ -1113,17 +1134,37 @@ module Samagotchi
     # the turn as its own).
     # @return [Array(Array<ChildReports::Report>, Hash|nil)] the reports
     #   and the mark of their message
-    def take_child_reports
+    # A report whose question goes to the parent's user is relayed here
+    # (ChildReports#resolve), before the boundary announces or merges
+    # anything; one whose card a Stop closed is held back until a human's
+    # input (no wake turn re-offers it at once; other wakes go on).
+    # +resolve+ false: a wake turn's take before the turn starts.
+    def take_child_reports(resolve: true)
       if (reports = @wakes.take_handed)
-        return [reports, { turn_start: true, turn_id: @turn_id }.compact]
+        return [resolve_relays(reports), { turn_start: true, turn_id: @turn_id }.compact]
       end
 
-      [@child_reports.take, nil]
+      taken = @child_reports.take
+      [resolve ? resolve_relays(taken) : taken, nil]
     rescue StandardError => e
       Log.warn(:worker, "delegate_reports_failed", error: e.class.name, msg: e.message)
       [[], nil]
     end
 
+    def resolve_relays(reports)
+      return reports if reports.none?(&:relay)
+
+      relay = @engine.relay_peer
+      stopped = false
+      reports.filter_map do |report|
+        next report unless report.relay
+        # The turn stopped on an earlier card: no more cards in it.
+        next @child_reports.hold_back(report) if stopped
+
+        @child_reports.resolve(report, relay: relay).tap { |resolved| stopped = resolved.nil? }
+      end
+    end
+
     # Check again with the event log held, which the Bridge holds while it
     # queues a POST /turn, then close the Bridge's intake so no client can
     # queue one after the check, and stop the idle jobs (reminder callback,
@@ -1245,6 +1286,7 @@ module Samagotchi
 
       ArchiveStore.user_input(@session_id, state_dir: @state_dir)
       @wakes.human_input!(interactive: ClientId.interactive?(client_id))
+      @child_reports&.release_holds
     end
 
     def stopped_on_disk?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.87.0
+  version: 0.88.0
 platform: ruby
 authors:
 - Dmitry Dedov