samagotchi 0.159.0 → 0.161.0

data/lib/samagotchi/child_reports.rb

@@ -52,12 +52,15 @@ module Samagotchi
     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).
+    # raised): a ring delivery (SessionInbox.deliver :ring). The ring file
+    # goes to the parent parent.json names; its WakePolicy decides whether
+    # a worker starts (a parent with none, idle, in wake mode), and for an
+    # archived parent with a later link, that link (the one whose
+    # ChildReports reads the ring). A start runs on a thread.
     # @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
+    # @param wake [#call, nil] (parent id) starts the worker the policy
+    #   decided on; nil: SessionManager.start_for_inbox on a thread
     # @return [String, nil] the ring file, nil when none was written
     # The parent is read fresh: a continue may have moved the child to the
     # chain's new link (Session::PARENT_FILE) since its worker loaded it.
@@ -70,33 +73,36 @@ module Samagotchi
 
       parent_id = Session.parent_override(child.id, state_dir: state_dir) || child.parent_id
       return nil unless parent_id
-      # A deleted parent gets no orphan dir.
-      return nil unless Session.exist?(parent_id, state_dir: state_dir)
 
-      parent_dir = Session.session_dir(parent_id, state_dir: state_dir)
-      path = SessionInbox.write_ring(parent_dir, child_id: child.id, why: why)
-      Log.info(:worker, "delegate_rang", parent: parent_id[0, 8], why: why)
-      wake_parent(parent_id, state_dir: state_dir, wake: wake) if mode == "wake"
+      # A deleted parent gets no orphan dir: the delivery refuses it (:gone).
+      path = nil
+      SessionInbox.deliver(:ring, parent_id, state_dir: state_dir, wake: mode == "wake",
+                                             start: starter(state_dir, wake)) do |at|
+        path = SessionInbox.write_ring(Session.session_dir(at, state_dir: state_dir), child_id: child.id, why: why)
+        Log.info(:worker, "delegate_rang", parent: at[0, 8], why: why)
+        true
+      end
       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)
-
-      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)
+    # The ring delivery's start: +wake+, or SessionManager.start_for_inbox
+    # on a thread (#await_wakes joins it), so the child's turn doesn't wait
+    # for a spawn.
+    def starter(state_dir, wake)
+      return ->(id) { wake.call(id).then { :woken } } if wake
+
+      lambda do |id|
+        thread = Thread.new do
+          SessionManager.start_for_inbox(id, state_dir: state_dir, event: :delegate_woke_parent)
+        rescue StandardError => e
+          Log.warn(:worker, "delegate_wake_failed", parent: id[0, 8], error: e.class.name, msg: e.message)
+        end
+        @wakes_mutex.synchronize { @wakes = @wakes.select(&:alive?) << thread }
+        :woken
       end
-      @wakes_mutex.synchronize { @wakes = @wakes.select(&:alive?) << thread }
-      thread
     end
 
     # Waits up to +timeout+ for the parent wakes this process started: a

data/lib/samagotchi/client_id.rb

@@ -9,6 +9,8 @@ module Samagotchi
     # A web tab (web:<random>, per tab); web:restart, the page's Restart.
     WEB_PREFIX = "web:"
     WEB_RESTART = "web:restart"
+    # A web page's first prompt when creating a session.
+    WEB_CREATE = "web:create"
     # An attached chi TUI: tui:<pid>.
     TUI_PREFIX = "tui:"
     # chi send's turns and commands.
@@ -98,6 +100,10 @@ module Samagotchi
     # Whether +client_id+ is a participant's (review:).
     def review?(client_id) = client_id.to_s.start_with?(REVIEW_PREFIX)
 
+    # The client id a delegating parent's task and follow-ups carry:
+    # delegate:<parent8>.
+    def delegate(parent_id) = "#{DELEGATE_PREFIX}#{parent_id.to_s[0, 8]}"
+
     # The client id a durable schedule's turn carries: system:schedule:<id>.
     def schedule(schedule_id) = "#{SCHEDULE_PREFIX}#{schedule_id}"
 

data/lib/samagotchi/command_intake.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "client_id"
+
+module Samagotchi
+  # Who may send a session command as a message (a turn's text: chi send -m
+  # "/model x", a web page's first message, an input file, a session's
+  # first prompt), and what a line from anyone else is. The one rule the
+  # two intakes ask (WorkerInbound#queue_as_command, Bridge#handle_post_turn)
+  # and the senders that refuse up front (Tools::Delegate, Schedules#add).
+  # No Engine needed: a schedule's tick and the CLI have none.
+  #
+  # From a sender that may not, a /word line is plain prompt text (the
+  # model reads it) and a ! line (a shell command: SessionCommands#shell
+  # runs it with no Gate) is refused with REFUSED, never run.
+  module CommandIntake
+    # A shell line's prefix: !<cmd>, and !rollback (SessionCommands::
+    # SHELL_BANG_PREFIX, which a spec keeps the same: SessionCommands is too
+    # big a load for the bundle test kit's budget).
+    SHELL_PREFIX = "!"
+
+    # The one text a refused shell line gets: the Bridge's 403 detail, the
+    # worker's command_ran error, a delegate's or a schedule's refusal.
+    REFUSED = "a message that starts with ! is a shell command, which only a person runs as a message " \
+              "(a web tab, a chi TUI, chi send); from a delegate, a schedule or another automatic sender it is not run. " \
+              "Say what to run in words instead (\"run `ls`\"), or leave out the leading !"
+
+    # The Bridge's error code for it (403).
+    REFUSED_ERROR = "command_not_permitted"
+
+    # chi answer's marker (a parent agent's /continue yes and
+    # /parent-answers; Worker#as_parent? holds those to its own rules): any
+    # command, with chi send's trust.
+    ALLOWED_IDS = [ClientId::CLI_ANSWER].freeze
+
+    module_function
+
+    # Whether a message from +client_id+ may run as a session command: a
+    # human's input (ClientId.human?: a web tab, a chi TUI, chi send, no
+    # client) but a participant's (review:, refused on its own), and chi
+    # answer's. A delegate, a child's report, a context or task wake, a
+    # schedule, a reminder, a relay and a plugin may not (the bundles that
+    # send, coordinator and skills, send prose).
+    def allowed?(client_id)
+      ALLOWED_IDS.include?(client_id.to_s) || (ClientId.human?(client_id) && !ClientId.review?(client_id))
+    end
+
+    # Whether +text+ would be a shell line (!<cmd>, !rollback) if a command:
+    # what a delegate's task or a schedule's prompt may not start with.
+    def shell_line?(text) = text.to_s.lstrip.start_with?(SHELL_PREFIX)
+
+    # Whether the command line +line+ from +client_id+ is a shell line that
+    # must not run.
+    def refused?(line, client_id) = shell_line?(line) && !allowed?(client_id)
+  end
+end

data/lib/samagotchi/compat.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rubygems/version"
+require_relative "version"
+
+module Samagotchi
+  # The compatibility decision for state and bridge data from a chi version.
+  module Compat
+    module_function
+
+    def verdict(worker_version:, version: VERSION, worker_protocol: nil, protocol: nil)
+      return :refused if protocol && worker_protocol.to_i > protocol
+
+      worker_version = worker_version.to_s
+      version = version.to_s
+      return :restart_suggested if worker_version.empty? || version.empty?
+      return :restart_suggested unless Gem::Version.correct?(worker_version) && Gem::Version.correct?(version)
+
+      worker = Gem::Version.new(worker_version)
+      current = Gem::Version.new(version)
+      return :restart_suggested if worker < previous_minor(current)
+
+      :ok
+    end
+
+    def previous_minor(version)
+      major, minor = version.segments.first(2)
+      Gem::Version.new("#{major}.#{[(minor || 0) - 1, 0].max}.0")
+    end
+    private_class_method :previous_minor
+  end
+end

data/lib/samagotchi/context_absorber.rb

@@ -59,17 +59,19 @@ module Samagotchi
     VERDICT = /\bVERDICT:?\s*([A-Z]+)(?![A-Za-z|])/
 
     # @param project_root [String, nil] Session#project_root
+    # @param project_id [String, nil] Session#project_id
     # @param peer_sources [PeerSources, nil] the peer bundles' declared sources
     # @param peer_turns [#call, nil] the peer wake turns in a row
     #   (WorkerWakes#peer_turns); 0 or nil: no source is a peer's
-    def initialize(session_id:, state_dir:, project_root:, peer_sources: nil, peer_turns: nil)
+    def initialize(session_id:, state_dir:, project_root:, project_id: nil, peer_sources: nil, peer_turns: nil)
       @session_id = session_id
       @peer_sources = peer_sources
       @peer_turns = peer_turns
       @state_dir = state_dir
       @own = ContextSources.session_location(session_id, state_dir: state_dir)
-      @project = ContextSources.project_location_for(project_root, state_dir: state_dir)
+      @project = ContextSources.project_location_for(project_root, project_id: project_id, state_dir: state_dir)
       @project_root = project_root
+      @project_id = project_id
       @signature = nil
     end
 
@@ -79,7 +81,8 @@ module Samagotchi
       return nil if signature == @signature
 
       subs = @own.subscriptions
-      visible = ContextSources.attached(@session_id, project_root: @project_root, state_dir: @state_dir)
+      visible = ContextSources.attached(@session_id, project_root: @project_root, project_id: @project_id,
+                                                  state_dir: @state_dir)
       deliveries = visible.filter_map do |attached|
         next if @own.muted?(attached.name)
 

data/lib/samagotchi/context_candidate_choice.rb

@@ -56,11 +56,12 @@ module Samagotchi
     # @param show_card [#call] (**card) → shows it; false/nil: it wasn't
     #   shown (the UI is on another session), so no carded line
     # @return [Symbol, nil] :attached, :carded or nil
-    def after_judged(job:, fields:, settings:, project_root:, state_dir:, log:, show_card:)
+    def after_judged(job:, fields:, settings:, project_root:, state_dir:, log:, show_card:, project_id: nil)
       return nil unless settings.mode == "on" && fields && fields["stated"]
       return nil unless %w[attach offer].include?(fields["would"])
 
-      candidate = proposed(job.session_id, job.name, project_root: project_root, state_dir: state_dir) or return nil
+      candidate = proposed(job.session_id, job.name, project_root: project_root, project_id: project_id,
+                                                     state_dir: state_dir) or return nil
       if fields["would"] == "attach"
         judge_attach(candidate, job: job, p: fields["p"], state_dir: state_dir, log: log, show_card: show_card)
       else
@@ -72,8 +73,9 @@ module Samagotchi
     end
 
     # The candidate +name+ when it is still proposed in the session.
-    def proposed(session_id, name, project_root:, state_dir:)
-      rows = ContextCandidates.with_status(session_id, project_root: project_root, state_dir: state_dir)
+    def proposed(session_id, name, project_root:, state_dir:, project_id: nil)
+      rows = ContextCandidates.with_status(session_id, project_root: project_root, project_id: project_id,
+                                                       state_dir: state_dir)
       rows.find { |candidate, status| candidate.name == name && status == "proposed" }&.first
     end
 
@@ -128,7 +130,8 @@ module Samagotchi
     end
 
     def find(session, name, state_dir:)
-      ContextCandidates.with_status(session.id, project_root: session.project_root, state_dir: state_dir)
+      ContextCandidates.with_status(session.id, project_root: session.project_root, project_id: session.project_id,
+                                                state_dir: state_dir)
                        .find { |candidate, _status| candidate.name == name }
     end
 

data/lib/samagotchi/context_candidates.rb

@@ -58,18 +58,19 @@ module Samagotchi
 
     # The session's candidates with their status, by name.
     # @return [Array<Array(ContextSources::Candidate, String)>]
-    def with_status(session_id, project_root:, state_dir: nil)
+    def with_status(session_id, project_root:, project_id: nil, state_dir: nil)
       own = ContextSources.session_location(session_id, state_dir: state_dir)
       candidates = own.candidates
       return [] if candidates.empty?
 
-      attached = ContextSources.attached(session_id, project_root: project_root, state_dir: state_dir, shadowed: true)
+      attached = ContextSources.attached(session_id, project_root: project_root, project_id: project_id, state_dir: state_dir,
+                                                     shadowed: true)
       candidates.map { |candidate| [candidate, status(candidate, own: own, attached: attached)] }
     end
 
     # The candidates section of /context, nil for none.
-    def listing(session_id, project_root:, state_dir: nil)
-      rows = with_status(session_id, project_root: project_root, state_dir: state_dir)
+    def listing(session_id, project_root:, project_id: nil, state_dir: nil)
+      rows = with_status(session_id, project_root: project_root, project_id: project_id, state_dir: state_dir)
       return nil if rows.empty?
 
       lines = rows.map { |candidate, state| "- #{candidate.name} · #{state} · #{candidate.title}" }
@@ -171,8 +172,8 @@ module Samagotchi
     end
 
     # The proposed candidates (no source of theirs attached, not declined).
-    def proposed(session_id, project_root:, state_dir: nil)
-      with_status(session_id, project_root: project_root, state_dir: state_dir)
+    def proposed(session_id, project_root:, project_id: nil, state_dir: nil)
+      with_status(session_id, project_root: project_root, project_id: project_id, state_dir: state_dir)
         .filter_map { |candidate, state| candidate if state == "proposed" }
     end
 
@@ -194,7 +195,8 @@ module Samagotchi
       # The earlier owner prompts too: a proposal that came while one ran
       # (a one-shot's plugins never see a running turn's prompt).
       texts = owner_texts(session.messages) + (prompt.is_a?(String) ? [prompt] : [])
-      found = hits(texts, proposed(session.id, project_root: session.project_root, state_dir: state_dir))
+      found = hits(texts, proposed(session.id, project_root: session.project_root, project_id: session.project_id,
+                                       state_dir: state_dir))
       names = found.filter_map { |hit| attach(hit, own: own, state_dir: state_dir) }
       first_fetch(own, unfetched(own, names), cwd: session.working_directory, seconds: seconds, cancelled: cancelled)
       names
@@ -213,7 +215,8 @@ module Samagotchi
       names = own.candidates.map(&:name)
       return 0 if names.empty?
 
-      absorber = ContextAbsorber.new(session_id: session.id, state_dir: state_dir, project_root: session.project_root)
+      absorber = ContextAbsorber.new(session_id: session.id, state_dir: state_dir, project_root: session.project_root,
+                                     project_id: session.project_id)
       batch = absorber.pending or return 0
       picked = batch.deliveries.select { |delivery| names.include?(delivery.name) }
       picked.each { |delivery| engine.add_context_note(session, delivery.note) if delivery.note }

data/lib/samagotchi/context_candidates_log.rb

@@ -65,7 +65,16 @@ module Samagotchi
     # its prompts. Never raises.
     # @return [Integer] how many lines were dropped
     def purge_session(session_id, state_dir: nil)
-      log_for(state_dir).prune { |line| line["session_id"] != session_id.to_s }
+      purge_sessions([session_id], state_dir: state_dir)
+    end
+
+    # Many sessions' lines, pruned in one pass through the log. Never raises.
+    # @return [Integer] how many lines were dropped
+    def purge_sessions(session_ids, state_dir: nil)
+      ids = Array(session_ids).map(&:to_s).reject(&:empty?).to_h { |id| [id, true] }
+      return 0 if ids.empty?
+
+      log_for(state_dir).prune { |line| !ids[line["session_id"]] }
     rescue StandardError => e
       Log.warn(:context, "context_candidates_log_failed", error: e.class.name, msg: e.message.to_s[0, 200])
       0

data/lib/samagotchi/context_command.rb

@@ -80,7 +80,12 @@ module Samagotchi
     # Where a command acts: a session (its own sources, then its project's)
     # or a project's sources. +label+ names it in the output, +cwd+ is
     # where its session's sources run (ContextPoller's choice).
-    Target = Data.define(:session_id, :project_root, :cwd, :label) do
+    # +project_id+ is the project's id (Session#project_id, a marked
+    # project's ProjectLookup#id): with +project_root+ it keys the project's
+    # sources (MemoryPaths.key_for).
+    Target = Data.define(:session_id, :project_root, :cwd, :label, :project_id) do
+      def initialize(session_id:, project_root:, cwd:, label:, project_id: nil) = super
+
       def project? = session_id.nil?
     end
 
@@ -234,7 +239,7 @@ module Samagotchi
         end
 
         @stdout.puts("#{target.label}  #{name}: #{pushed.revision == pushed.before ? "unchanged" : "new text"} " \
-                     "(#{pushed.revision[0, 12]})")
+                     "(#{pushed.revision[0, 12]})#{" · #{pushed.wake_line}" if pushed.wake_line}")
         true
       end
     end
@@ -421,14 +426,15 @@ module Samagotchi
       root = found.root
       # Its sources run in the root, or in this checkout when the root is a
       # git dir (ContextSources.project_cwd).
-      Target.new(session_id: nil, project_root: root, cwd: found.top || @cwd,
+      Target.new(session_id: nil, project_root: root, project_id: found.id, cwd: found.top || @cwd,
                  label: "project #{File.basename(root)}")
     end
 
     def session_target(given)
       id = @access.resolve_id(given)
       session = @access.show(id)
-      Target.new(session_id: id, project_root: session.project_root, cwd: session.working_directory, label: id[0, 8])
+      Target.new(session_id: id, project_root: session.project_root, project_id: session.project_id,
+                 cwd: session.working_directory, label: id[0, 8])
     rescue ArgumentError => e
       error_line("#{command_name}: #{e.message}")
       nil

data/lib/samagotchi/context_move.rb

@@ -70,13 +70,18 @@ module Samagotchi
         reserve = CARRY_MORE_TRUNCATION.bytesize
         text_limit = [CARRY_SOURCE_MAX_BYTES, remaining - heading.bytesize - reserve].min
         if text_limit < CARRY_SOURCE_TRUNCATION.bytesize
+          # Not even room for a trimmed source: this one is dropped, so the
+          # note says text is missing even when it was the last.
           truncated = true
           break
         end
 
         bounded, source_truncated = bound_source_text(text, text_limit)
         note << heading << bounded
-        if source_truncated
+        # Only a cut by the note's own budget ends the note: a source trimmed to
+        # CARRY_SOURCE_MAX_BYTES still leaves room for the next one, and one that
+        # fits the smaller room left is carried whole.
+        if source_truncated && text_limit < CARRY_SOURCE_MAX_BYTES
           truncated = more
           break
         end

data/lib/samagotchi/context_poller.rb

@@ -23,12 +23,14 @@ module Samagotchi
     TICK_SECONDS = 5
 
     # @param project_root [String, nil] Session#project_root
+    # @param project_id [String, nil] Session#project_id
     # @param cwd [String] the session's folder (a session source runs there)
     # @param on_change [#call] after a fetch brought a new text or failed
-    def initialize(session_id:, state_dir:, project_root:, cwd:, on_change:, tick: TICK_SECONDS)
+    def initialize(session_id:, state_dir:, project_root:, cwd:, on_change:, project_id: nil, tick: TICK_SECONDS)
       @session_id = session_id
       @state_dir = state_dir
       @project_root = project_root
+      @project_id = project_id
       @cwd = cwd
       @on_change = on_change
       @tick = tick
@@ -56,7 +58,8 @@ module Samagotchi
     # One pass (the thread's loop body; specs call it).
     # @param first [Boolean] the worker's first pass
     def poll(first: false)
-      ContextSources.attached(@session_id, project_root: @project_root, state_dir: @state_dir).each do |attached|
+      ContextSources.attached(@session_id, project_root: @project_root, project_id: @project_id,
+                                          state_dir: @state_dir).each do |attached|
         break if @stopping
         next if attached.source.push? || @own.muted?(attached.name)
 

data/lib/samagotchi/context_sources.rb

@@ -634,19 +634,21 @@ module Samagotchi
 
     # The project a session's sources come from: nil when it is in no repo.
     # @param project_root [String, nil] Session#project_root
-    def project_location_for(project_root, state_dir: nil)
+    # @param project_id [String, nil] Session#project_id (a marked project's
+    #   id keys its folder: MemoryPaths.key_for)
+    def project_location_for(project_root, project_id: nil, state_dir: nil)
       return nil if project_root.to_s.empty?
 
-      project_location(MemoryPaths.key_for_root(project_root), state_dir: state_dir)
+      project_location(MemoryPaths.key_for(root: project_root, id: project_id), state_dir: state_dir)
     end
 
     # A session's sources: its own, then the project's it doesn't shadow
     # (+shadowed+ lists those too, marked).
     # @return [Array<Attached>]
-    def attached(session_id, project_root:, state_dir: nil, shadowed: false)
+    def attached(session_id, project_root:, project_id: nil, state_dir: nil, shadowed: false)
       own = session_location(session_id, state_dir: state_dir)
       list = own.sources.map { |source| Attached.new(source: source, location: own, shadowed: false) }
-      project = project_location_for(project_root, state_dir: state_dir)
+      project = project_location_for(project_root, project_id: project_id, state_dir: state_dir)
       return list unless project
 
       names = list.map(&:name)

data/lib/samagotchi/engine/events.rb

@@ -51,6 +51,18 @@ module Samagotchi
         @session_observer.synchronize(&)
       end
 
+      def reserve_enqueued_id(id) = @turn_state.reserve_enqueued_id(id)
+
+      def claim_enqueued_id(id) = @turn_state.claim_enqueued_id(id)
+
+      def finish_enqueued_id(id) = @turn_state.finish_enqueued_id(id)
+
+      def forget_enqueued_id(id) = @turn_state.forget_enqueued_id(id)
+
+      def drop_enqueued_id(id) = @turn_state.drop_enqueued_id(id)
+
+      def enqueued_id?(id) = @turn_state.enqueued_id?(id)
+
       # The working set's :working_set_updated, announced between turns
       # (after a command changed what the next request sends), when it
       # differs from the last one emitted (#emit_working_set). Under the
@@ -79,8 +91,7 @@ module Samagotchi
           announce({ type: :guardrail_warning, message: message }) if message
           plugins = @plugin_failures.message
           announce({ type: :guardrail_warning, message: plugins, label: "plugins" }) if plugins
-          memory = MemoryOrphans.message
-          announce({ type: :guardrail_warning, message: memory, label: "memory" }) if memory
+          memory_load_warnings.each { |event| announce(event) }
           @extension_load.held_events.each do |event|
             announce(event[:type] == :card ? event.merge(in_turn: false) : event.merge(between_turns: true))
           end
@@ -88,6 +99,18 @@ module Samagotchi
         nil
       end
 
+      # The session-start memory warnings (label "memory"), for both load
+      # announcements (a worker's, a one-shot's first turn): an orphaned
+      # project memory folder (MemoryOrphans), a copied project sharing its
+      # id (ProjectIdClash, which also claims the id folder for this root).
+      # @return [Array<Hash>] the :guardrail_warning events
+      def memory_load_warnings
+        [MemoryOrphans.message, ProjectIdClash.check&.message].compact.map do |message|
+          { type: :guardrail_warning, message: message, label: "memory" }
+        end
+      end
+      private :memory_load_warnings
+
       # Run the block holding back the cards and between-turns notices it
       # announces on this thread, so the caller announces them after its own
       # event (a worker's command: its command_ran first, so a UI prints the

data/lib/samagotchi/engine/guardrails.rb

@@ -46,8 +46,8 @@ module Samagotchi
 
       # Once per Engine, on its first turn: what failed to load, so every UI
       # (the attached TUI, the web, a one-shot's stderr) shows it: the guardrails, then the plugins
-      # (label: "plugins"; the UIs say guardrails without one), an orphaned
-      # project memory folder (label: "memory"), then the notices and cards plugins showed as they loaded.
+      # (label: "plugins"; the UIs say guardrails without one), the memory
+      # warnings (label: "memory": #memory_load_warnings), then the notices and cards plugins showed as they loaded.
       def announce_guardrail_failures(on_event)
         return if @guardrail_failures_announced
 
@@ -56,8 +56,7 @@ module Samagotchi
         emit_event(on_event, { type: :guardrail_warning, message: message }) if message
         plugins = @plugin_failures.message
         emit_event(on_event, { type: :guardrail_warning, message: plugins, label: "plugins" }) if plugins
-        memory = MemoryOrphans.message
-        emit_event(on_event, { type: :guardrail_warning, message: memory, label: "memory" }) if memory
+        memory_load_warnings.each { |event| emit_event(on_event, event) }
         @extension_load.held_events.each { |event| emit_event(on_event, event) }
       end
       private :announce_guardrail_failures

data/lib/samagotchi/engine/plugins.rb

@@ -166,7 +166,7 @@ module Samagotchi
           end,
           state_dir: -> { session_state_dir },
           scratch: -> { @scratch },
-          setup: -> { SessionSetup.of(@session) },
+          setup: -> { SessionSetup.of(@session, forked: true) },
           # The files whose text the built system prompt holds; [] until a
           # build and after a rebuild that drops them (SystemPrompt#prompt_files
           # returns [] itself: the || keeps a nil builder safe).

data/lib/samagotchi/engine/steering.rb

@@ -126,8 +126,8 @@ module Samagotchi
       # Cancel the currently running turn, if any.
       # @param reason [Symbol] cancellation reason
       # @return [Boolean] whether a cancellation was triggered
-      def cancel_current_turn!(reason = :manual)
-        @turn_state.cancel!(reason)
+      def cancel_current_turn!(reason = :manual, turn_id: nil)
+        @turn_state.cancel!(reason, turn_id: turn_id)
       end
     end
   end

data/lib/samagotchi/engine.rb

@@ -83,6 +83,7 @@ require_relative "guardrails"
 require_relative "reminder_store"
 require_relative "reminder_queue"
 require_relative "memory_orphans"
+require_relative "project_id_clash"
 require_relative "tools/memory"
 require_relative "muted_memories"
 require_relative "used_memories"

data/lib/samagotchi/engine_peers.rb

@@ -17,6 +17,7 @@ module Samagotchi
       def session_id = engine.session&.id
       def cwd = engine.session&.working_directory
       def project_root = engine.session&.project_root
+      def project_id = engine.session&.project_id
       def state_dir = engine.peer_state_dir
       def cancelled? = !!engine.active_cancel_controller&.cancelled?
       def cancel_reason = engine.active_cancel_controller&.reason

data/lib/samagotchi/events.rb

@@ -22,6 +22,77 @@ module Samagotchi
     STREAM_FRAMES = %i[snapshot reset stream_closed].freeze
     SYNTHETIC = %i[merged_input].freeze
 
+    # The client-facing lifetime of each event. Rows are drawn in the
+    # conversation and survive reload; state updates the live UI; transient
+    # is live-only; internal is not sent to clients.
+    CLASSIFICATION = {
+      after_generation: :internal,
+      after_tool_call: :internal,
+      after_turn: :internal,
+      answer_display: :state,
+      before_generation: :internal,
+      before_tool_call: :internal,
+      before_turn: :internal,
+      card: :row,
+      command_queued: :state,
+      command_ran: :state,
+      context_added: :row, # Reloaded from the session messages, not a turn fold or card store.
+      context_status: :state,
+      continue_offered: :state,
+      continue_resolved: :state,
+      empty_answer_retry: :row,
+      generation_cancelled: :state,
+      generation_chunk: :transient,
+      generation_completed: :state,
+      generation_progress: :internal,
+      generation_retrying: :state, # Updates live retry status; a restart also removes invalidated chunks.
+      generation_started: :state,
+      guardrail_warning: :state, # Worker startup state; not a persistent conversation notice.
+      hook_notice: :row,
+      input_merged: :state,
+      llm_context_edited: :row,
+      merged_input: :row,
+      objectives_updated: :state,
+      participants_changed: :state,
+      pending_input_merged: :row,
+      plugin_init_finished: :state,
+      plugin_init_started: :state,
+      plugin_init_wait: :state,
+      prompt_restored: :state,
+      question_answered: :state,
+      question_cancelled: :state,
+      question_relay: :state,
+      question_requested: :state,
+      reasoning_history_refused: :internal,
+      recap_ready: :state,
+      reminder_injected: :row,
+      reset: :state,
+      sampling_refused: :internal,
+      session_end: :internal,
+      session_start: :internal,
+      side_usage: :state,
+      steer_cut: :row,
+      stream_closed: :state,
+      stream_resumed: :transient,
+      stream_retrying: :transient,
+      thinking_dropped: :transient,
+      thinking_refused: :internal,
+      tool_call_completed: :row,
+      tool_call_started: :row,
+      tool_dispatch_completed: :state,
+      tool_dispatch_started: :state,
+      turn_canceled: :row,
+      turn_completed: :row,
+      turn_dequeued: :state,
+      turn_enqueued: :state,
+      turn_failed: :row,
+      turn_started: :row,
+      used_memories_updated: :state,
+      verdict_recorded: :state,
+      worker_changed: :state,
+      working_set_updated: :state
+    }.freeze
+
     # Whether +event+ ends a turn that stays in the conversation: completed,
     # canceled, or failed with its work kept (turn_failed's kept_steps).
     def self.kept_turn?(event)