samagotchi 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7af50a3a7e90170a9d6b4f3f5ab5914a0ab536ea121b498779109dabfb7c0b51
-  data.tar.gz: 4ddba29c753f1a6900956cc5abbbef70c3d912286e252c4c9adf08534a773368
+  metadata.gz: b18cad295a3d093e74497e8d271c571b12531797f0345bc7f929cc3e1d10d663
+  data.tar.gz: e72c996d2692f6a91a69f03943ca4e985ba777fea18ba4cb08728fe32a744c72
 SHA512:
-  metadata.gz: 497f4731e7a4ca9c1bd5073bea8e897506d37a5fcdfd15ea394f5837edfc85d76fbaade739ec4f6de998f7da5a982c3a8a9c1d4674b1e218a50ab14fe673291b
-  data.tar.gz: 0c6428021607e8540dcb21801510eca0295be3fba2de0e09eb4c2fd3c2c362326301065b52c5bc7745e006768522312d1934659da4cacc93254560402c767e76
+  metadata.gz: 8878011a9051c4d815dc24e0785fd91772155e770d39974841c2d85b0d0d5f9a57d23f6f862d49f449e8b9436171a99b91e2fad5105ce9863ba5ce3a76e9fe5d
+  data.tar.gz: 11086d6eb896ea62961f87d70ecd7e6eaaacab9fefc519ef11249b643fbdcb3becdc28054447b23be10fbf898c599bd7da746a2a259504e54e9e9656f8d92d86

data/CHANGELOG.md

@@ -8,6 +8,50 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.31.0] - 2026-10-06
+
+### Added
+
+- Delegate reports: a child started with `delegate` (`wait: false`) brings its reply to its parent by itself when
+  it ends its turn, fails or asks the parent something. A parent mid-turn gets it at the next step; an idle parent
+  runs a turn for it and tells its user, waking its worker when that had exited. The report carries the reply, so
+  the model doesn't poll with `delegate_result`. The web shows a "delegate report" bubble, the attached terminal
+  `delegate report> <child> answered: …`, and the bell rings when such a turn ends. A stopped or archived parent
+  isn't woken: its reports join its next turn. New settings `session.delegate_reports` (`wake`, `queue`, `off`) and
+  `session.max_wakes` (default 10 turns in a row with no human input; then reports wait for your next message).
+
+### Changed
+
+- The parent's record of which delegate replies its model already had is kept on disk (`delegates.json`), so a
+  restarted worker no longer hands the model a reply again; `delegate_result` asked again about a question it
+  already reported waits for its answer instead of repeating it.
+- A delegated child does only what its task asks: a question gets a report with the change it would make, not
+  file edits; it edits files only when the task asks for a change, and then only the files that takes.
+- `task_get`, `task_stop` and `task_wait` say they take a task id (from `task_create` or `task_list`, with an example),
+  not a session id: models passed session ids to them.
+
+### Fixed
+
+- A message sent while a reminder turn ran was lost when that reminder turn was the session worker's first turn
+  (a fresh or restarted worker): the turn took the message and dropped it. It now joins the turn as steering does.
+- `chi -p … --non-interactive` (and a fresh REPL session's first turn without a worker) could not use the `delegate`
+  tool: the session was not saved until its turn ended, so the child failed with "Session not found". A fresh
+  session is now saved before its first turn.
+- `task_get`, `task_stop` and `task_wait` given a session id say so: `task not found: <id> (that is a session id; task
+  ids come from task_create, and task_list lists them)`.
+- `task_get`, `task_stop` and `task_wait` take only an id shaped like task_create's (`20261005093000-1a2b3c4d`): an id
+  such as `../x` could read a `task.json` outside `tmp/tasks`. Anything else is `task not found`.
+- `task_wait` for an unknown task said `Error: Error: task not found: …`; it now says it once.
+- A corrupt Gemma 4 generation on a llama.cpp host (a tool call never closed, or a fresh thought header after the
+  answer text) was saved as the answer, and a delegate report passed it on to the parent. A poisoned llama.cpp prompt
+  cache produced one with another session's answer in it (ggml-org/llama.cpp#27148). chi now logs
+  `generation_malformed`, shows `↻ malformed answer, asking again (1/1)` and asks once more without the prompt cache;
+  a second corrupt generation fails the turn ("malformed generation from host …"). The half tool call never runs.
+- On llama.cpp, a parent's turn-end warm-up no longer waits behind a delegate child generating on the same slot, and
+  its next turn no longer waits behind that warm-up: the warm-up is skipped when `/slots` says the slot is busy.
+
+Update with `chi update` and restart `chi web`.
+
 ## [0.30.0] - 2026-10-05
 
 ### Added
@@ -1552,7 +1596,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.30.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.31.0...HEAD
+[0.31.0]: https://github.com/dm1try/samagotchi/compare/v0.30.0...v0.31.0
 [0.30.0]: https://github.com/dm1try/samagotchi/compare/v0.29.0...v0.30.0
 [0.29.0]: https://github.com/dm1try/samagotchi/compare/v0.28.0...v0.29.0
 [0.28.0]: https://github.com/dm1try/samagotchi/compare/v0.27.0...v0.28.0

data/docs/configuration.md

@@ -72,6 +72,8 @@ session:
   # idle_exit_minutes: 30   # an unused worker exits after this (0 = never)
   # keep_empty: false       # true keeps sessions nothing happened in (default: deleted when left)
   # max_children: 4         # running sessions one session may have delegated at a time (the delegate tool)
+  # delegate_reports: wake  # a child's reply reaches its parent by itself: wake (an idle parent runs a turn), queue, off
+  # max_wakes: 10           # turns in a row a parent runs for delegate reports with no human input
 
 # Baseline memories preloaded into the system prompt (same shape as --memory);
 # name entries you have, or chi warns at each start.
@@ -884,6 +886,8 @@ described in their own sections.
 | `session.idle_exit_minutes` | `30` | yes | An unused worker exits after this; `0` = never. |
 | `session.keep_empty` | `false` | | Keep sessions nothing happened in. |
 | `session.max_children` | `4` | | Running delegated sessions one session may have. |
+| `session.delegate_reports` | `wake` | | When a delegate child ends a turn, its reply reaches the parent: `wake` runs an idle parent's turn for it, `queue` waits for the parent's next turn, `off` leaves it to `delegate_result`. |
+| `session.max_wakes` | `10` | | Turns a parent runs for delegate reports in a row with no human input; past it reports wait for the next turn. |
 | `session.retention_days` | `14` | yes | Delete sessions not updated for N days; `0` = forever. See [Sessions](sessions.md). |
 | `session.max_count` | `500` | yes | Keep the newest N; `0` = uncapped. |
 | `session.keep_status` | none | yes | Comma list of statuses never pruned (a session a worker or `chi` has open is never pruned anyway). |

data/docs/internals/engine.md

@@ -294,7 +294,7 @@ Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):
 | `:generation_retrying` | the transport retries the request | `{iteration, ...}` (the retry's fields) |
 | `:generation_completed` | a generation ended, or was cut | `{iteration, content_length, thinking_chars, served_model, requested_model, finish_reason, ...}`; a cut adds `stopped_by`, `stop_reason`; the Engine adds `speed`, `tokens` |
 | `:generation_cancelled` | the turn was cancelled mid-loop | `{iteration, reason, stopped_by}` |
-| `:empty_answer_retry` | an empty or cut answer is asked again | `{iteration, attempt, of, finish_reason, thinking_chars, ...}` |
+| `:empty_answer_retry` | an empty, cut or malformed answer is asked again | `{iteration, attempt, of, finish_reason, thinking_chars, stopped_by?, malformed?}` |
 | `:steer_cut` | a steer cut the generation | `{iteration, source}` |
 | `:pending_input_merged` | queued input joined the conversation | `{iteration, count, content, steers?, answer}` |
 | `:tool_dispatch_started` / `:tool_dispatch_completed` | around a batch | `{iteration, call_count}` |

data/docs/sessions.md

@@ -181,7 +181,7 @@ chi send --wait 3fa2                                   # sends nothing: waits fo
 
 The `delegate` tool hands a task to a **child session**: an ordinary chi session in a worker of its own, started in the parent's `working_directory` with the task, verbatim, as its first user message, on the parent's model unless the call names one (`model:` takes a name or an alias, resolved as `--model` is; an unknown host comes back as the tool's `Error:` line; an id the host's saved model list doesn't have starts the child with a `Warning: host 'h' doesn't list model 'x' (did you mean: …?)` line in the result). Children run in parallel and only their **final reply** comes back to the parent: the child's newest `output/<timestamp>.txt` file, which the worker writes at the end of each turn that produced visible text, cut head-and-tail like an `execute` result. Nothing of the child's trace enters the parent's context. Nothing is hidden: a child shows in `chi sessions list` (`↳ <parent>`), the web (a `↳` chip on its card, `delegated by` in its info bar, listed right after its parent in the all-sessions view) and the `list_sessions` tool (`child`; the parent shows as `parent` in the child's own list); the user can `chi --attach <child id>` and steer it mid-run, and `chi send` and `send_note` reach it like any session.
 
-- `delegate(task, model:, session:, wait:, timeout:)`: starts a child and, by default, waits for its reply (`wait: false` returns at once, so several children can run side by side; `timeout`, default 600 s, leaves a slow child running; 0 checks once without waiting). With `session:` (a child's id or prefix) the task goes to that child as a follow-up instead, delivered like `chi send` (client id `delegate:<parent short id>`, shown as `delegate>` in the child's UIs); only this session's children take one.
+- `delegate(task, model:, session:, wait:, timeout:)`: starts a child and, by default, waits for its reply (`wait: false` returns at once, so several children can run side by side, and the reply comes back by itself as a *delegate report*, below; `timeout`, default 600 s, leaves a slow child running; 0 checks once without waiting). With `session:` (a child's id or prefix) the task goes to that child as a follow-up instead, delivered like `chi send` (client id `delegate:<parent short id>`, shown as `delegate>` in the child's UIs); only this session's children take one.
 - `delegate_result(session:, timeout:)`: waits for a child's next reply: the one named, or the newest running child (`timeout` as for `delegate`: 0 checks once and returns at once). The reply comes back once; a later call waits for the next one.
 - 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 `turn.parent_continue` (see [chi as a sub-agent](sub-agent.md#the-step-limit)).
@@ -190,6 +190,13 @@ The `delegate` tool hands a task to a **child session**: an ordinary chi session
   - 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_approvals` 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"`.
+  - 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). 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 is kept; a turn that fails leaves it for the next one (and the report isn't handed back to the composer).
+  - Limits: `session.max_wakes` (default `10`) wake turns in a row with no human input; past it the reports wait for the next message and the UIs show `N delegate reports waiting; they join your next message`. A wake turn that fails pauses wakes until the next human input. A continue offer waiting in the parent takes the reports into its continue turn instead.
+  - `session.delegate_reports`: `wake` (default), `queue` (no wake turns: reports join the parent's next turn) or `off` (no rings; only `delegate_result` asks, as before). Env `SAMAGOTCHI_SESSION_DELEGATE_REPORTS`, `SAMAGOTCHI_SESSION_MAX_WAKES`.
+  - The web's bell rings at a wake turn's end however short (nobody started it, so nobody watched it). The text a model writes about a report mid-turn, before its next tool call, stays visible after the report's bubble once the turn ends.
 - Every child starts with the shipped `delegated` system memory preloaded (`preloaded_memory_names: ["system/delegated"]`; `--mute delegated` would hide it): put everything in the final reply, don't delegate further, don't write memories or change config, stay in the folder. Its system prompt also says `Delegated by session <parent id>`. The parent's own `--mute` list does not carry over.
 - Limits: a child cannot `delegate` (depth 1; the tool refuses), and one session may have at most `session.max_children` (default `4`, env `SAMAGOTCHI_SESSION_MAX_CHILDREN`) children running at a time, counted from the session files (a finished or idle-exited child does not count; one whose worker is still starting does, for 15 s). A refused call creates no session. Nothing stops children with the parent: `chi sessions stop ID` does.
-- The link is the session's `parent_id`, written before the worker starts, so a respawn keeps it; `GET /api/sessions` and `/api/sessions/:id` carry it, and `SessionManager.children_of` lists a parent's children.
+- The link is the session's `parent_id`, written before the worker starts, so a respawn keeps it (and `delegate: true`, which a fork's `parent_id` doesn't come with; a child saved before that field is known by its `system/delegated` memory); `GET /api/sessions` and `/api/sessions/:id` carry it, and `SessionManager.children_of` lists a parent's children.

data/lib/samagotchi/bridge/card_store.rb

@@ -166,7 +166,7 @@ module Samagotchi
         # this worker runs, where it showed live.
         when :guardrail_warning then push({ type: :guardrail_warning, message: event[:message], label: event[:label] }
                                             .compact.merge(in_turn: false, turns: @turns_done))
-        when :empty_answer_retry then add_turn_row(event.slice(:type, :attempt, :of, :stopped_by)) if @running
+        when :empty_answer_retry then add_turn_row(event.slice(:type, :attempt, :of, :stopped_by, :malformed)) if @running
         when :steer_cut then add_turn_row(event.slice(:type, :source)) if @running
         when :question_requested
           add_turn_row({ type: :question, pending_question: Marshal.load(Marshal.dump(event[:pending_question])) }) if @running

data/lib/samagotchi/bridge/turn_notice.rb

@@ -11,7 +11,7 @@ module Samagotchi
     module TurnNotice
       FIELDS = {
         hook_notice: %i[hook text level],
-        empty_answer_retry: %i[iteration attempt of stopped_by],
+        empty_answer_retry: %i[iteration attempt of stopped_by malformed],
         steer_cut: %i[iteration source],
         question_requested: %i[pending_question],
         question_answered: %i[id answer],

data/lib/samagotchi/bundles/system/delegated.md

@@ -3,6 +3,7 @@
 Another chi session (the parent) gave you this task. It reads only your last message of each turn; the user may be watching, or not.
 
 - Finish the task in this turn if you can. End with one reply the parent can act on without asking back: the result first, then evidence (paths, commands run and what they printed), then anything you could not verify or finish.
+- Do only what the task asks. A question ("why does this spec fail?", "what calls X?", "check whether…") gets a report, not file changes: say what you found and what change you would make, and leave making it to the parent. Edit files only when the task asks you to change, fix, add or write something, and then only the files that takes.
 - The parent may send follow-up messages later; each one is a new turn in this same session, with what you did so far.
 - Work in the directory you were started in. Don't change config, install bundles, edit managed files or write memories unless the task asks for it.
 - You can't delegate further. Don't start other chi sessions, and send notes only to the parent.

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.30.0
+version: 0.31.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
-  self_map.md: sha256:69bc0ec091fdaeedf6e3aa7365275461fe3eba32b2dedc9cf45044176c356af5
+  self_map.md: sha256:d8f93e2a4ce555316216ad63f9644c488e02e3f3dd19f6e8537a1ea1404314ff
   config_modification_protocol.md: sha256:ec0b0c7023dbf03b93879e51cd5cdc38b22d43a2e5984ee11e8542ace077c3be
   memory_guide.md: sha256:17126f5adb9ef7b33c40e920ef339388c8c8c045b38a7de825b08760604db4e4
-  delegated.md: sha256:0a71d5dfa7127df2d51cb5f0e7214240ed88777e36559430a8724c796d7ae561
+  delegated.md: sha256:eaaf66830d3ab1346c75812a5fc8fcb9d3dbaa6a3f6bcf47c103155d96e415b5

data/lib/samagotchi/bundles/system/self_map.md

@@ -24,7 +24,8 @@
   `chi send --new --wait -m TEXT` starts a session the user can watch in the web and prints its
   answer (exit 3: it waits for the user's answer); see "Starting a session".
 - `delegate` hands a task to a child session that runs in parallel and returns only its final
-  reply (`delegate_result` waits for it; `session:` sends a follow-up to a child). A child is a
+  reply (`delegate_result` waits for it; with `wait: false` chi brings the reply to me by itself
+  as a delegate report when the child ends its turn; `session:` sends a follow-up to a child). A child is a
   normal session: it shows in `chi sessions list` with `↳ <parent>`, and the user can steer it
   with `chi --attach <id>`. While I wait for a child, its tool approvals go to my user as my own
   approvals (I see only how each was answered); see `docs/sessions.md` "Delegating".

data/lib/samagotchi/child_reports.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "session"
+require_relative "session_inbox"
+require_relative "reply_wait"
+require_relative "steer"
+require_relative "log"
+require_relative "config"
+require_relative "tools/delegate_wait"
+require_relative "tools/delegate_cursor"
+
+module Samagotchi
+  # Loaded on first use: session_manager requires terminal_ui, which
+  # requires KernelLoop and so the tools (a require cycle otherwise).
+  autoload :SessionManager, File.expand_path("session_manager", __dir__)
+
+  # A delegate child's news reaching its parent by itself (the delegate
+  # tool's wait: false). The child rings (ChildRing): a small file in the
+  # parent's children/ dir. The parent's worker reads the rings
+  # (ChildReports) and asks each child what happened, as delegate_result
+  # would, and hands the model a report: mid-turn at the next iteration
+  # boundary, or in a turn of its own when the parent was idle (Worker).
+  # The rings stay on disk until the turn that took them is kept, so a
+  # worker that exits, restarts or crashes meanwhile loses nothing.
+  module ChildRing
+    MODE_KEY = "session.delegate_reports"
+    MODES = %w[wake queue off].freeze
+    # Turns an idle parent runs for reports in a row with no human input.
+    MAX_WAKES_KEY = "session.max_wakes"
+    MAX_WAKES_DEFAULT = 10
+
+    module_function
+
+    # wake: an idle parent runs a turn for a report; queue: reports wait
+    # for its next turn; off: no rings at all.
+    def mode
+      value = Config.get(MODE_KEY).to_s
+      MODES.include?(value) ? value : "wake"
+    rescue StandardError
+      "wake"
+    end
+
+    # Ring +child+'s parent; best effort (a failure is logged, never
+    # raised). A parent with no worker is woken on a thread
+    # (SessionManager.wake_for_report decides whether it may be).
+    # @param child [Session] a delegate child
+    # @param why [String] "turn_end", "question" or "crash"
+    # @param wake [#call, nil] (parent id) wakes a parent with no worker;
+    #   nil: SessionManager.wake_for_report on a thread
+    # @return [String, nil] the ring file, nil when none was written
+    def ring(child, why:, state_dir:, wake: nil)
+      return nil if mode == "off"
+      return nil unless child&.delegate? && child.parent_id
+      # A deleted parent gets no orphan dir.
+      return nil unless Session.exist?(child.parent_id, state_dir: state_dir)
+
+      parent_dir = Session.session_dir(child.parent_id, state_dir: state_dir)
+      path = SessionInbox.write_ring(parent_dir, child_id: child.id, why: why)
+      Log.info(:worker, "delegate_rang", parent: child.parent_id[0, 8], why: why)
+      wake_parent(child.parent_id, state_dir: state_dir, wake: wake) if mode == "wake"
+      path
+    rescue StandardError => e
+      Log.warn(:worker, "delegate_ring_failed", parent: child&.parent_id.to_s[0, 8], error: e.class.name, msg: e.message)
+      nil
+    end
+
+    # A live parent worker sees the ring on its next pass; one with no
+    # worker is woken.
+    def wake_parent(parent_id, state_dir:, wake:)
+      return if SessionManager.session_owner(parent_id, state_dir: state_dir)
+
+      if wake
+        wake.call(parent_id)
+      else
+        Thread.new do
+          SessionManager.wake_for_report(parent_id, state_dir: state_dir)
+        rescue StandardError => e
+          Log.warn(:worker, "delegate_wake_failed", parent: parent_id[0, 8], error: e.class.name, msg: e.message)
+        end
+      end
+    end
+  end
+
+  # The parent's side: reads the rings in its children/ dir and turns them
+  # into reports for its model. One per worker; the turn thread and the
+  # loop thread both call it (never at once: worker turns run on the loop
+  # thread, the drain inside them).
+  #
+  # A turn takes reports (#take, at each boundary) and the worker settles
+  # them as the turn ends: #commit when it is kept (completed or canceled):
+  # the cursors move on (DelegateCursors) and the rings go; #release when it
+  # failed: the next turn reads the same rings again.
+  class ChildReports
+    SOURCE = Steer::DELEGATE_REPORT
+    CLIENT_PREFIX = Steer::CHILD_CLIENT_PREFIX
+
+    # A report for the model: the text delegate_result would return
+    # (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) do
+      def line(mark: nil) = Steer::Line.new(text: text, source: ChildReports::SOURCE, mark: mark)
+      def origin = { client_id: "#{ChildReports::CLIENT_PREFIX}#{child_id[0, 8]}" }
+    end
+
+    def initialize(session_id:, state_dir:)
+      @session_id = session_id
+      @state_dir = state_dir
+      @session_dir = Session.session_dir(session_id, state_dir: state_dir)
+      # child id → the Report this turn took for it (rings merged).
+      @taken = {}
+    end
+
+    # 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
+      SessionInbox.find_ring_files(@session_dir).any? { |file| !taken.include?(file) }
+    end
+
+    # The reports for rings this turn hasn't taken yet, recorded as taken.
+    # A ring that turns out to say nothing new (the reply was already given,
+    # an approval the user answers on the child's card) is deleted.
+    # @return [Array<Report>]
+    def take
+      return [] if ChildRing.mode == "off"
+
+      taken = taken_rings
+      fresh = SessionInbox.find_ring_files(@session_dir).reject { |file| taken.include?(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)
+        unless report
+          delete_rings(rings)
+          next
+        end
+
+        @taken[child_id] = merge_taken(@taken[child_id], report)
+        report
+      end
+    end
+
+    # The turn that took the reports was kept: move each child's cursor on
+    # (unless something else moved it since: the model's own
+    # delegate_result), then delete the rings.
+    def commit
+      @taken.each_value do |report|
+        Tools::DelegateCursors.update(@session_id, report.child_id, state_dir: @state_dir) do |cursor|
+          cursor == report.before ? report.after : cursor
+        end
+        delete_rings(report.rings)
+      rescue StandardError => e
+        Log.warn(:worker, "delegate_commit_failed", child: report.child_id[0, 8], error: e.class.name, msg: e.message)
+      end
+      @taken = {}
+    end
+
+    # The turn failed (rolled back): its rings stay for the next one.
+    def release
+      @taken = {}
+    end
+
+    def taken? = !@taken.empty?
+
+    private
+
+    def taken_rings
+      @taken.values.flat_map(&:rings)
+    end
+
+    # A second ring for a child taken earlier in this turn: read from where
+    # the first report left the cursor, keeping the first one's +before+.
+    def merge_taken(earlier, report)
+      return report unless earlier
+
+      report.with(before: earlier.before, rings: earlier.rings + report.rings)
+    end
+
+    # @return [Report, nil] nil when the child has nothing to report
+    def report_for(child_id, rings)
+      child = Session.load(child_id, state_dir: @state_dir)
+      return nil unless child.parent_id == @session_id
+
+      before = @taken[child_id]&.after || Tools::DelegateCursors.get(@session_id, child_id, state_dir: @state_dir)
+      wait = ReplyWait.call(child_id, state_dir: @state_dir, cursor: before.reply_file, baseline: before.baseline,
+                                      timeout: 0)
+      return nil unless reportable?(wait)
+
+      after = before.with(reply_file: wait.status == :done ? wait.file : before.reply_file)
+                    .with_baseline(ReplyWait.baseline_of(wait.session))
+      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)
+    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.
+    def reportable?(wait)
+      case wait.status
+      when :done, :no_reply, :error then true
+      when :waiting_for_answer then [nil, "", "continue"].include?(wait.question&.dig(:kind)&.to_s)
+      else false
+      end
+    end
+
+    def delete_rings(rings)
+      rings.each { |file| FileUtils.rm_f(file) }
+    end
+  end
+end

data/lib/samagotchi/client.rb

@@ -250,11 +250,13 @@ module Samagotchi
     #   this request runs on. PromptWarmup's pin, and only while a warm-up
     #   still runs there: a request pinned to a slot the server has since
     #   cleared skips its prompt cache and prefills everything again
+    # @param cache_prompt [Boolean] llama.cpp only: false prefills the whole
+    #   prompt, reusing nothing cached (a malformed generation's retry)
     # @return [String] the generated text
     def complete(prompt, stop: [], n_predict: nil, model: nil, on_chunk: nil, cancel_controller: nil, on_retry: nil,
-                 images: [], sampling: {}, slot: nil)
+                 images: [], sampling: {}, slot: nil, cache_prompt: true)
       images = Array(images)
-      request = { stop: stop, n_predict: n_predict, model: model, sampling: sampling, slot: slot }
+      request = { stop: stop, n_predict: n_predict, model: model, sampling: sampling, slot: slot, cache_prompt: cache_prompt }
       return stream_completion(LLM::Utf8Scrub.call(prompt), request, on_chunk, cancel_controller, on_retry) if images.empty?
 
       # The media marker is random per server process: a restart between the
@@ -311,6 +313,33 @@ module Samagotchi
                  prompt_ms: timings["prompt_ms"]&.round)
     end
 
+    # Whether llama.cpp's slot +slot+ is processing a request now (GET
+    # /slots, its is_processing): :busy or :idle. nil when unknown: no slot,
+    # another transport, the endpoint off (--no-slots), a slot it doesn't
+    # list, a bad body or a network error. One quick attempt (PromptWarmup:
+    # a warm-up pinned to a busy slot waits behind that request, and the
+    # next turn behind the warm-up).
+    # @return [Symbol, nil]
+    def slot_status(slot, model: nil)
+      return nil unless @transport.native? && slot.is_a?(Integer)
+
+      model = model.to_s.strip
+      query = model.empty? ? "" : "?#{URI.encode_www_form(model: model)}"
+      uri = URI("#{@scheme}://#{@host}:#{@port}/slots#{query}")
+      response = @http.fetch(uri, Net::HTTP::Get.new(uri), retries: false, check_status: false,
+                                  log_fields: { purpose: "slots" },
+                                  open_timeout: CONTEXT_WINDOW_PROBE_OPEN_TIMEOUT,
+                                  read_timeout: CONTEXT_WINDOW_PROBE_READ_TIMEOUT)
+      return nil unless response.code.to_s == "200"
+
+      entry = Array(JSON.parse(response.body.to_s)).find { |s| s.is_a?(Hash) && s["id"] == slot }
+      return nil unless entry&.key?("is_processing")
+
+      entry["is_processing"] == true ? :busy : :idle
+    rescue StandardError
+      nil
+    end
+
     private def stream_completion(prompt, fields, on_chunk, cancel_controller, on_retry)
       uri = completion_uri
       request = Net::HTTP::Post.new(uri)
@@ -498,7 +527,7 @@ module Samagotchi
       URI("#{@scheme}://#{@host}:#{@port}#{@transport.completion_path}")
     end
 
-    def completion_payload(prompt, stop:, n_predict:, model:, sampling: {}, slot: nil)
+    def completion_payload(prompt, stop:, n_predict:, model:, sampling: {}, slot: nil, cache_prompt: true)
       payload = { prompt: prompt, stop: stop, stream: true }
       # A non-positive cap is dropped, which leaves the length to the server
       # (unbounded): 0 here never means "only process the prompt". The
@@ -508,7 +537,9 @@ module Samagotchi
       payload[:model] = model_name if model_name
       if @transport.native?
         # llama.cpp's default today, sent anyway: chi's next turn relies on it.
-        payload[:cache_prompt] = true
+        # false only for the retry of a malformed generation (KernelLoop),
+        # which a poisoned cache must not produce again.
+        payload[:cache_prompt] = cache_prompt != false
         payload[:id_slot] = slot if slot.is_a?(Integer)
       end
       sendable_sampling(sampling).merge(payload)

data/lib/samagotchi/config.rb

@@ -95,6 +95,11 @@ module Samagotchi
       Entry.new(key: "session.keep_empty",            yaml_path: %w[session keep_empty],            type: :bool,    default: false, expose: %i[env config]),
       # The most sessions one session may have delegated and still running (the delegate tool); a guard against a runaway model.
       Entry.new(key: "session.max_children",          yaml_path: %w[session max_children],          type: :integer, default: 4,     expose: %i[env config]),
+      # A delegate child's turn end reaches its parent (ChildReports): wake runs an idle parent's turn for it, queue waits
+      # for the parent's next turn, off is the old behaviour (only delegate_result asks).
+      Entry.new(key: "session.delegate_reports",      yaml_path: %w[session delegate_reports],      type: :enum,    default: "wake", expose: %i[env config], enum_values: %w[wake queue off]),
+      # Turns a parent runs for delegate reports in a row with no human input; past it reports wait for the next turn.
+      Entry.new(key: "session.max_wakes",             yaml_path: %w[session max_wakes],             type: :integer, default: 10,    expose: %i[env config]),
 
       # Images sent to a model (ImageStore): the long side they are downscaled
       # to, the most bytes one may take (bigger → re-encoded as jpeg), and how

data/lib/samagotchi/engine.rb

@@ -61,6 +61,7 @@ require_relative "thinking"
 require_relative "answer_display"
 require_relative "edit_preview"
 require_relative "question_desk"
+require_relative "child_reports"
 require_relative "relay_desk"
 require_relative "guardrail_wiring"
 require_relative "plugin_tasks"
@@ -1190,6 +1191,7 @@ module Samagotchi
     def record_last_turn(session, outcome, seconds, origin, event, limit: nil)
       client_id = origin.is_a?(Hash) ? origin[:client_id].to_s : ""
       source = if client_id.start_with?("#{Tools::Delegate::CLIENT_PREFIX}:") then "delegate"
+               elsif client_id.start_with?(ChildReports::CLIENT_PREFIX) then "delegate_report"
                elsif client_id == SessionManager::REMINDER_CLIENT_ID then "reminder"
                else "client"
                end

data/lib/samagotchi/idle_recap.rb

@@ -54,6 +54,7 @@ module Samagotchi
       TOOL_OUTPUT_HEADER_RE = /\A\[([\w.:-]+)\]/
       # The text the web sends for a turn of images alone (images.js turnText).
       IMAGE_ONLY_RE = /\A\s*(?:\[image: [^\]\n]*\]\s*)+\z/
+      DELEGATE_REPORT_LINE = "(a delegate session's report, delivered by chi; not the user's words)"
 
       module_function
 
@@ -71,6 +72,9 @@ module Samagotchi
             # An image is a line naming it (refs only, never its bytes), unless
             # the text is only the web's placeholder naming it already.
             content = message["content"].to_s
+            # A delegate child's report (ChildReports) is chi's news, not
+            # what the user said.
+            content = "#{DELEGATE_REPORT_LINE}\n#{content}" if message["source"].to_s == Steer::DELEGATE_REPORT
             images = IMAGE_ONLY_RE.match?(content) ? [] : image_lines(message["images"])
             [content, *images].reject(&:empty?).join("\n")
           when "model", "assistant"

data/lib/samagotchi/kernel_loop.rb

@@ -97,6 +97,8 @@ module Samagotchi
 
     DEFAULT_MAX_TOOL_OUTPUT_CHARS = 10_000
     QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_LIMIT = 2
+    # How much of a malformed generation's end the warning keeps.
+    MALFORMED_TAIL_CHARS = 400
     QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_PROMPT = "Continue the previous assistant message by finishing the open <tool_call> XML block. Output only the remaining XML needed to complete the tool call."
 
     # @param tools [Tools::Registry, nil] the tools calls dispatch to (the
@@ -242,7 +244,8 @@ module Samagotchi
     # the prefill, and what the caller gave.
     Turn = Struct.new(:conversation, :context, :empty_retry, :tool_activity, :buffer, :streamed_thinking, :qwen_attempts,
                       :qwen_partial, :prefill, :pending_tool_calls, :model_name, :pending_input, :on_stream_event,
-                      :cancel_controller, :cap, :emit, :iteration, :empty_steps, :ended_empty, keyword_init: true)
+                      :cancel_controller, :cap, :emit, :iteration, :empty_steps, :ended_empty, :malformed_retried,
+                      :uncached_next, keyword_init: true)
     # One request: the prompt and its images as sent, the images' token
     # estimate, and the window it was measured against.
     Request = Struct.new(:prompt, :images, :image_tokens, :window, :prefill, keyword_init: true)
@@ -250,9 +253,10 @@ module Samagotchi
     # generation's own server counts, the model the server named, the
     # thinking it streamed, and why it stopped (the transport's finish
     # reason, Client::Transport#finish_reason_from; nil when not named),
-    # and its prompt-cache counts (the largest seen: they come cumulative).
+    # and its prompt-cache counts (the largest seen: they come cumulative),
+    # and where its visible text starts in the turn's buffer.
     Generation = Struct.new(:response, :cut, :usage, :served_model, :streamed_thinking, :finish_reason, :cache,
-                            keyword_init: true)
+                            :buffer_mark, keyword_init: true)
     private_constant :Turn, :Request, :Generation
 
     def start_turn(messages, on_stream_event:, cancel_controller:, pending_input:, cap:)
@@ -278,6 +282,9 @@ module Samagotchi
       request = prepare_request(turn)
       generation = generate(turn, request)
       return after_cut(turn, generation) if generation.cut
+      if (reason = parser.malformed(generation.response))
+        return after_malformed(turn, generation, reason)
+      end
 
       turn.conversation << { role: "model", content: request.prefill + generation.response.to_s }
       # Profile-specific parse (incl. Qwen unterminated-block recovery); the
@@ -330,10 +337,13 @@ module Samagotchi
       # thinking_chars=N content_length=…).
       generation = Generation.new(usage: nil, served_model: nil, streamed_thinking: 0)
       fire_hook(:before_generation, { type: :before_generation, iteration: turn.iteration }) if @hooks
-      buffer_mark = turn.buffer.length
+      buffer_mark = generation.buffer_mark = turn.buffer.length
       # A cancel salvages only this generation's thinking: the earlier
       # steps' is on their own messages already.
       turn.streamed_thinking = +""
+      # Only the retry of a malformed generation skips the prompt cache.
+      uncached = turn.uncached_next
+      turn.uncached_next = false
       generation.response = with_generation(turn.cancel_controller) do |generation_controller|
         request_generation(
           request.prompt,
@@ -341,6 +351,7 @@ module Samagotchi
           cancel_controller: turn.cancel_controller,
           model_name: turn.model_name,
           sampling: turn.empty_retry.request_sampling(@turn_settings.sampling),
+          cache_prompt: !uncached,
           on_chunk: ->(chunk) { stream_chunk(turn, generation, stream_splitter, chunk) },
           on_retry: lambda { |retry_event|
             # The retry streams from the start: its counts replace these.
@@ -462,6 +473,31 @@ module Samagotchi
       cancelled_result(turn.conversation, tool_activity: turn.tool_activity, reason: :hook, partial_assistant_text: "")
     end
 
+    # A corrupt generation (ToolCallParser#malformed) is no answer and runs
+    # no tool: it is logged and dropped, with its streamed text, and the
+    # same prompt goes once more without the server's prompt cache (a
+    # poisoned cache made it, ggml-org/llama.cpp#27148), shown as the loop
+    # asking again. A second one fails the turn. Returns :next.
+    def after_malformed(turn, generation, reason)
+      response = generation.response.to_s
+      Log.warn(:model, "generation_malformed", iteration: turn.iteration, reason: reason, id_slot: @last_slot,
+                                               cache_n: generation.cache&.dig(:cached), finish_reason: generation.finish_reason,
+                                               retried: turn.malformed_retried ? true : false,
+                                               payload: response[-MALFORMED_TAIL_CHARS..] || response)
+      turn.buffer.slice!(generation.buffer_mark..)
+      if turn.malformed_retried
+        label = @client.respond_to?(:host_name) && @client.host_name ? @client.host_name : "llama.cpp"
+        raise LLM::MalformedGeneration.new("#{label}: #{reason}, again without the prompt cache; nothing was saved",
+                                           host: label)
+      end
+
+      turn.malformed_retried = true
+      turn.uncached_next = true
+      emit(turn, type: :empty_answer_retry, iteration: turn.iteration, attempt: 1, of: 1,
+                 finish_reason: generation.finish_reason, malformed: true)
+      :next
+    end
+
     # A generation with no tool calls: a Qwen call left open is asked to be
     # finished; an empty answer is asked again (EmptyAnswerRetry: not when
     # a length stop came with the context full); queued input keeps the
@@ -612,8 +648,11 @@ module Samagotchi
     end
 
     # +sampling+: this request's (EmptyAnswerRetry#request_sampling).
-    def complete_kwargs(cancel_controller:, model_name: nil, on_chunk: nil, on_retry: nil, images: [], sampling: nil)
+    # +cache_prompt+: false for a malformed generation's retry (only then sent).
+    def complete_kwargs(cancel_controller:, model_name: nil, on_chunk: nil, on_retry: nil, images: [], sampling: nil,
+                        cache_prompt: true)
       kwargs = {}
+      kwargs[:cache_prompt] = false unless cache_prompt
       # Only a request with images names them: a text-only call is unchanged.
       kwargs[:images] = images unless images.empty?
       kwargs[:on_chunk] = on_chunk if on_chunk