samagotchi 0.85.0 → 0.86.0

data/lib/samagotchi/bundle_command/test_run.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Samagotchi
+  class BundleCommand
+    # `chi bundle test [PATH] [-- ARGS]`: a bundle's tests on the Ruby and
+    # the lib chi runs on (RbConfig.ruby, -I chi's lib), which an external
+    # bundle can't easily find itself (mise, rbenv, gem paths). test/**/
+    # *_test.rb runs on Minitest with the kit's Case; a spec/ with no test/
+    # on RSpec with the kit's helpers, as `rake bundles:specs` runs the
+    # shipped ones. Outside any Bundler env (Bundler.with_unbundled_env, as
+    # SessionManager's unbundled_env_changes): chi's gems don't include minitest.
+    # When the framework loads only inside the Bundler env chi itself runs in
+    # (a checkout or a vendored install: its gems in vendor/bundle), there.
+    # The tests' exit status is #run's.
+    class TestRun
+      LIB_DIR = File.expand_path("../..", __dir__)
+
+      def initialize(dir, args: [], stdout: $stdout, stderr: $stderr)
+        @dir = File.expand_path(dir)
+        @args = args
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      # @return [Integer] exit status
+      def run
+        tests = Dir.glob(File.join(@dir, "test", "**", "*_test.rb")).sort
+        return minitest(tests) if tests.any?
+        return rspec if File.directory?(File.join(@dir, "spec"))
+
+        @stderr.puts "chi bundle test: no test/*_test.rb or spec/ in #{@dir} (chi bundle new NAME writes a test to copy)"
+        CLI::Exit::FAILED
+      end
+
+      private
+
+      def minitest(tests)
+        return missing("minitest", "gem install minitest") unless loads?("minitest")
+
+        requires = tests.map { |file| "require #{file.inspect}" }.join("; ")
+        say("#{tests.size} test file#{"s" unless tests.size == 1}")
+        spawn(RbConfig.ruby, "-I", LIB_DIR, "-r", "minitest/autorun", "-r", "samagotchi/testing/minitest", "-e", requires,
+              "--", *@args)
+      end
+
+      def rspec
+        return missing("rspec", "gem install rspec") unless loads?("rspec/core")
+
+        say("spec/ on RSpec")
+        spawn(RbConfig.ruby, "-I", LIB_DIR, "-r", "rspec/core", "-e", "exit RSpec::Core::Runner.run(ARGV)", "--",
+              "--options", File::NULL, "-r", "samagotchi/testing/rspec", "spec", *@args)
+      end
+
+      def say(what) = @stdout.puts("chi bundle test: #{what} on #{RbConfig.ruby} (chi's lib #{LIB_DIR})")
+
+      def missing(lib, hint)
+        @stderr.puts "chi bundle test: #{lib} doesn't load on chi's Ruby (#{RbConfig.ruby}); #{hint}"
+        CLI::Exit::USAGE
+      end
+
+      # Whether +lib+ loads unbundled, else in chi's own Bundler env (then
+      # #spawn stays in it).
+      def loads?(lib)
+        check = -> { system(RbConfig.ruby, "-e", "require #{lib.inspect}", out: File::NULL, err: File::NULL) }
+        @bundled = false
+        return true if unbundled(&check)
+
+        @bundled = bundler?
+        @bundled && check.call
+      end
+
+      def spawn(*command)
+        @stdout.flush
+        run = -> { system(*command, chdir: @dir) }
+        @bundled ? run.call : unbundled(&run)
+        $?.exitstatus || CLI::Exit::FAILED
+      end
+
+      def unbundled(&)
+        bundler? ? ::Bundler.with_unbundled_env(&) : yield
+      end
+
+      # Bundler may be defined without its runtime (RubyGems' own stub).
+      def bundler? = defined?(::Bundler) && ::Bundler.respond_to?(:with_unbundled_env)
+    end
+  end
+end

data/lib/samagotchi/bundle_command.rb

@@ -10,7 +10,7 @@ module Samagotchi
   # subcommands have their own flags).
   class BundleCommand
     USAGE = <<~TEXT
-      Usage: chi bundle <install|upgrade|uninstall|status|diff|list|build|trash> [options]
+      Usage: chi bundle <install|upgrade|uninstall|status|diff|list|build|trash|new|test|check> [options]
 
         install <source> [--scope system|project] [--force]
           Install a memory bundle from a directory, zip, tar archive, or git URL.
@@ -42,6 +42,16 @@ module Samagotchi
         trash [--empty] [--dry-run] [--older-than DAYS]
           List bundle trash (moved files from uninstalls/upgrades).
           --empty deletes all trash folders. --older-than DAYS keeps only recent ones.
+
+        new NAME [--dir DIR]
+          Start a bundle in DIR/NAME (default ./NAME): manifest, plugin, a passing test, README.
+
+        test [PATH] [-- ARGS]
+          Run a bundle's test/*_test.rb (Minitest) or spec/ (RSpec) on chi's Ruby and lib.
+
+        check [PATH] [--fix] [--set KEY=VALUE]
+          Check a bundle you're writing (default: the current dir): manifest, files, sha256 lines,
+          requires_chi, and an install + load in a sandbox. --fix rewrites stale sha256 lines.
     TEXT
 
     # Each subcommand's --help (and only --help: -h and help are taken as
@@ -71,6 +81,33 @@ module Samagotchi
           chi bundle build --scope system --out ./my-bundle/ identity.md work.md
     TEXT
     TRASH_HELP = "Usage: chi bundle trash [--empty] [--dry-run] [--older-than DAYS]"
+    NEW_HELP = <<~TEXT
+      Usage: chi bundle new NAME [--dir DIR]
+
+        Start a bundle in DIR/NAME (default ./NAME; refused when it exists): manifest.yml (shas filled,
+        requires_chi this chi), plugin.rb (a /NAME command and an after_tool_call hook), test/NAME_test.rb
+        (passes as written) and README.md. Then: chi bundle test, chi bundle check, chi bundle install.
+    TEXT
+    TEST_HELP = <<~TEXT
+      Usage: chi bundle test [PATH] [-- ARGS]
+
+        Run the tests of the bundle at PATH (default: .) on the Ruby and the lib chi runs on, outside any Bundler env:
+        test/**/*_test.rb on Minitest (require "samagotchi/testing/minitest"), or else spec/ on RSpec with the kit
+        (-r samagotchi/testing/rspec). ARGS go to the test runner (-- -n /name/, -- -e "a name").
+        The tests run the bundle's code as written, with your HOME (the kit's sandbox is per test): run code you'd install.
+        Exit status: the tests'; 1 no tests; 2 usage, or minitest / rspec doesn't load.
+    TEXT
+    CHECK_HELP = <<~TEXT
+      Usage: chi bundle check [PATH] [--fix] [--set KEY=VALUE]
+
+        Check the bundle at PATH (default: .) as an install would take it, one finding per line:
+          error|warn|info CODE file[:line]: message (fix: hint)
+        It installs and loads the bundle in a sandbox (temp HOME, config and state), not in yours, but its plugin and
+        hooks run in this process as written: run it on code you'd install.
+        --fix            rewrite stale and placeholder sha256 lines in manifest.yml
+        --set KEY=VALUE  a setting for the load (config.yml bundles: <name>: KEY), repeatable
+        Exit status: 0 no errors, 1 errors, 2 usage.
+    TEXT
 
     # The subcommands' flags: --help only; a word not starting with -- is
     # a positional (install's source, -h included). --scope takes whatever
@@ -90,6 +127,14 @@ module Samagotchi
     BUILD_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/, dash_values: false) do |f|
       %w[--scope --name --version --description --out].each { |name| f.value name }
     end
+    NEW_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
+      f.value "--dir"
+    end
+    TEST_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A-/)
+    CHECK_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
+      f.switch "--fix"
+      f.value "--set", key: :set, repeat: true
+    end
     TRASH_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
       f.switch "--empty"
       f.switch "--dry-run"
@@ -121,8 +166,11 @@ module Samagotchi
       when "list" then list
       when "build" then build(@argv[1..])
       when "trash" then trash(@argv[1..])
+      when "new" then new_bundle(@argv[1..])
+      when "test" then test_bundle(@argv[1..])
+      when "check" then check(@argv[1..])
       else
-        @stderr.puts "Unknown bundle subcommand: #{sub}. Use: install, upgrade, uninstall, status, diff, list, build, trash"
+        @stderr.puts "Unknown bundle subcommand: #{sub}. Use: install, upgrade, uninstall, status, diff, list, build, trash, new, test, check"
         CLI::Exit::USAGE
       end
     end
@@ -749,6 +797,81 @@ module Samagotchi
       end
     end
 
+    def new_bundle(rest)
+      parsed = parse_flags(NEW_FLAGS, rest, "new", help: NEW_HELP)
+      return parsed if parsed.is_a?(Integer)
+
+      unless parsed.args.size == 1
+        @stderr.puts NEW_HELP.lines.first
+        return CLI::Exit::USAGE
+      end
+      require_relative "bundle_command/scaffold"
+      scaffold = Scaffold.new(parsed.args.first, parent: parsed.options.fetch(:dir, "."))
+      begin
+        written = scaffold.write
+      rescue ArgumentError => e
+        @stderr.puts "chi bundle new: #{e.message}"
+        return CLI::Exit::FAILED
+      end
+      shown = scaffold.dir.start_with?("#{Dir.pwd}/") ? scaffold.dir.delete_prefix("#{Dir.pwd}/") : scaffold.dir
+      @stdout.puts "Created #{shown}/: #{written.join(", ")}"
+      @stdout.puts <<~TEXT
+        Next: cd #{shown}, edit plugin.rb and the test, then
+          chi bundle test           its tests, on chi's Ruby and lib
+          chi bundle check --fix    shas, requires_chi, an install and load in a sandbox
+          chi bundle install .      then a new session loads it
+      TEXT
+      CLI::Exit::OK
+    end
+
+    # ARGS after "--" go to the test runner untouched.
+    def test_bundle(rest)
+      split = rest.index("--")
+      own, args = split ? [rest[0...split], rest[(split + 1)..]] : [rest, []]
+      parsed = parse_flags(TEST_FLAGS, own, "test", help: TEST_HELP)
+      return parsed if parsed.is_a?(Integer)
+
+      dir = parsed.args.first || "."
+      unless parsed.args.size <= 1 && File.directory?(dir)
+        @stderr.puts parsed.args.size > 1 ? TEST_HELP.lines.first : "chi bundle test: #{dir} isn't a folder"
+        return CLI::Exit::USAGE
+      end
+      require_relative "bundle_command/test_run"
+      TestRun.new(dir, args: args, stdout: @stdout, stderr: @stderr).run
+    end
+
+    def check(rest)
+      parsed = parse_flags(CHECK_FLAGS, rest, "check", help: CHECK_HELP)
+      return parsed if parsed.is_a?(Integer)
+
+      settings = check_settings(parsed.options.fetch(:set, [])) or return CLI::Exit::USAGE
+      if parsed.args.size > 1
+        @stderr.puts "chi bundle check takes one PATH (#{parsed.args.join(" ")})"
+        return CLI::Exit::USAGE
+      end
+      dir = parsed.args.first || "."
+      unless File.directory?(dir)
+        @stderr.puts "chi bundle check: #{dir} isn't a folder"
+        return CLI::Exit::USAGE
+      end
+      require_relative "bundle_command/check"
+      Check.new(dir, fix: parsed.options.fetch(:fix, false), settings: settings, stdout: @stdout).run
+    end
+
+    # --set KEY=VALUE values as typed (BundleSessionSettings.typed), or nil
+    # after saying what's wrong.
+    def check_settings(pairs)
+      require_relative "bundle_session_settings"
+      pairs.each_with_object({}) do |pair, out|
+        key, sep, value = pair.partition("=")
+        unless !sep.empty? && key.match?(BundleSessionSettings::KEY)
+          @stderr.puts "chi bundle check: --set takes KEY=VALUE, not #{pair}"
+          return nil
+        end
+        out[key] = BundleSessionSettings.typed(value)
+      end
+    end
+
     # +rest+ through +flags+, stopping at the first --help or error.
     #
     # @return [CLI::Flags::Result, Integer] the result, or the exit status

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

@@ -1,11 +1,11 @@
 ---
 name: core
-version: 0.3.2
+version: 0.3.3
 scope: system
 description: "Recommended safety set"
 trust_level: reviewed
 # Its members' highest floor (cost-cap's)
-requires_chi: ">= 0.83.0"
+requires_chi: ">= 0.86.0"
 includes:
 - loop-guard
 - check-in

data/lib/samagotchi/bundles/cost-cap/manifest.yml

@@ -1,13 +1,13 @@
 ---
 name: cost-cap
-version: 0.1.1
+version: 0.2.0
 scope: system
 description: "A per-session $ cap: at the cap the turn pauses on Continue (another cap's worth) / Stop, a warning at 80% goes to the user only; /cap shows or sets it"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:2ea7f76af1ea1c1b0a9a8b0b4b11d6e85a4a816fae224ef5b220cfd20fb48f42
-# ctx.cost is new in chi 0.83.0
-requires_chi: ">= 0.83.0"
+  sha256: sha256:21308746c9cfa3e135909d74e1668ccfc659ea120b3fb41b1ee6a3ce386d8b45
+# ctx.cost is new in chi 0.83.0; ask_user's effects: in the next chi
+requires_chi: ">= 0.86.0"
 # chi --set cost-cap.cap=3: a session's own cap (ctx.settings["cap"])
 session_settings: [cap]

data/lib/samagotchi/bundles/cost-cap/plugin.rb

@@ -28,6 +28,9 @@ require "fileutils"
 class Plugin
   USAGE = "usage: /cap [N | $N | off] (USD; /cap alone shows the spend)"
   OPTIONS = %w[Continue Stop].freeze
+  # For a parent agent's answer (guardrails.parent_answers): Continue
+  # spends more, Stop denies; under hard a parent may only Stop.
+  EFFECTS = { "Continue" => :spend, "Stop" => :deny }.freeze
   WARN_AT = 0.8
 
   def initialize(_settings)
@@ -103,7 +106,7 @@ class Plugin
     raised = raised_cap(cap, resolved[:step] || cap, cost.total)
     answer = ctx.ask_user(question: "Cost cap reached: #{money(cost.total)} spent of #{money(cap)}. " \
                                     "Continue raises it to #{money(raised)}.",
-                          header: "Cost cap", options: OPTIONS)
+                          header: "Cost cap", options: OPTIONS, effects: EFFECTS)
     if continue?(answer)
       save(ctx, resolved[:session], "cap" => raised, "step" => resolved[:step] || cap)
       ctx.notify("cap raised to #{money(raised)}")

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

@@ -1,6 +1,6 @@
 ---
 name: dev
-version: 0.5.1
+version: 0.6.0
 scope: system
 description: "Developer tools"
 trust_level: reviewed
@@ -15,3 +15,4 @@ includes:
 - coordinator
 - claude-peer
 - codex-peer
+- ruby

data/lib/samagotchi/bundles/guardrails/guardrails/rules.yml

@@ -174,8 +174,10 @@ rules:
     reason: shares a note with every session it may concern; chi broadcast is for the user, not an agent
 
   # ── answering chi's own questions around chi answer ───────────────────
-  # A parent agent answers a child's approval with chi answer, which holds it
-  # to guardrails.parent_approvals. These shapes go around that: chi --attach
+  # A parent agent answers a child's question with chi answer, which holds it
+  # to the option effects a parent may pick. These shapes go around that,
+  # answering as the user, so only the user may allow them (core's
+  # PROTECTED_RULES, never a parent agent): chi --attach
   # or chi -p with stdin from a pipe, a here-string or a file other than
   # /dev/null (a chi after 0.12 treats those as a parent too, but an older
   # child doesn't), and a POST to the Bridge's or the web's answer route.

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

@@ -1,6 +1,6 @@
 ---
 name: guardrails
-version: 0.9.1
+version: 0.9.2
 scope: system
 description: Optional default guardrail rules (git push/rewrites, rm -rf wide, curl | sh, git hooks, chi's own config and attached context from the shell, chi context add --cmd, chi broadcast, answering chi around chi answer, removing a memory, writing a memory that reaches the system prompt (identity, model notes) or a model overlay; in strict mode also git rebase and writes and git in another checkout outside the session's repo), asks only small models get (git checkout --/restore, git stash drop), and a note for the model
 trust_level: reviewed

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

@@ -0,0 +1,11 @@
+---
+name: ruby
+version: 0.1.0
+scope: system
+description: "An RSpec run with no examples at all (`0 examples, 0 failures`) steers a hint into the turn: check the path, the filter (-e/--tag) or the .rspec --pattern"
+trust_level: reviewed
+plugin:
+  file: plugin.rb
+  sha256: sha256:f088ae539b1a0c46b35823fb69be42524ce8eac34e185b20ffef7e05d62dbd5f
+# after_tool_call's result: (0.57.0)
+requires_chi: ">= 0.57.0"

data/lib/samagotchi/bundles/ruby/plugin.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# The ruby bundle (docs/plugins.md, The ruby bundle): an `execute` that ran
+# RSpec and got no examples at all steers a hint into the running turn.
+#
+# RSpec prints `0 examples, 0 failures` for a run whose path matched no
+# file, whose filter (-e, --tag) matched no example, or whose .rspec
+# --pattern hid the specs (a nested project's .rspec overrides one). The
+# summary reads green, so the model takes the suite as passing and moves on
+# with code no test ever loaded. after_tool_call checks the run: the command
+# runs rspec, and every summary line in its output counted 0 examples.
+#
+# The command: one of its simple commands (split at &&, ||, ;, | and a
+# newline, so after a leading `cd x &&` too) starts with `rspec`,
+# `bin/rspec` (any path ending in /rspec) or `parallel_rspec`, once leading
+# X=… assignments, `bundle exec` and `time` are left out. A program that
+# only names rspec (`grep rspec README`, `echo "bundle exec rspec"`) is not
+# a run. Only `execute` results count.
+#
+# The output: every `<N> examples, <M> failures` line (RSpec's summary,
+# `0 examples, 0 failures` or `, 3 pending` after it) counts, and the hint
+# comes when all of them are 0: parallel_rspec prints one per process, so a
+# single process with examples leaves its 0 out of the total. An output with
+# no summary line (a spec that fails to load, a missing path, a killed run)
+# says what is wrong already: the hint doesn't repeat it.
+#
+# The hint is a steer: its own user message in the conversation at the
+# loop's next boundary, shown as `ruby> nudged: …`, dropped (logged) if the
+# model answers first. Nothing is remembered, so the next 0-example run
+# hints again: a different command, and it may be the same mistake.
+class Plugin
+  HINT = "rspec ran 0 examples: check the path, the filter (-e/--tag) or the .rspec --pattern"
+  PROGRAMS = %w[rspec parallel_rspec].freeze
+  SUMMARY = /\b(\d+) examples?, (\d+) failures?\b/
+  # Where a simple command ends: the next one runs its own program.
+  SEGMENTS = /&&|\|\||[;|\n]/
+  ASSIGNMENT = /\A[A-Za-z_][A-Za-z0-9_]*=/
+
+  def register(chi)
+    chi.on(:after_tool_call) { |event, ctx| after(event, ctx) }
+  end
+
+  def after(event, ctx)
+    return unless event[:tool].to_s == "execute"
+    return unless self.class.zero_examples?(event[:result])
+
+    call = event[:call]
+    return unless call.is_a?(Hash) && self.class.rspec?(call[:content])
+
+    ctx.steer(HINT)
+  end
+
+  # Whether one of +command+'s simple commands runs rspec.
+  def self.rspec?(command)
+    command.to_s.split(SEGMENTS).any? { |segment| PROGRAMS.include?(File.basename(program(segment))) }
+  end
+
+  # The program a simple command starts: leading X=… assignments, `bundle
+  # exec` and `time` left out ("" for none).
+  def self.program(segment)
+    words = segment.split(/\s+/).reject(&:empty?)
+    words.shift while words.first&.match?(ASSIGNMENT)
+    words.shift(2) if words[0] == "bundle" && words[1] == "exec"
+    words.shift if words.first == "time"
+    words.first.to_s
+  end
+
+  # Whether the output has summary lines and every one of them counts 0
+  # examples.
+  def self.zero_examples?(output)
+    counts = output.to_s.scan(SUMMARY).map { |examples, _failures| examples.to_i }
+    !counts.empty? && counts.all?(&:zero?)
+  end
+end

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

@@ -60,7 +60,7 @@ Only the nested form is read. An env name used as a top-level key (`SAMAGOTCHI_D
 - `hosts:` map of `name → {host, port | url, transport, api, api_key_env, auth, dialect, profile, first_token_timeout, vision, sampling, thinking, enabled, models}` (`ConfigFile.hosts_config`, `host_registry.rb` `HostEntry`). Names lowercased; `url:` (http/https, optional path) replaces host/port, never both; `api_key_env:` names the env var holding the API key (never write a key into config.yml); `auth:` (`bearer|x-api-key`) is the header the key goes in (default `x-api-key` on `api: anthropic`, Bearer elsewhere); `dialect:` (`fireworks`, or `standard` for the default; `api: anthropic` only) adjusts the Messages wire for that provider (Bearer by default, no thinking `display`, no `cache_control`, `x-session-affinity`; `LLM::Dialect`, docs/configuration.md "Anthropic Messages hosts"); `transport` overrides `server.transport`; `first_token_timeout` (seconds, `0` = off; a negative or non-number warns and is ignored) overrides `server.first_token_timeout` for that host; `models:` (a map of model ids, or a plain list) declares ids the host serves whatever its `/v1/models` lists: no "doesn't list" warning, and a bare id routes there as if listed (`HostModel`); an entry may hold `price: {input, output, cache_read?, cache_write?}` in USD per 1M tokens (`ModelPrice`; an unset cache rate is the input rate), which estimates a cost the provider doesn't report or reports as 0 (`cost_estimate`, shown as `~$`), and `served: [ids] | any`, the models a gateway may answer that id with (no served-model warning for them); model settings stay in the root `models:`; a worker reads `hosts:` from the file as it starts (no environment variable sets hosts).
 - `models:` map of model id or alias → `{profile, vision, sampling, thinking, reasoning_history}` (`ConfigFile.model_settings`). `thinking:` (here, on a host, or `thinking.level` for every model) is `off|low|medium|high|default` (`Thinking`; unquoted `off` works, `on` is not a level; `default` = send nothing). Precedence: the session's own level (`/thinking LEVEL`, saved in the session; `chi --thinking` on a session run, `chi send --new --thinking`) > `chi web --thinking`/`SAMAGOTCHI_THINKING_LEVEL` > `models:` > `hosts.<name>.thinking` > `thinking.level` in config.yml > `default`. A `sampling:` key wins over the fields a level sends (`null` drops one); `docs/configuration.md` "Thinking". `reasoning_history:` (here or on a host) is `drop|turn|all`, which of its reasoning a chat host's model gets back. Precedence: the session's own level (`/reasoning-history LEVEL`, saved in the session) > `SAMAGOTCHI_REASONING_HISTORY` > `models:` > `hosts.<name>.reasoning_history` > `turn`; `docs/configuration.md` "Reasoning history". `/thinking` and `/reasoning-history` ask before a change that restarts the prompt cache; `--yes` applies it (`chi send` commands apply directly). `sampling:` (here or on a host) is a map of request fields passed to the provider as written (`temperature`, `top_p`, `presence_penalty`, `repeat_penalty`, …; a model's fields win over its host's per field; `null` = don't send; chi's own fields like `max_tokens`/`stream` are refused with a warning; `docs/configuration.md` "Sampling"). Keys match case-insensitively. `profile` (here or on a host) is `qwen36|gemma4`: the raw prompt format for native hosts. Precedence: `--profile`/`SAMAGOTCHI_MODEL_PROFILE` > `models:` > `hosts.<name>.profile` > the llama.cpp server's chat template > the name (`qwen`/`gemma`) > `qwen36` (`ModelProfile.resolve`). Set one when a model's name hides its family (e.g. a Qwen fine-tune under another name on mlx, which has no template to read).
 - `hooks:` map of `hooks_dir` + per-event lists `{path, on_error}` (`Hooks::Loader.load`). `hooks_dir` may start with `~`.
-- `guardrails:` tool-call rules (`docs/guardrails.md`; read in `Engine#guardrail_rules`, parsed by `Guardrails::Rules.parse`): `enabled` (bool, default true; `false` drops rules and hooks' asks, a deny still applies; config.yml only, like every `guardrails` setting: no env variable), `parent_approvals` (`off`, the default: a parent agent's `chi answer` can only deny an approval; `once`: it may give "Allow once" too; a convention for an honest parent, not a security boundary, and the user's choice: set it only when the user asks), `rules:` (list), `disable:` (a rule id or a list of them, `id` or `bundle:id`, switching off a bundle's or config rule without editing it), `small_models` (`auto`, the default: small = 32B or less read from the name; a glob or list of globs; `[]` for none). A rule takes only `id`, `tool`, `command`, `path`, `git`, `models`, `verdict`, `reason`, `scopes`: `id` required; at least one of `tool` (a name, `shell` = execute + task_create, a `File.fnmatch` glob like `"mcp_*"`, or a list), `command` (a Ruby regex on the shell command), `path` (a glob, or `outside_repo`: outside the session's repo, tmp folders and memory files excepted), `git` (only `outside_repo`: a shell call runs commit/add/reset/… in another checkout); `models` (optional: `small`, a model-name glob, or a list; without it the rule is for every model); `verdict` `ask|deny`; `scopes` (for `ask`) a subset of `once, session, repo, rule`. **Any parse error (an unknown key, a bad regex, no verdict) makes chi deny every tool call** until fixed, so validate with `YAML.safe_load` and keep the list shape. Rules are read again on the next tool call after config.yml or a bundle's rules change: no restart needed. Installed bundles' rule files (`chi bundle install guardrails`) add to them; `/guardrails` lists what loaded.
+- `guardrails:` tool-call rules (`docs/guardrails.md`; read in `Engine#guardrail_rules`, parsed by `Guardrails::Rules.parse`): `enabled` (bool, default true; `false` drops rules and hooks' asks, a deny still applies; config.yml only, like every `guardrails` setting: no env variable), `parent_answers` (`soft`, the default: a parent agent's `chi answer` may deny, answer, Continue and give "Allow once"; `standard`: no allow; `hard`: deny, Stop and plain answers only; never a wider scope; replaces `parent_approvals` and `turn.parent_continue`; a convention for an honest parent, not a security boundary, and the user's choice: set it only when the user asks), `rules:` (list), `disable:` (a rule id or a list of them, `id` or `bundle:id`, switching off a bundle's or config rule without editing it), `small_models` (`auto`, the default: small = 32B or less read from the name; a glob or list of globs; `[]` for none). A rule takes only `id`, `tool`, `command`, `path`, `git`, `models`, `verdict`, `reason`, `scopes`: `id` required; at least one of `tool` (a name, `shell` = execute + task_create, a `File.fnmatch` glob like `"mcp_*"`, or a list), `command` (a Ruby regex on the shell command), `path` (a glob, or `outside_repo`: outside the session's repo, tmp folders and memory files excepted), `git` (only `outside_repo`: a shell call runs commit/add/reset/… in another checkout); `models` (optional: `small`, a model-name glob, or a list; without it the rule is for every model); `verdict` `ask|deny`; `scopes` (for `ask`) a subset of `once, session, repo, rule`. **Any parse error (an unknown key, a bad regex, no verdict) makes chi deny every tool call** until fixed, so validate with `YAML.safe_load` and keep the list shape. Rules are read again on the next tool call after config.yml or a bundle's rules change: no restart needed. Installed bundles' rule files (`chi bundle install guardrails`) add to them; `/guardrails` lists what loaded.
 
 ```yaml
 guardrails:

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.85.0
+version: 0.86.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
-  self_map.md: sha256:4ff5708e51f55089de47b107643ae0b74aee04cb96111226823a8d44fb4bc33d
-  config_modification_protocol.md: sha256:66792f788cdbb8ee0252f2c387c96bd75266817bb75f721aaa181b602db97137
+  self_map.md: sha256:be1b601c550e22730416913eeb0bd47a097e37f3c6743bda709ee495467547a5
+  config_modification_protocol.md: sha256:f2551c71a21cc42e8b888e4b9b41f4b0909224e5393731905c1f786c704bad14
   memory_guide.md: sha256:c48eea744db69e4f3e9bb415e9a03a8c78bbcaa1205ad3b1fb157a079f92d22e
   delegated.md: sha256:a0d6ddcd4a8be06526d964898611775fd251cfd9d145a9d16afaccaa503597bd

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

@@ -58,7 +58,8 @@
   keeps older versions of `skill_*` memories). `chi bundle list`
   shows installed + available; `chi bundle install <name>`. Settings: config.yml `bundles: <name>:`
   (`config_modification_protocol`), read at session start: after an install or a settings change,
-  tell the user to restart the session. API and bundle docs: `docs/plugins.md`.
+  tell the user to restart the session. API and bundle docs: `docs/plugins.md`. Writing one: read
+  `docs/bundle-authoring.md` in my source dir first.
 
 ## Where things live (relative to the source dir)
 - `docs/`: `cli.md` (flags, subcommands, REPL commands), `configuration.md` (config.yml keys,

data/lib/samagotchi/client_id.rb

@@ -13,7 +13,7 @@ module Samagotchi
     TUI_PREFIX = "tui:"
     # chi send's turns and commands.
     CLI_SEND = "cli:send"
-    # chi answer's answers (a parent agent's, Guardrails::ParentApprovals).
+    # chi answer's answers (a parent agent's, Guardrails::ParentPolicy).
     CLI_ANSWER = "cli:answer"
     # chi restart.
     CLI_RESTART = "cli:restart"