samagotchi 0.160.0 → 0.161.0

data/lib/samagotchi/broadcast_command.rb

@@ -249,13 +249,20 @@ module Samagotchi
     # +decisions+, prints a line per recipient and the summary, and logs it.
     def deliver_all(broadcast, decisions, cards)
       ok = true
+      # Two links of one chain are one session: the note goes once (Head).
+      got = {}
       lines = decisions.map do |d|
         next [d, "skipped", d.verdict.reason] unless d.deliver?
 
+        head = SessionInbox::Head.resolve(:note, d.recipient.id, state_dir: @state_dir)
+        next [d, "skipped", "#{head.id[0, 8]}, its chain's newest link, got it already"] if got[head.id]
+
         result = NoteDelivery.deliver(d.recipient.id, text: body(broadcast.text, d.verdict), source: SOURCE,
-                                                      state_dir: @state_dir)
+                                                      state_dir: @state_dir, resolved: head)
         next [d, "skipped", OwnerLock::TUI_BUSY] unless result.delivered?
 
+        got[result.id] = true
+
         [d, "delivered", "#{d.verdict.reason}#{"; waits for its next start" if result.status == :waits}"]
       rescue SessionInbox::NoteRejected, SystemCallError => e
         ok = false
@@ -333,7 +340,9 @@ module Samagotchi
         return 1
       end
       ids = sessions.map { |given| resolve_session(given) }
-      results = ids.compact.uniq.map { |id| deliver_anyway(record, id) }
+      # Two links of one chain are one session: the note goes once (Head).
+      results = ids.compact.map { |id| SessionInbox::Head.resolve(:note, id, state_dir: @state_dir) }
+                   .uniq(&:id).map { |head| deliver_anyway(record, head) }
       unless results.empty?
         begin
           @log.append_correction(id: record.id, at: @now, sessions: results)
@@ -359,22 +368,29 @@ module Samagotchi
       nil
     end
 
-    # @param id [String] a full session id (#resolve_session)
+    # @param head [SessionInbox::Resolved] the session named (+asked+, a full
+    #   id: #resolve_session) and the link that gets it (a continued one's
+    #   chain's newest)
     # @return [Broadcast::TriageLog::Delivery]
-    def deliver_anyway(record, id)
-      if record.delivered?(id)
+    def deliver_anyway(record, head)
+      id = head.asked
+      if record.delivered?(id) || record.delivered?(head.id)
         @stdout.puts(line_for(id, "skipped", "it got #{record.id} already"))
         return Broadcast::TriageLog::Delivery.new(session: id, result: "had it")
       end
 
-      result = NoteDelivery.deliver(id, text: passed_on_body(record), source: SOURCE, state_dir: @state_dir)
+      result = NoteDelivery.deliver(id, text: passed_on_body(record), source: SOURCE, state_dir: @state_dir,
+                                        resolved: head)
       unless result.delivered?
         @stdout.puts(line_for(id, "skipped", OwnerLock::TUI_BUSY))
         return Broadcast::TriageLog::Delivery.new(session: id, result: "refused")
       end
 
-      @stdout.puts(line_for(id, "delivered", "by hand#{"; waits for its next start" if result.status == :waits}"))
-      Broadcast::TriageLog::Delivery.new(session: id, result: "delivered")
+      how = "by hand#{"; to #{result.id[0, 8]}, its chain's newest link" if result.continued?}" \
+            "#{"; waits for its next start" if result.status == :waits}"
+      @stdout.puts(line_for(id, "delivered", how))
+      # Logged under the link that has it, so the next deliver finds it.
+      Broadcast::TriageLog::Delivery.new(session: result.id, result: "delivered")
     rescue SessionInbox::NoteRejected, SystemCallError => e
       @stdout.puts(line_for(id, "failed", e.message))
       Broadcast::TriageLog::Delivery.new(session: id, result: "failed")

data/lib/samagotchi/bundle_command.rb

@@ -2,6 +2,7 @@
 
 require_relative "cli/flags"
 require_relative "cli/exit"
+require_relative "live_versions"
 require_relative "memory_bundle"
 
 module Samagotchi
@@ -17,6 +18,7 @@ module Samagotchi
           Source is the path/URL to the bundle (dir/zip/tar.gz/git).
           --force overwrites existing entries (one that differs is copied to the trash first); default skips them.
           A bundle whose requires_chi this chi doesn't meet is refused; --force installs it anyway.
+          So is a memory, plugin or script whose bytes disagree with its manifest sha256; --force installs it too.
 
         upgrade <source|name> [--scope system|project] [--force] [--dry-run] [--agent|--no-agent]
           Upgrade a bundle (3-way: a file you didn't edit updates; one you edited takes a text
@@ -24,6 +26,7 @@ module Samagotchi
           A bare NAME upgrades the bundle installed under that name from the source it came from.
           --dry-run shows what would change. --agent launches interactive session on conflict.
           A bundle whose requires_chi this chi doesn't meet is refused; --force installs it anyway.
+          So is a file whose bytes disagree with its manifest sha256; --force installs it too.
 
         uninstall <bundle> [--scope system|project] [--force]
           Remove a bundle and its index entries (--force moves a locally edited file to the trash).
@@ -73,8 +76,8 @@ module Samagotchi
           Install a memory bundle from a directory, zip, tar archive, or git URL,
           or a bundle shipped with chi by name (see: chi bundle list).
           --force overwrites existing entries (one that differs is copied to the trash first); default skips them.
-          It also installs a bundle whose requires_chi this chi doesn't meet: without --force that install is
-          refused, and the bundle is not written anywhere.
+          It also installs a bundle whose requires_chi this chi doesn't meet and a file whose bytes disagree with
+          its manifest sha256: without --force both are refused, and the bundle is not written anywhere.
         install --dev PATH
           Install the bundle in the local directory PATH as a link to it: its plugin, rules and scripts
           are PATH's own files (an edit applies at the next worker or chi web restart, with no re-install) and
@@ -83,8 +86,9 @@ module Samagotchi
     TEXT
     UPGRADE_HELP = <<~TEXT
       Usage: chi bundle upgrade <source|name> [--scope system|project] [--force] [--dry-run] [--agent|--no-agent]
-        --force takes the bundle's file over an edited one, and installs a bundle whose requires_chi this chi
-        doesn't meet (without it such a bundle is refused).
+        --force takes the bundle's file over an edited one, installs a bundle whose requires_chi this chi
+        doesn't meet, and installs a file whose bytes disagree with its manifest sha256 (without it each is
+        refused, nothing written).
     TEXT
     UNINSTALL_HELP = "Usage: chi bundle uninstall <bundle> [--scope system|project] [--force]"
     BUILD_HELP = <<~TEXT
@@ -246,7 +250,12 @@ module Samagotchi
         end
       end
       installer = installer_for(expanded_source, bundle_name, prepared: prepared, scope: scope, force: force, upgrade: true, dry_run: dry_run)
-      run_installer(installer, failed: "Upgrade") do |manifest|
+      # The record and the manifest as they were/are, for the hint below: it
+      # reads which plugin the run touched.
+      before = Samagotchi::MemoryBundle::Provenance.new(name: bundle_name).record
+      manifest = nil
+      status = run_installer(installer, failed: "Upgrade") do |run_manifest|
+        manifest = run_manifest
         print_plugin(manifest, plugin: !dry_run)
         next dry_run_done if dry_run
 
@@ -256,6 +265,8 @@ module Samagotchi
 
         print_provenance(bundle_name, manifest)
       end
+      restart_hint(before, manifest, installer) if !dry_run && status != 1
+      status
     end
 
     # The source normalized once (a git clone, a zip or tar extract) and the
@@ -300,7 +311,10 @@ module Samagotchi
     end
 
     def installer_for(source, name, scope:, force:, **)
-      Samagotchi::MemoryBundle::Installer.new(source: source, name: name, scope: scope, force: force, strict: true, **)
+      # A bundle the user installs: a memory, plugin or script whose bytes
+      # disagree with its manifest sha is refused, not warned (--force past it).
+      Samagotchi::MemoryBundle::Installer.new(source: source, name: name, scope: scope, force: force, strict: true,
+                                              refuse_mismatch: true, **)
     end
 
     # Runs +installer+, prints its summary, then yields the manifest.
@@ -340,6 +354,41 @@ module Samagotchi
       0
     end
 
+    # A run wrote or took away a file (Installer#results' words).
+    CHANGED_WORDS = %i[installed updated merged removed restored].freeze
+
+    # Only a bundle's plugin stays in a worker's memory: its rules reload by
+    # their stamp (GuardrailWiring#rules_stamp), its scripts run from the files
+    # the install replaced, and chi no longer loads class-file hooks. So an
+    # upgrade or uninstall that changed the plugin -- or brought one in --
+    # leaves the old code in every session already up: one line, after the
+    # result, with how many sessions and the command for each. Nothing when the
+    # plugin is unchanged or there never was one, nothing with no worker that
+    # can be restarted.
+    # @param before [InstalledBundle, nil] the bundle's record as it was before
+    #   the run (an uninstall deletes it, so take it first)
+    # @param manifest [MemoryBundle::Manifest, nil] the manifest this run
+    #   installed; nil for an uninstall
+    # @param installer [Installer, nil] the run, for what it wrote to the plugin
+    def restart_hint(before, manifest = nil, installer = nil)
+      return if before.nil? || before.error?
+
+      plugin_files = [before.plugin&.file, manifest&.plugin&.dig(:file)].compact.uniq
+      changed = if installer
+                  plugin_files.any? { |file| CHANGED_WORDS.include?(installer.results[file]&.word) }
+                else
+                  !before.plugin.nil?
+                end
+      return unless changed
+
+      ids = Samagotchi::LiveVersions.workers.select(&:restart).map { |worker| worker.session_id.to_s[0, 8] }
+      return if ids.empty?
+
+      commands = ids.map { |id| "chi sessions restart #{id}" }
+      @stdout.puts "#{ids.size} session#{"s" unless ids.size == 1} " \
+                   "#{ids.size == 1 ? "runs" : "run"} the old code: #{commands.join(", ")}"
+    end
+
     # An upgrade that kept edited files: launch an agent to merge them
     # (--agent, or yes on a terminal), or say how to take the bundle's.
     # An upgrade that kept edited files exits 2, as a usage error does
@@ -427,6 +476,7 @@ module Samagotchi
         @stdout.puts uninstaller.trash_copy_line if uninstaller.trash_copy_line
         @stdout.puts "Removed: #{uninstaller.removed_files.join(", ")}" unless uninstaller.removed_files.empty?
         uninstaller.warnings.each { |w| @stdout.puts w }
+        restart_hint(record)
         0
       rescue Samagotchi::MemoryBundle::Uninstaller::UninstallError => e
         @stderr.puts "Uninstall failed: #{e.message}"; 1

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

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

@@ -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.

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_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

@@ -239,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

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/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

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/guardrails/child_boundary.rb

@@ -17,14 +17,20 @@ module Samagotchi
     # (a repo or rule answer would hold in every worktree, for every child),
     # when:
     #   write, edit: a path is outside root (Outside: tmp dirs and memory
-    #     files never are);
+    #     files never are); so is a path a plugin tool's targets: declare
+    #     the call writes (writes: true), the same declaration
+    #     ProtectedPaths reads — a call is judged by what its targets say it
+    #     acts on, not by its tool's name;
     #   execute, task_create: mutating git runs in a dir outside root
     #     (ShellGitDirs), or a command that isn't read-only starts outside
     #     root (its cwd:, else Dir.pwd) or names a path in the repository's
     #     other checkouts (the main one and sibling worktrees) or its
     #     common git dir; or it runs git that changes what all checkouts
     #     share, from anywhere (SharedGit: config, update-ref, worktree add,
-    #     stash clear, tags, another branch's delete).
+    #     stash clear, tags, another branch's delete). A plugin tool's
+    #     declared command: is checked for what chi can read for sure only:
+    #     SharedGit, and whether the call's cwd: is outside root (its text
+    #     may not be shell; Targets#rule_command).
     # Paths elsewhere in a command (/usr/bin, ~/.gem) don't count, and
     # read-only commands never ask, nor do ones that only write into a tmp
     # dir (> / >>, cp's destination, tee; Targets#read_only_but_tmp_writes?). Paths resolve under chi's env and the
@@ -67,12 +73,39 @@ module Samagotchi
 
       def crosses?(targets, root)
         case targets.tool
-        when "write", "edit" then targets.paths.any? { |path| Outside.outside?(path, root: root) }
+        when "write", "edit" then paths_cross?(targets, root)
         when *SHELL_TOOLS then shell_crosses?(targets, root)
-        else false
+        else
+          # chi's other own tools (read, memory_write, …) are unchanged:
+          # memory_write carries writes: for ProtectedPaths, but its paths
+          # are memory files (Outside exempts them) and its `..` entry names
+          # asked for nothing here before.
+          return false if Targets::CORE_TOOLS.include?(targets.tool)
+
+          plugin_crosses?(targets, root)
         end
       end
 
+      def paths_cross?(targets, root)
+        targets.paths.any? { |path| Outside.outside?(path, root: root) }
+      end
+
+      # A plugin tool, by what its targets: say it acts on (Targets#writes?,
+      # #command, #cwd), not by its name: paths its targets say it writes
+      # like a write's, and a declared command like a shell's — but for the
+      # command only what chi can read for sure: git that changes what every
+      # checkout shares (SharedGit), and where the call runs (its cwd:). A
+      # plugin's command text may not be shell (Targets#rule_command), so
+      # the shell half's git-dir, cd and redirect reads are left out; a
+      # plugin that wants more can bring a rule of its own.
+      def plugin_crosses?(targets, root)
+        return true if targets.writes? && paths_cross?(targets, root)
+        return :shared if targets.command && SharedGit.changes?(targets.command, own_branch: @branch.call)
+        return true if targets.command && targets.cwd && Outside.outside?(targets.cwd, root: root)
+
+        false
+      end
+
       def shell_crosses?(targets, root)
         return true if targets.git_dirs.any? { |dir| dir.is_a?(String) && Outside.outside?(dir, root: root) }
         return :shared if SharedGit.changes?(targets.command, own_branch: @branch.call)

data/lib/samagotchi/guardrails/protected_paths.rb

@@ -4,7 +4,8 @@ require_relative "path_resolve"
 
 module Samagotchi
   module Guardrails
-    # Core checks on what the file tools (write, edit, memory_write) touch,
+    # Core checks on what a call writes (Targets#writes?: write, edit,
+    # memory_write, and a plugin tool whose targets: say writes: true),
     # after the hooks and before the rules. Paths are compared with
     # symlinks resolved (on the longest existing parent, `..` taken
     # physically, a dangling symlink followed: PathResolve.reals, the
@@ -14,7 +15,8 @@ module Samagotchi
     #         hooks, rules, manifests), attached context (a source's
     #         command runs later, outside the gate; chi context writes
     #         it) and System 1's saved runs (a label there may train a
-    #         model); nothing legitimate writes there through the file tools.
+    #         model); nothing legitimate writes there through a tool
+    #         that says it writes.
     #   ask (once / session): config.yml, home.json (the chi home: the
     #         Ruby every chi launch boots), the chi shim (ChiShim: the
     #         `chi` every tool runs) and the plain hooks dir. The
@@ -24,7 +26,6 @@ module Samagotchi
     # execute can still write all of them (the guardrails bundle adds a
     # text match for that).
     class ProtectedPaths
-      FILE_TOOLS = %w[write edit memory_write].freeze
       SOURCE = "core"
 
       # @param store_dir [String] <state dir>/guardrails
@@ -50,10 +51,12 @@ module Samagotchi
         ].select { |_, root, _| root }
       end
 
-      # Vote on +verdict+ (its targets).
+      # Vote on +verdict+ (its targets): a call whose targets say it writes
+      # (Targets#writes?: write, edit, memory_write, or a plugin tool's
+      # targets: writes: true) is judged on its paths.
       def check(verdict)
         targets = verdict.targets
-        return verdict unless targets && FILE_TOOLS.include?(targets.tool)
+        return verdict unless targets&.writes?
 
         paths = targets.paths.flat_map { |p| PathResolve.reals(p) }
         @deny.each do |rule, root, reason|

data/lib/samagotchi/guardrails/targets.rb

@@ -90,6 +90,15 @@ module Samagotchi
       #   reads it)
       attr_reader :label
 
+      # @return [Boolean] whether the call writes the paths its targets name:
+      #   chi's own write, edit and memory_write, and a plugin tool whose
+      #   targets: say writes: true (a literal true only). The checks that
+      #   guard a write (ProtectedPaths, ChildBoundary) ask this rather than
+      #   the tool's name, so a plugin tool that acts like one is judged
+      #   like one.
+      attr_reader :writes
+      alias writes? writes
+
       # @return [Boolean] a memory_write call that removes a memory (remove:
       #   true), for a rule's memory: remove
       attr_reader :memory_remove
@@ -126,6 +135,7 @@ module Samagotchi
         args = nil
         acts_as = nil
         label = nil
+        writes = false
         env = {}
         case tool
         when *SHELL_TOOLS
@@ -134,14 +144,17 @@ module Samagotchi
           given = call[:cwd].to_s.strip
           cwd = File.expand_path(given, base) unless given.empty?
         when "write", "edit"
+          writes = true
           paths.concat(absolutes(call[:path], base))
         when "read"
           paths.concat(absolutes(call[:content], base))
         when "memory_write"
+          writes = true
           paths << memory_path(call, model_key)
         else
           given = plugin_targets(call, registry, surface)
           command = given[:command]
+          writes = given[:writes]
           given_cwd = given[:cwd].to_s.strip
           cwd = File.expand_path(given_cwd, base) unless given_cwd.empty?
           paths.concat(given[:paths].flat_map { |path| absolutes(path, cwd) })
@@ -154,25 +167,29 @@ module Samagotchi
         memory_overlay = tool == "memory_write" && !memory_remove && call[:current_model_only].to_s.strip.downcase == "true"
         memory = tool == "memory_write" ? memory_facts(call) : nil
         new(tool: tool, command: command, paths: paths.compact, cwd: cwd, env: env, repo_root: context.repo_root(cwd),
-            repo: context.repo(cwd), args: args, acts_as: acts_as, label: label, memory_remove: memory_remove,
+            repo: context.repo(cwd), args: args, acts_as: acts_as, label: label, writes: writes,
+            memory_remove: memory_remove,
             memory_overlay: memory_overlay, memory: memory,
             model_name: model_name, model_key: model_key, session_root: context.repo_root(base) || base,
             chi_dirs: -> { chi_dirs(context, base) })
       end
 
       # What a plugin tool's targets: callable says the call acts on:
-      # {command:, paths:, cwd:, acts_as:, args:, label:}, each optional; a callable
+      # {command:, paths:, writes:, cwd:, acts_as:, args:, label:}, each
+      # optional; a callable
       # that raises or gives something else counts as nothing (and is
       # logged). args: counts when it is a Hash; acts_as: is dropped (and
       # logged) when it names a core tool or another bundle's tool, so a
       # call can't pass for one and match (or reuse the approvals of) its
-      # rules. label: counts when it is one short line (.label_of). A
+      # rules. label: counts when it is one short line (.label_of). writes:
+      # counts only for a literal true: the tool says its paths are written,
+      # and the checks that guard write/edit judge them (.writes?). A
       # missing surface (Tools::MissingSurface) is raised, never taken as
       # nothing: call_tool's acts_as would go missing, and with it the
       # mcp_* rules on the call (fail-open).
       def self.plugin_targets(call, registry, surface = nil)
         entry = entry_of(call[:name], registry, surface)
-        none = { command: nil, paths: [], cwd: nil, acts_as: nil, args: nil, label: nil }
+        none = { command: nil, paths: [], writes: false, cwd: nil, acts_as: nil, args: nil, label: nil }
         return none unless entry && !entry.core? && entry.targets
 
         given = entry.targets_of(call, surface)
@@ -180,7 +197,8 @@ module Samagotchi
 
         given = given.transform_keys(&:to_sym)
         command = given[:command].to_s
-        { command: command.empty? ? nil : command, paths: Array(given[:paths]).map(&:to_s), cwd: given[:cwd],
+        { command: command.empty? ? nil : command, paths: Array(given[:paths]).map(&:to_s), writes: given[:writes] == true,
+          cwd: given[:cwd],
           acts_as: acts_as_of(given[:acts_as], entry, registry, surface), args: given[:args].is_a?(Hash) ? given[:args] : nil,
           label: label_of(given[:label], entry) }
       rescue Tools::MissingSurface
@@ -318,10 +336,11 @@ module Samagotchi
       # @param env [Hash{String=>String}] the call's env: (.env_of)
       def initialize(tool:, command:, paths:, cwd:, repo_root:, env: {}, repo: nil, args: nil, acts_as: nil,
                      label: nil, model_name: nil, model_key: nil, session_root: nil, chi_dirs: nil,
-                     memory_remove: false, memory_overlay: false, memory: nil)
+                     memory_remove: false, memory_overlay: false, memory: nil, writes: false)
         @env = env
         @acts_as = acts_as
         @label = label
+        @writes = writes
         @memory_remove = memory_remove
         @memory_overlay = memory_overlay
         @memory = memory

data/lib/samagotchi/live_versions.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "rubygems/version"
 require_relative "config"
 require_relative "session"
 require_relative "version"
@@ -38,9 +39,13 @@ module Samagotchi
       end
     end
 
-    # The live workers on another version than +version+ (unknown counts).
+    # The live workers older than the target chi (unknown versions count).
+    # Compat's N-1 verdict is for hints; these callers are adopting the new code.
     def stale_workers(version = VERSION, state_dir: Session.default_state_dir)
-      workers(state_dir: state_dir).reject { |w| w.version == version }
+      target = Gem::Version.new(version)
+      workers(state_dir: state_dir).select do |worker|
+        worker.version.nil? || !Gem::Version.correct?(worker.version) || Gem::Version.new(worker.version) < target
+      end
     end
 
     # The /api/info of a chi web on host:port, or nil when nothing (or not