samagotchi 0.32.0 → 0.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9af1ef94626f6ec7c44f8a7a0ad46421eca3c770b9b0bc6dab78664ec3a9cd9
-  data.tar.gz: bb2db5c510efa064f5c377335d83b6df450a67f0bafa8c70e4160ef97dc2d874
+  metadata.gz: ca8acdcb161f8d093ab1c860913dd3a1e826083bcfff0165039847e38a26c5ad
+  data.tar.gz: 5c286ada590d84b793e95d9f2dec051132462469aace12c0faf1da0f1c4e3fdf
 SHA512:
-  metadata.gz: af61e4ce113e2dea9a3ecf9bedc4d7335aa35f7aca81e37734a952e150f79930e9a6451e1c22c507762caafa76c29fd324fe3544e901cf70fa6783547cf5924e
-  data.tar.gz: fd9ca3f931a144e48e8a120202000cf845806aaaedb676d3dde3a094e03432bc19f79eadac054363f7248c257bec7fe74ba3ae99f8b682492215dae64a4e7392
+  metadata.gz: 394a942740165c9ea457b3a3043a070ef9338a897c6eb41c387b1101e8426c8e21c938757868d87493216324d84441165a82601b796801be90feef5c8e6c7091
+  data.tar.gz: 29d24ccdb0bd41d027ccdaf4b8c6e0a191d292b636fc3af1e27e994f30b1331192f59d3bf6aa5d858e78ec5d84d32d8760f2df03c8dace2feaad1ac87783c1c6

data/CHANGELOG.md

@@ -8,6 +8,33 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.33.0] - 2026-10-06
+
+### Changed
+
+- Input from a client chi doesn't know (a script calling the web API with its own id, say) is no longer taken
+  for the user's: the model reads it as automatic input, not your message, and it never cuts in on a thinking
+  model. The TUI and the web label a prompt by its sender: "chi send", "chi answer", "plugin", or "automatic";
+  "user" is left for your own lines.
+
+### Fixed
+
+- `task_stop` no longer signals a process group chi didn't start: a missing or reused pid in a task record could
+  stop chi or other processes.
+- A delegate child that crashes still wakes its idle parent.
+- `chi send <id> --wait` to a stopped session with attached context prints the answer instead of "no answer".
+- `chi bundle build` keeps a bundle's `scripts:` and `context_providers:`, so a rebuilt bundle still attaches its URLs.
+- A context source's wake is no longer lost when a later update that doesn't ask to wake comes in before the
+  session reads it.
+- A failed wake turn leaves a plain note in the conversation; a reload no longer draws an empty turn for it.
+- Web: the info bar no longer swallows a click on "copy chi --attach" or Restart while a turn runs, and its
+  tooltips stay up.
+- Web: an image the server refuses shows why; a 409 that isn't "open in a chi REPL" no longer switches the page to
+  the REPL notice.
+- Web: an answer equal to an earlier turn's ("Done." twice) is shown.
+
+Update with `chi update`.
+
 ## [0.32.0] - 2026-10-06
 
 ### Added
@@ -1636,7 +1663,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.32.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.33.0...HEAD
+[0.33.0]: https://github.com/dm1try/samagotchi/compare/v0.32.0...v0.33.0
 [0.32.0]: https://github.com/dm1try/samagotchi/compare/v0.31.0...v0.32.0
 [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

data/docs/context.md

@@ -135,7 +135,9 @@ attaches a URL; the web never adds a command.
 A change can start a turn by itself, so the agent tells you about it while
 you're away from the terminal. All of these must hold:
 
-- the source asked (`"wake": true`; a plain-text source never does);
+- the source asked (`"wake": true`; a plain-text source never does), in
+  any change since the session last heard of it: a later change that doesn't
+  ask doesn't take the wake back;
 - `context.wake` is on (default `true`);
 - the session's worker is up and idle: no turn running, nothing queued, no
   question or continue offer waiting, not just started;

data/docs/hooks.md

@@ -122,9 +122,12 @@ Its `source` is the hook's bundle (a config or turn hook's label otherwise).
 Lines typed into a running turn are saved as `{role: "user", kind: "input",
 content: "…"}`: part of that turn, not a turn of their own. They carry a
 `source` when they are not the user's own: `chi_send` (`chi send -m`),
-`parent_agent` (a delegate's follow-up) or `plugin_send` (`ctx.sessions.send`).
-The model reads them with the same kind of header (`[Steer from the user, …]`,
-`[Steer sent with chi send, …]`, and so on).
+`parent_agent` (a delegate's follow-up), `plugin_send` (`ctx.sessions.send`),
+or `automatic:<client id>` for a client id chi doesn't know (an unknown sender
+is never taken for the user). The model reads them with the same kind of
+header (`[Steer from the user, …]`, `[Steer sent with chi send, …]`, and so
+on; `[Automatic input from <client id>, sent mid-task; not your user's
+message. …]` for an unknown one).
 
 Timing: a notice from `:after_turn` or `:session_end` shows after the turn's
 end line. A question from `:before_tool_call` shows **before** the tool

data/docs/plugins.md

@@ -1181,7 +1181,8 @@ gem.
 - `chi bundle diff <name> [plugin.rb]`: shows the installed base and the
   file on disk.
 - `chi bundle build --name <name>`: puts the installed plugin (and
-  `requires_chi`) into the built bundle.
+  `requires_chi`, its `scripts/` and `context_providers:`) into the built
+  bundle.
 - `chi bundle uninstall <name>`: removes the plugin with the bundle.
 
 ## Not yet

data/docs/releasing.md

@@ -49,7 +49,8 @@ as the GitHub release body.
 | Task | What it does |
 | --- | --- |
 | `rake bundles:sha` | Recomputes the sha256 lines of every shipped bundle manifest (`files:`, `hooks:`, `plugin:`). |
-| `rake bundles:check` | Sha lines match; a bundle changed since the last `v*` tag has a higher version (skipped, with a note, before the first tag). Warns (doesn't fail) when such a bundle's `requires_chi` still admits the tagged chi: raise it if the change uses anything new. |
+| `rake bundles:check` | Sha lines match; a bundle changed since the last `v*` tag has a higher version (skipped, with a note, before the first tag). Warns (doesn't fail) when such a bundle's `requires_chi` still admits the tagged chi: raise it if the change uses anything new. The release workflow and `release:check` run it in full. |
+| `rake 'bundles:check[ci]'` | The CI workflow's (every push and PR): the same, except the version check leaves out the system bundle, which is changed and unbumped between releases (`release:bump` moves its version with VERSION). A task argument, not `CI=1`: GitHub sets `CI` in the release workflow too. |
 | `rake release:draft_changelog` | A draft Unreleased section from the commit subjects since the last tag, grouped. Stdout only. |
 | `rake release:bump[X.Y.Z]` | VERSION, the system manifest, Gemfile.lock, CHANGELOG. No commit. |
 | `rake release:check` | Clean tracked tree, VERSION == system bundle, a CHANGELOG section, `bundles:check`, `rake lint` (RuboCop), rspec + npm test, `gem build`, then a clean install into a temp GEM_HOME that runs `chi --version`, `chi self` and `chi bundle list` with a temp HOME. Needs the network (gem dependencies). |

data/lib/samagotchi/answer_command.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "client_id"
 require_relative "session"
 require_relative "session_manager"
 require_relative "bridge_client"
@@ -189,7 +190,7 @@ module Samagotchi
                   client.dismiss_question(id: qid)
                 else
                   client.answer(id: qid, selected: selected, freeform: options[:text],
-                                client_id: Guardrails::ParentApprovals::CLIENT_ID)
+                                client_id: ClientId::CLI_ANSWER)
                 end
         break unless reply.status == 408
       end

data/lib/samagotchi/archive_store.rb

@@ -17,12 +17,6 @@ module Samagotchi
   # file from memory (and bumps updated_at) at every turn.
   module ArchiveStore
     FILE = "archived"
-    # Input a human typed: a web tab, a chi TUI, `chi send`, and nil (a
-    # worker's initial prompt; a web client may send none). Delegates,
-    # plugins and reminders are not (an allowlist, so a new automatic
-    # origin stays out).
-    USER_CLIENT_PREFIXES = %w[web: tui:].freeze
-    USER_CLIENT_IDS = ["cli:send"].freeze
 
     # @return [Hash, nil] the marker (string keys), nil when none or unreadable
     def self.read(session_dir)
@@ -57,15 +51,7 @@ module Samagotchi
       write(session_id, { "unarchived_at" => Time.now.iso8601(3) }, state_dir: state_dir)
     end
 
-    # Whether +client_id+ (a turn's origin) is a human's input.
-    def self.user_input?(client_id)
-      return true if client_id.nil?
-
-      id = client_id.to_s
-      USER_CLIENT_IDS.include?(id) || USER_CLIENT_PREFIXES.any? { |prefix| id.start_with?(prefix) }
-    end
-
-    # A human's input came into the session: it is back in the lists. Its
+    # A human's input (ClientId.human?) came into the session: it is back in the lists. Its
     # children stay archived. Never raises.
     # @return [Boolean] whether it was archived
     def self.user_input(session_id, state_dir:)

data/lib/samagotchi/bridge.rb

@@ -55,6 +55,8 @@ module Samagotchi
     CANCEL_REASONS = %w[manual user ctrl_c].freeze
     # How long #stop waits for requests it is answering (not open streams).
     REQUEST_GRACE_SECONDS = 1.0
+    # How long #stop waits for each killed RelayWatcher thread to end.
+    RELAY_WATCHER_JOIN_SECONDS = 1.0
     # The largest request body read (images travel as refs, never bytes).
     MAX_BODY_BYTES = 1_000_000
     # A request's deadline (see #handle_post_turn) that isn't epoch seconds.
@@ -198,7 +200,9 @@ module Samagotchi
       await_answers(REQUEST_GRACE_SECONDS)
       @connection_threads.each { |t| t.kill rescue nil }
       @connection_threads.clear
-      @mutex.synchronize { @relay_watchers&.each { |t| t.kill rescue nil } }
+      # Its relay watchers (RelayWatcher) end with it.
+      watchers = @mutex.synchronize { (@relay_watchers || []).tap { @relay_watchers = [] } }
+      watchers.each { |thread| thread.kill.join(RELAY_WATCHER_JOIN_SECONDS) }
       @accept_thread&.join(2)
       remove_sidecar
       nil
@@ -839,8 +843,9 @@ module Samagotchi
       return [{}, 500, { error: "enqueue_failed", detail: "could not write turn input" }] unless enqueued
 
       # Queued (outside the event lock): a running generation that has only
-      # been thinking for long is cut for it, unless a plugin sent it. An
-      # image input never merges mid-turn, so it never cuts.
+      # been thinking for long is cut for it, unless a plugin or a client
+      # chi doesn't know sent it. An image input never merges mid-turn, so
+      # it never cuts.
       @engine.cut_for_steer(Steer.source_for_client(client_id), epoch: epoch) if images.empty?
       [{}, 202, { status: "accepted", enqueued_id: enqueued_id, session_id: @session_id }]
     end

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

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.32.0
+version: 0.33.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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "client_id"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "reply_wait"
@@ -29,6 +30,13 @@ module Samagotchi
     # Turns an idle parent runs for reports in a row with no human input.
     MAX_WAKES_KEY = "session.max_wakes"
     MAX_WAKES_DEFAULT = 10
+    # How long a leaving worker waits for the parent wakes it started
+    # (#await_wakes): a wake only spawns a worker, well under a second.
+    WAKE_JOIN_SECONDS = 5
+
+    # The wake threads #ring started in this process, until #await_wakes.
+    @wakes = []
+    @wakes_mutex = Mutex.new
 
     module_function
 
@@ -70,15 +78,29 @@ module Samagotchi
     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
+      return wake.call(parent_id) if wake
+
+      thread = 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
+      @wakes_mutex.synchronize { @wakes = @wakes.select(&:alive?) << thread }
+      thread
+    end
+
+    # Waits up to +timeout+ for the parent wakes this process started: a
+    # worker's teardown, since its process exits right after (a crash's
+    # ring comes just before it) and an exit kills a wake midway, before
+    # it spawned the parent's worker.
+    # @return [Integer] the wakes still running after it
+    def await_wakes(timeout = WAKE_JOIN_SECONDS)
+      threads = @wakes_mutex.synchronize { @wakes.tap { @wakes = [] } }
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      threads.each { |thread| thread.join([deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max) }
+      left = threads.count(&:alive?)
+      Log.warn(:worker, "delegate_wakes_left", count: left) if left.positive?
+      left
     end
   end
 
@@ -93,7 +115,6 @@ module Samagotchi
   # 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,
@@ -101,7 +122,7 @@ module Samagotchi
     # 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]}" }
+      def origin = { client_id: "#{ClientId::CHILD_PREFIX}#{child_id[0, 8]}" }
     end
 
     def initialize(session_id:, state_dir:)

data/lib/samagotchi/client_id.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # Who sent a turn, a line or an answer: its client_id, as a turn's origin,
+  # an input file and the events carry it. The one table of the ids chi
+  # makes, and of which of them are a human's input (#human?). No requires,
+  # so any file can use it.
+  module ClientId
+    # A web tab (web:<random>, per tab); web:restart, the page's Restart.
+    WEB_PREFIX = "web:"
+    WEB_RESTART = "web:restart"
+    # An attached chi TUI: tui:<pid>.
+    TUI_PREFIX = "tui:"
+    # chi send's turns and commands.
+    CLI_SEND = "cli:send"
+    # chi answer's answers (a parent agent's, Guardrails::ParentApprovals).
+    CLI_ANSWER = "cli:answer"
+    # chi restart.
+    CLI_RESTART = "cli:restart"
+    # A delegating parent's task or follow-up: delegate:<parent8>.
+    DELEGATE_PREFIX = "delegate:"
+    # A delegate child's report (ChildReports): child:<child8>.
+    CHILD_PREFIX = "child:"
+    # A turn chi ran because an attached context source changed:
+    # context:<name> (Worker's context wake).
+    CONTEXT_PREFIX = "context:"
+    # chi's own turns; system:reminder, the turn queued when reminders are due.
+    SYSTEM_PREFIX = "system:"
+    REMINDER = "system:reminder"
+    # A plugin's message (Plugin::Sessions#send).
+    PLUGIN = "plugin"
+    # A relayed answer (RelayVerifier): relay:<parent8>.
+    RELAY_PREFIX = "relay:"
+
+    # Input a human typed: a web tab, a chi TUI, chi send, and nil (a
+    # worker's initial prompt; a web client may send none). An allowlist:
+    # delegates, plugins, reminders, context changes and any id chi doesn't
+    # know are not.
+    HUMAN_PREFIXES = [WEB_PREFIX, TUI_PREFIX].freeze
+    HUMAN_IDS = [CLI_SEND].freeze
+
+    module_function
+
+    # Whether +client_id+ (a turn's or a line's origin) is a human's input.
+    def human?(client_id)
+      return true if client_id.nil?
+
+      id = client_id.to_s
+      HUMAN_IDS.include?(id) || HUMAN_PREFIXES.any? { |prefix| id.start_with?(prefix) }
+    end
+  end
+end

data/lib/samagotchi/context_absorber.rb

@@ -118,7 +118,8 @@ module Samagotchi
       if sub.seen != snapshot.revision
         args = { name: name, hint: hint, summary: snapshot.summary, changes: snapshot.serial - sub.seen_serial }
         found = delivery(name, text_note_id(name, snapshot), self.class.updated_text(**args), now, seen(sub, snapshot))
-        return found unless snapshot.wake
+        # Any revision since the one the session last saw may have asked.
+        return found unless snapshot.wake_serial.to_i > sub.seen_serial
 
         return found.with(wake_note: found.note.merge(text: self.class.updated_text(**args, wake: true)))
       end

data/lib/samagotchi/context_fetch.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require_relative "context_sources"
 require_relative "context_providers"
 require_relative "log"
+require_relative "process_group"
 
 module Samagotchi
   # Runs an attached context source's command once and records the result
@@ -117,47 +118,26 @@ module Samagotchi
 
       out_r, out_w = IO.pipe
       err_r, err_w = IO.pipe
-      pid = Process.spawn(env, "sh", "-c", cmd, chdir: cwd, pgroup: true, in: File::NULL, out: out_w, err: err_w)
+      pid = ProcessGroup.spawn(env, "sh", "-c", cmd, chdir: cwd, in: File::NULL, out: out_w, err: err_w)
       out_w.close
       err_w.close
-      output = +""
-      over = false
-      out_reader = Thread.new do
-        loop do
-          chunk = out_r.readpartial(READ_CHUNK)
-          if output.bytesize + chunk.bytesize > ContextSources::TEXT_MAX_BYTES
-            over = true
-            break
-          end
-          output << chunk
-        end
-      rescue IOError # EOFError too
-        nil
-      end
-      stderr = +""
-      err_reader = Thread.new do
-        loop do
-          stderr << err_r.readpartial(READ_CHUNK)
-          stderr = stderr.byteslice(-STDERR_TAIL_BYTES, STDERR_TAIL_BYTES) if stderr.bytesize > STDERR_TAIL_BYTES
-        end
-      rescue IOError # EOFError too
-        nil
-      end
+      out_reader = ProcessGroup::PipeReader.new(out_r, cap: ContextSources::TEXT_MAX_BYTES, chunk: READ_CHUNK)
+      err_reader = ProcessGroup::PipeReader.new(err_r, cap: STDERR_TAIL_BYTES, keep: :tail, chunk: READ_CHUNK)
 
-      error, status = wait(pid, timeout: timeout, over: -> { over }, cancelled: cancelled)
+      error, status = wait(pid, timeout: timeout, over: -> { out_reader.over? }, cancelled: cancelled)
       reaped = true
       # Whatever the command left running in its group goes with it.
-      signal_group(pid, "KILL")
-      [out_reader, err_reader].each { |thread| thread.join(KILL_GRACE_SECONDS) || thread.kill }
-      stderr_text = stderr.dup.force_encoding(Encoding::UTF_8).scrub
+      ProcessGroup.signal(pid, "KILL")
+      [out_reader, err_reader].each { |reader| reader.wait(KILL_GRACE_SECONDS) || reader.kill }
+      stderr_text = err_reader.text(Encoding::UTF_8).scrub
       Log.debug(:context, "stderr", text: stderr_text[-1000..] || stderr_text) unless stderr_text.strip.empty?
       return Run.new(output: nil, error: nil, stderr: stderr_text, cancelled: true) if error == :cancelled
 
       # Checked again once the reader is done: a command that exits before
       # wait's next tick never gets an over from it.
-      error = OVER_CAP if over
+      error = OVER_CAP if out_reader.over?
       error ||= exit_error(status, stderr_text)
-      Run.new(output: output, error: error, stderr: stderr_text, cancelled: false)
+      Run.new(output: out_reader.text, error: error, stderr: stderr_text, cancelled: false)
     rescue SystemCallError => e
       Run.new(output: nil, error: "couldn't run it: #{e.message}", stderr: "", cancelled: false)
     ensure
@@ -188,33 +168,22 @@ module Samagotchi
 
     def abandon(pid, readers)
       stop_group(pid)
-      readers.each { |thread| thread&.kill }
+      readers.each { |reader| reader&.kill }
     rescue StandardError => e
       Log.warn(:context, "stop_failed", pid: pid, error: e.class.name)
     end
 
     # TERM, then KILL after a grace; @return [Process::Status, nil]
     def stop_group(pid)
-      signal_group(pid, "TERM")
-      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + KILL_GRACE_SECONDS
-      until Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
-        _, status = Process.wait2(pid, Process::WNOHANG)
-        return status if status
+      status = nil
+      reaped = -> { status = Process.wait2(pid, Process::WNOHANG)&.last }
+      return status if ProcessGroup.stop(pid, grace: KILL_GRACE_SECONDS, poll: 0.05, stopped: reaped)
 
-        sleep(0.05)
-      end
-      signal_group(pid, "KILL")
       Process.wait2(pid).last
     rescue Errno::ECHILD
       nil
     end
 
-    def signal_group(pid, signal)
-      Process.kill(signal, -pid)
-    rescue Errno::ESRCH, Errno::EPERM
-      nil
-    end
-
     def exit_error(status, stderr)
       return nil if status.nil? || status.success?
 

data/lib/samagotchi/context_sources.rb

@@ -67,26 +67,35 @@ module Samagotchi
     # +serial+ counts the revisions (an absorb that missed some says how
     # many); +error+ is the last failure, +error_since+ when the failures
     # began (cleared by a success), so a session hears about each run of
-    # failures once. +summary+, +wake+ and +hint+ come with the revision.
+    # failures once. +summary+, +wake+ and +hint+ come with the revision;
+    # +wake_serial+ is the serial of the newest revision that asked to wake
+    # (nil: none), so a change that doesn't ask, recorded before an absorb,
+    # doesn't hide a wake asked since the session's last one.
     # +fetched_at+ is the last success, +checked_at+ the last try (the
     # poller's clock: a failing source isn't run again every tick).
-    Snapshot = Data.define(:text, :summary, :revision, :serial, :fetched_at, :checked_at, :wake, :hint, :error,
-                           :error_since) do
+    Snapshot = Data.define(:text, :summary, :revision, :serial, :fetched_at, :checked_at, :wake, :wake_serial, :hint,
+                           :error, :error_since) do
       def self.empty
-        new(text: nil, summary: nil, revision: nil, serial: 0, fetched_at: nil, checked_at: nil, wake: false, hint: nil,
-            error: nil, error_since: nil)
+        new(text: nil, summary: nil, revision: nil, serial: 0, fetched_at: nil, checked_at: nil, wake: false,
+            wake_serial: nil, hint: nil, error: nil, error_since: nil)
       end
 
       def to_h
         { "text" => text, "summary" => summary, "revision" => revision, "serial" => serial,
-          "fetched_at" => fetched_at, "checked_at" => checked_at, "wake" => (wake ? true : nil), "hint" => hint,
+          "fetched_at" => fetched_at, "checked_at" => checked_at, "wake" => (wake ? true : nil),
+          "wake_serial" => wake_serial, "hint" => hint,
           "error" => error, "error_since" => error_since }.compact
       end
 
+      # A snapshot 0.32.0 wrote has no wake_serial: its wake is the latest
+      # revision's.
       def self.from_h(data)
-        new(text: data["text"], summary: data["summary"], revision: data["revision"], serial: data["serial"].to_i,
-            fetched_at: data["fetched_at"], checked_at: data["checked_at"] || data["fetched_at"],
-            wake: data["wake"] == true, hint: data["hint"], error: data["error"], error_since: data["error_since"])
+        serial = data["serial"].to_i
+        wake = data["wake"] == true
+        new(text: data["text"], summary: data["summary"], revision: data["revision"], serial: serial,
+            fetched_at: data["fetched_at"], checked_at: data["checked_at"] || data["fetched_at"], wake: wake,
+            wake_serial: data["wake_serial"]&.to_i || (serial if wake), hint: data["hint"], error: data["error"],
+            error_since: data["error_since"])
       end
 
       def text? = !text.nil?
@@ -230,7 +239,8 @@ module Samagotchi
                   else
                     Snapshot.new(text: fetched.text, revision: revision, serial: previous.serial + 1, fetched_at: stamp,
                                  checked_at: stamp, summary: fetched.summary || ContextSources.plain_summary(previous.text, fetched.text),
-                                 wake: fetched.wake, hint: fetched.hint || previous.hint, error: nil, error_since: nil)
+                                 wake: fetched.wake, wake_serial: fetched.wake ? previous.serial + 1 : previous.wake_serial,
+                                 hint: fetched.hint || previous.hint, error: nil, error_since: nil)
                   end
         write_snapshot(name, written)
       end

data/lib/samagotchi/engine.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "time"
 require "yaml"
 
+require_relative "client_id"
 require_relative "iteration_limit"
 require_relative "config"
 require_relative "context_note"
@@ -349,7 +350,8 @@ module Samagotchi
     # again with the message, no nudge, no retry spent. Too early, the
     # message waits (WaitingSteer) and cuts once the thinking passes it
     # (#recheck_waiting_steer, on each thinking chunk), unless a boundary
-    # hands it to the model first. A plugin's message never cuts.
+    # hands it to the model first. A plugin's message never cuts, nor an
+    # unknown client's (automatic:<id>).
     # Call it after the message is queued, with the #input_epoch read
     # before queueing it. Outside any lock; a cut that lands just after the
     # generation ended is harmless (the loop re-asks).
@@ -811,6 +813,7 @@ module Samagotchi
       # #stop_idle's work (the scheduler's stop is idempotent), where the
       # callers haven't stopped it already.
       @idle_scheduler&.stop
+      @prompt_warmup.stop
       deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + join_timeout
       threads.each do |thread|
         next if thread == Thread.current
@@ -1183,17 +1186,18 @@ module Samagotchi
     private :hook_messages
 
     # How the turn ended, on the session (Session#last_turn): the caller's
-    # save puts it in the file the session hub watches.
+    # save puts it in the file the session hub watches. Public for the
+    # Worker's turn that failed before it began (no #end_turn ran).
     # @param limit [Integer, nil] the turn ran out of iterations at this
     #   limit: "exhausted" => true, "limit" => N, so a wait with nobody to
     #   answer the continue offer says so (ReplyWait, ParentReport "limit")
     # @param event [Hash] the turn's end event (#stop_facts)
     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.start_with?(Steer::CONTEXT_CLIENT_PREFIX) then "context"
-               elsif client_id == SessionManager::REMINDER_CLIENT_ID then "reminder"
+      source = if client_id.start_with?(ClientId::DELEGATE_PREFIX) then "delegate"
+               elsif client_id.start_with?(ClientId::CHILD_PREFIX) then "delegate_report"
+               elsif client_id.start_with?(ClientId::CONTEXT_PREFIX) then "context"
+               elsif client_id == ClientId::REMINDER then "reminder"
                else "client"
                end
       session.last_turn = { "outcome" => outcome, "ended_at" => Time.now.iso8601(3),
@@ -1201,7 +1205,6 @@ module Samagotchi
       session.last_turn.merge!("exhausted" => true, "limit" => limit) if limit
       session.last_turn.merge!(stop_facts(event))
     end
-    private :record_last_turn
 
     # Why a turn stopped, from its end event, for a parent agent's wait
     # (ReplyWait): a provider error's kind and whether a retry may help, a

data/lib/samagotchi/guardrails/parent_approvals.rb

@@ -30,8 +30,6 @@ module Samagotchi
     # rewrite would be "allow everything" from then on.
     module ParentApprovals
       KEY = "guardrails.parent_approvals"
-      # The client id chi answer posts its answers with.
-      CLIENT_ID = "cli:answer"
       # Set by chi's execute and task_create for the commands they run: a
       # chi started there answers as a parent (#parent_process?).
       PARENT_SESSION_ENV = "SAMAGOTCHI_PARENT_SESSION"

data/lib/samagotchi/memory_bundle/builder.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "tmpdir"
 require_relative "manifest"
 require_relative "placeholder"
+require_relative "../context_providers"
 require_relative "../memory_paths"
 require_relative "../model_overlay"
 
@@ -152,6 +153,10 @@ module Samagotchi
         requires_chi = prov_data && prov_data[:requires_chi]
         needs = prov_data && prov_data[:needs]
 
+        # ── Scripts and context providers: the installed bundle's ──
+        scripts_to_copy = installed_scripts(prov, prov_data)
+        context_providers = prov_data ? ContextProviders.parse_list(prov_data[:context_providers]) : []
+
         # Determine trust_level for the built bundle
         build_trust_level = @trust_level
         if (build_trust_level.nil? || build_trust_level.empty?) && prov_data && prov_data[:trust_level]
@@ -185,6 +190,11 @@ module Samagotchi
 
           FileUtils.cp(plugin_src, File.join(staging, File.basename(plugin_src))) if plugin_src
 
+          unless scripts_to_copy.empty?
+            FileUtils.mkdir_p(File.join(staging, "scripts"))
+            scripts_to_copy.each_value { |src| FileUtils.cp(src, File.join(staging, "scripts", File.basename(src))) }
+          end
+
           Manifest.write(
             dir: staging,
             name: resolved_name,
@@ -196,7 +206,9 @@ module Samagotchi
             trust_level: build_trust_level,
             plugin: plugin_src && { file: File.basename(plugin_src), sha256: Digest::SHA256.hexdigest(File.binread(plugin_src)) },
             requires_chi: requires_chi,
-            needs: needs
+            needs: needs,
+            scripts: scripts_to_copy.transform_values { |src| "sha256:#{Digest::SHA256.hexdigest(File.binread(src))}" },
+            context_providers: context_providers
           )
 
           case format
@@ -255,6 +267,15 @@ module Samagotchi
 
       private
 
+      # The installed bundle's scripts its record lists, file name => path
+      # in its scripts/ (a missing one is left out); {} without a record.
+      def installed_scripts(prov, prov_data)
+        return {} unless prov && prov_data && prov_data[:scripts].is_a?(Hash)
+
+        prov_data[:scripts].keys.map(&:to_s).sort.to_h { |file| [file, File.join(prov.scripts_dir, file)] }
+                           .select { |_, path| File.file?(path) }
+      end
+
       # Without an allowlist, a memory another installed bundle owns (its
       # record lists it) isn't the user's to share: left out, one line
       # each. The bundle being built (same name) keeps its own.

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -124,7 +124,7 @@ module Samagotchi
 
       # Writes a fresh manifest.yml from computed checksums at `dir`.
       def self.write(dir:, name:, version:, files:, scope: nil, description: "", hooks: nil, trust_level: nil,
-                     plugin: nil, requires_chi: nil, needs: nil)
+                     plugin: nil, requires_chi: nil, needs: nil, scripts: {}, context_providers: [])
         FileUtils.mkdir_p(dir)
         manifest = {
           "name" => name,
@@ -149,6 +149,8 @@ module Samagotchi
         manifest["requires_chi"] = requires_chi.to_s if requires_chi && !requires_chi.to_s.empty?
         needs = parse_needs(needs)
         manifest["needs"] = needs.map { |n| n.transform_keys(&:to_s).compact } unless needs.empty?
+        manifest["scripts"] = scripts.transform_keys(&:to_s) unless scripts.empty?
+        manifest["context_providers"] = context_providers.map(&:to_h) unless context_providers.empty?
         File.write(File.join(dir, "manifest.yml"), YAML.dump(manifest))
       end