samagotchi 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4db526cc3c79a4e5aa8061f124ff09e65e289415074fcb51c71c25ccee1ab0c9
-  data.tar.gz: c30c2094cb357df9fe4e5618956e0c1a559ea0a2765709605488d03c5febbb87
+  metadata.gz: 80a8fec85f3a253ce7f762f3c8881ee0c49d6e73117f205a53cb64482e7a9cc3
+  data.tar.gz: 6e21caec0f46b5a2831382a2c77842e5d3935e363b6b6ea96f5d136a24ffa1eb
 SHA512:
-  metadata.gz: 2ad7fd71ecfee430c9dec6d9b51971b1e7fdc38c099c5f4a868ad07add50a21ac293f6c686e5f8aca9b0d3bd919ee49e1d79336ac1fe1ac4926d6ace2de24adb
-  data.tar.gz: 5856a9fe2fcb23b4802626ee918e7015cc718d74b4d17828265377a606cb76fdf80badb3f5d0e314c76bcd3ceb4629fc3f79ab735275fd102c1a2895b54b4f3d
+  metadata.gz: ad7fd8882239bb39478cddc39d48e85c2dedfb782d73da193b7dfd401b40599aaf2385462c911d633ebdf78d2f2841d3c400367c1e6feefc300778e617afa425
+  data.tar.gz: 2104f11e65bfdf5f9b82a92a2e1281cda2c6a1c6c28a58bd7eedc89e34492f47f34f8aec229aba66d6c875b465ae56f181a0d0a539b039c5ed79a4830c1e4cd0

data/CHANGELOG.md

@@ -8,6 +8,25 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-10-01
+
+### Added
+
+- Guardrail rules can name the models they apply to (`models: small`, or globs on the model name). The guardrails
+  bundle (0.2.0, `chi update`; needs chi 0.8.1) adds two asks only small models get: `git checkout -- <file>` /
+  `git restore` (discards uncommitted changes) and `git stash drop`/`clear`. Small is `guardrails.small_models`:
+  `auto` (the default: 32B or less by the size in the model's name, an MoE's active size counting), a list of
+  globs, or `[]` for none. A chi older than 0.8.1 that shares the bundles dir (a checkout next to the gem, or a
+  worker still running after a gem update) doesn't know `models:` and denies every tool call until it is
+  restarted on the new chi.
+
+### Fixed
+
+- A tool row's time in the REPL and the attached TUI no longer counts the wait for a guardrail approval
+  (`blocked (2m 54s)` for a call denied at once).
+- docs/guardrails.md: rules are read again on the next tool call after config.yml or a bundle's rules change, with
+  no restart.
+
 ## [0.8.0] - 2026-10-01
 
 ### Added
@@ -462,7 +481,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.8.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.8.1...HEAD
+[0.8.1]: https://github.com/dm1try/samagotchi/compare/v0.8.0...v0.8.1
 [0.8.0]: https://github.com/dm1try/samagotchi/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/dm1try/samagotchi/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/dm1try/samagotchi/compare/v0.5.1...v0.6.0

data/docs/configuration.md

@@ -753,6 +753,7 @@ described in their own sections.
 | `image.max_bytes` | `3750000` | | See "Images". |
 | `image.max_per_request` | `20` | | See "Images". |
 | `guardrails.enabled` | `true` | | See [Guardrails](guardrails.md). |
+| `guardrails.small_models` | `auto` | | Which models get the `models: small` rules: `auto` (32B or less by the size in the name, an MoE's active size), a list of globs, or `[]`. See [Guardrails](guardrails.md#rules-for-some-models). |
 | `log.file` | state dir | yes | See "Debug Log File". |
 | `log.disable` | `false` | yes | No file logging. |
 | `log.level` | `info` | yes | `debug`, `info`, `warn`, `error`. |

data/docs/guardrails.md

@@ -138,8 +138,40 @@ guardrails:
 `/guardrails` marks them `disabled (guardrails.disable)` and names entries that
 match no rule. `disable:` only removes rules; hooks and the core checks still vote.
 
-Rules load when chi starts (a long-running worker picks up changes after its
-next start). A rule that doesn't parse (an unknown key, a bad regex, no
+### Rules for some models
+
+`models:` makes a rule vote only for some models: `small`, or a glob on the
+model's name (`Qwen3.6-*`, matched on the bare name without the host prefix and
+on the model key `qwen3-6-27b`, case-insensitively), or a list of them. Without
+`models:` a rule is for every model. With no model name set, a `models:` rule
+doesn't vote.
+
+```yaml
+guardrails:
+  small_models: auto          # the default; or a list of globs, or [] for none
+  rules:
+    - id: no-force-push-small
+      tool: shell
+      command: '\bgit\s+push\b.*--force'
+      models: small             # or "gemma-*", or [small, "deepseek-*"]
+      verdict: deny
+```
+
+Which models are small is `guardrails.small_models`. Nothing reports a model's
+size, so `auto` reads it from the name: `Qwen3.6-27B` is 27B, `gemma-4-E4B-it`
+4B, `Mixtral-8x7B` 56B, and for an MoE the active size counts
+(`Ornith-1.5-35B-A3B` is 3B, `Qwen3-235B-A22B` 22B). 32B or less is small. A name
+without a size (`deepseek-v4.1-flash`) is not small. A list of globs names the
+small models yourself (`auto` may be one of them), and `[]` means no model is
+small. It is read on every check, so `/model` and config edits apply at once.
+
+`/guardrails` names the model and whether it is small (`model: Qwen3.6-27B —
+small (auto, 27B)`), shows each rule's `models`, and marks a rule that doesn't
+vote for the current model `off for this model`.
+
+Rules are read again on the next tool call after `config.yml` or an installed
+bundle's rules change, so a long-running worker follows edits without a
+restart. A rule that doesn't parse (an unknown key, a bad regex, no
 verdict, a `disable:` that isn't a list of ids) makes chi **deny every tool call** and say why, rather than run
 without it.
 
@@ -157,6 +189,14 @@ repo; and shell commands that name chi's config, hooks or guardrails or
 `.git/hooks`. It denies writes into `.git/hooks`. The rules are in
 `lib/samagotchi/bundles/guardrails/guardrails/rules.yml`.
 
+Small models (`models: small`, see above) get two more asks, in
+`guardrails/small-models.yml`: `git checkout -- <path>`, `git checkout <rev> --
+<path>`, `git checkout .` and `git restore <path>` (not `--staged` alone), which
+discard uncommitted changes, and `git stash drop`/`clear`. They offer only
+"once" and "this session", so an approval doesn't silence them for good. To get
+them on every model, set `small_models` to `"*"`; to drop them, `[]` (or
+`disable:` the ids).
+
 A bundle ships rules as `guardrails/*.yml` (the same `rules:` shape). Install
 records each file's sha256; a file changed afterwards, missing, or not parsing
 denies every call until the bundle is reinstalled.

data/docs/releasing.md

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

data/lib/samagotchi/bundles/guardrails/guardrails/small-models.yml

@@ -0,0 +1,27 @@
+# Guardrail rules only small models get (models: small): asks that a strong
+# model would find noise. Which models are small is guardrails.small_models:
+# auto (the default) is 32B or less by the size in the model's name, an
+# MoE's active size counting (35B-A3B is small); a list of globs; or [] for
+# none. `/guardrails` says whether the current model is small.
+#
+# These asks offer only once and session: an approval for the repo or the
+# whole rule would silence them for good, on any model.
+# Same fields and git prefix as rules.yml.
+rules:
+  # ── losing uncommitted work ────────────────────────────────────────────
+  # git checkout -- <path>, git checkout <rev> -- <path>, git checkout .,
+  # and git restore of the worktree (not git restore --staged alone).
+  - id: git-discard-worktree
+    tool: shell
+    command: '\bgit(?:\s+(?:-C\s+\S+|-c\s+\S+|--?[A-Za-z][\w-]*(?:=\S+)?))*\s+(?:checkout\b[^;&|\n]*\s(?:--\s+\S|\.(?:\s|$|/))|restore\b(?![^;&|\n]*\s--staged\b)(?=[^;&|\n]*\s[^-\s])|restore\b(?=[^;&|\n]*\s(?:--worktree|-W)\b))'
+    models: small
+    verdict: ask
+    reason: git checkout -- / git restore discards uncommitted changes
+    scopes: [once, session]
+  - id: git-stash-drop
+    tool: shell
+    command: '\bgit(?:\s+(?:-C\s+\S+|-c\s+\S+|--?[A-Za-z][\w-]*(?:=\S+)?))*\s+stash\s+(drop|clear)\b'
+    models: small
+    verdict: ask
+    reason: git stash drop/clear deletes stashed work
+    scopes: [once, session]

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

@@ -1,8 +1,10 @@
 ---
 name: guardrails
-version: 0.1.1
+version: 0.2.0
 scope: system
-description: Optional default guardrail rules (git push/rewrites, rm -rf wide, curl | sh, writes outside the repo, git hooks) and a note for the model
+description: Optional default guardrail rules (git push/rewrites, rm -rf wide, curl | sh, writes outside the repo, git hooks), asks only small models get (git checkout --/restore, git stash drop), and a note for the model
 trust_level: reviewed
+# models: in small-models.yml (guardrails.small_models)
+requires_chi: ">= 0.8.1"
 files:
   guardrails.md: sha256:04207fd1738aeeeef3b7a8053fc57597565bddd7862f01acaba784419cbd909b

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

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.8.0
+version: 0.8.1
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/config.rb

@@ -103,6 +103,9 @@ module Samagotchi
       Entry.new(key: "image.max_per_request",    yaml_path: %w[image max_per_request],    type: :integer, default: 20,              expose: %i[env config]),
 
       Entry.new(key: "guardrails.enabled",       yaml_path: %w[guardrails enabled],       type: :bool,   default: true,             expose: %i[env config]),
+      # Which models get the rules with `models: small` (Guardrails::ModelSize): auto (32B or less by the name's size, an MoE's
+      # active size counting), globs on the bare model name or its key, "|"-separated (a YAML list works too), or "" ([]) for none.
+      Entry.new(key: "guardrails.small_models",  yaml_path: %w[guardrails small_models],  type: :string, default: "auto",           expose: %i[env config]),
 
       Entry.new(key: "log.file",                 yaml_path: %w[log file],                 type: :string, default: nil,              expose: %i[env config cli]),
       Entry.new(key: "log.disable",              yaml_path: %w[log disable],              type: :bool,   default: false,            expose: %i[env config cli]),

data/lib/samagotchi/engine.rb

@@ -126,6 +126,7 @@ module Samagotchi
         tools: -> { @tools },
         session: -> { @session },
         model_key: -> { @model_key },
+        model_name: -> { guardrail_model_name },
         cancelled: -> { !!active_cancel_controller&.cancelled? },
         ask: ->(fields) { open_question(fields) }
       )
@@ -428,6 +429,11 @@ module Samagotchi
     attr_reader :metrics
     attr_reader :default_model_name, :effective_model_name
 
+    # The effective model's key (ModelOverlay.key_for its bare name): memory
+    # overlays, guardrail rules' models:.
+    # @return [String, nil]
+    attr_reader :model_key
+
     # The prompt profile for the effective model (see #profile_resolution).
     # @return [ModelProfile]
     def profile = profile_resolution.profile
@@ -452,6 +458,13 @@ module Samagotchi
       @host_registry.bare_name(full_ref)
     end
 
+    # The effective model's bare name for the guardrails' models: rules;
+    # nil without a model name.
+    def guardrail_model_name
+      name = @effective_model_name && bare_model_name(@effective_model_name)
+      name.to_s.strip.empty? ? nil : name
+    end
+
     # Point the kernel (and a chat backend) at the effective model's host
     # (after /model, --model, resume).
     def sync_kernel_client!

data/lib/samagotchi/guardrail_wiring.rb

@@ -29,14 +29,16 @@ module Samagotchi
     # @param tools     [#call] → Tools::Registry
     # @param session   [#call] → Session, nil
     # @param model_key [#call] → String, the effective model's overlay key
+    # @param model_name [#call] → String, nil: the effective model's bare name
     # @param cancelled [#call] → Boolean, whether the running turn is cancelled
     # @param ask       [#call] (fields) → the answer; the Engine's question flow
-    def initialize(scratch:, hooks:, tools:, session:, model_key:, cancelled:, ask:)
+    def initialize(scratch:, hooks:, tools:, session:, model_key:, cancelled:, ask:, model_name: -> {})
       @scratch = scratch
       @hooks_lookup = hooks
       @tools_lookup = tools
       @session_lookup = session
       @model_key_lookup = model_key
+      @model_name_lookup = model_name
       @cancelled_lookup = cancelled
       @ask = ask
       @failures = Guardrails::LoadFailures.new
@@ -78,6 +80,7 @@ module Samagotchi
         -> { @hooks_lookup.call },
         context_lookup: -> { context },
         model_key_lookup: -> { @model_key_lookup.call },
+        model_name_lookup: -> { @model_name_lookup.call },
         approver: ->(verdict) { request_approval(verdict) },
         approvals_lookup: -> { @approvals },
         checks_lookup: -> { checks },

data/lib/samagotchi/guardrails/gate.rb

@@ -21,7 +21,8 @@ module Samagotchi
       #   the kernel is built.
       # @param context_lookup [#call] returns the Context for this call
       #   (the Engine's: session, interface, origin, per-turn git cache)
-      # @param model_key_lookup [#call] the model key (memory overlays)
+      # @param model_key_lookup [#call] the model key (memory overlays, rules' models:)
+      # @param model_name_lookup [#call] the bare model name (rules' models:)
       # @param approver [#call, nil] settles an ask (Engine#request_approval);
       #   without one an ask is denied
       # @param approvals_lookup [#call] returns the Approvals store (or nil)
@@ -31,12 +32,13 @@ module Samagotchi
       #   hook's stop_turn): the rest of a batch is denied without a vote
       # @param tools_lookup [#call] returns the Tools::Registry (or nil): a
       #   plugin tool's targets: say what its call acts on
-      def initialize(hooks_lookup, context_lookup: -> { Context.new }, model_key_lookup: -> {}, approver: nil,
-                     approvals_lookup: -> {}, checks_lookup: -> { [] }, cancelled_lookup: -> { false },
+      def initialize(hooks_lookup, context_lookup: -> { Context.new }, model_key_lookup: -> {}, model_name_lookup: -> {},
+                     approver: nil, approvals_lookup: -> {}, checks_lookup: -> { [] }, cancelled_lookup: -> { false },
                      tools_lookup: -> {})
         @hooks_lookup = hooks_lookup
         @context_lookup = context_lookup
         @model_key_lookup = model_key_lookup
+        @model_name_lookup = model_name_lookup
         @approver = approver
         @approvals_lookup = approvals_lookup
         @checks_lookup = checks_lookup
@@ -113,7 +115,8 @@ module Samagotchi
       end
 
       def targets_for(call, context)
-        Targets.for(call, context, model_key: @model_key_lookup.call, registry: @tools_lookup.call)
+        Targets.for(call, context, model_key: @model_key_lookup.call, model_name: @model_name_lookup.call,
+                                   registry: @tools_lookup.call)
       end
 
       # Registry#fire_each rescues a raising hook itself.

data/lib/samagotchi/guardrails/model_size.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../config"
+
+module Samagotchi
+  module Guardrails
+    # Whether the effective model is a small one, for rules with
+    # `models: small` (guardrails.small_models). Nothing reports a model's
+    # size (llama.cpp's /props has no parameter count), so `auto` reads it
+    # from the bare model name: Qwen3.6-27B → 27, gemma-4-E4B-it → 4,
+    # Ornith-1.5-35B-A3B → 3 (an MoE's active size counts), Mixtral-8x7B
+    # → 56. A name without a size, and no model at all, is not small (fail
+    # open: the rules for small models are extra asks, not the defaults).
+    module ModelSize
+      SETTING = "guardrails.small_models"
+      # The largest auto-small size, in billions of parameters.
+      MAX_SMALL = 32
+      GLOB_FLAGS = File::FNM_CASEFOLD | File::FNM_EXTGLOB
+
+      # A size starts at the name's start or after a separator, and ends at
+      # a separator or the name's end (so 4bit and v4.1 aren't sizes).
+      NUM = '(\d+(?:\.\d+)?)'
+      BEFORE = '(?:\A|[-_/:\s])'
+      AFTER = '(?=[-_:\s]|\z)'
+      ACTIVE = /#{BEFORE}a#{NUM}b#{AFTER}/i
+      EXPERTS = /#{BEFORE}(\d+)x#{NUM}b#{AFTER}/i
+      PLAIN = /#{BEFORE}e?#{NUM}b#{AFTER}/i
+
+      module_function
+
+      # The size the bare model name gives, in billions; nil without one.
+      # @return [Numeric, nil]
+      def billions(name)
+        name = name.to_s
+        if (m = name.match(ACTIVE))
+          number(m[1])
+        elsif (m = name.match(EXPERTS))
+          m[1].to_i * number(m[2])
+        elsif (m = name.match(PLAIN))
+          number(m[1])
+        end
+      end
+
+      def number(text)
+        text.include?(".") ? text.to_f : text.to_i
+      end
+
+      # @param name [String, nil] the bare model name (no host prefix)
+      # @param key [String, nil] its model key (ModelOverlay.key_for)
+      # @param setting [String, nil] guardrails.small_models: "auto", globs
+      #   on the name or the key, "|"-separated ("auto" may be one of them),
+      #   or "" (never)
+      def small?(name, key, setting = self.setting)
+        return false if name.nil? || name.to_s.strip.empty?
+
+        entries = (setting.nil? ? "auto" : setting.to_s).split("|").map(&:strip).reject(&:empty?)
+        entries.any? do |entry|
+          if entry.casecmp?("auto")
+            (size = billions(name)) ? size <= MAX_SMALL : false
+          else
+            [name, key].compact.any? { |candidate| File.fnmatch(entry, candidate.to_s, GLOB_FLAGS) }
+          end
+        end
+      end
+
+      # How /guardrails says it: "small (auto, 27B)", "not small (auto, no
+      # size in the name)", "small (small_models: qwen*)".
+      def describe(name, key, setting = self.setting)
+        return "not small (no model name)" if name.nil? || name.to_s.strip.empty?
+
+        verdict = small?(name, key, setting) ? "small" : "not small"
+        return "#{verdict} (small_models: #{setting.empty? ? "[]" : setting})" unless setting.nil? || setting.strip.casecmp?("auto")
+
+        size = billions(name)
+        "#{verdict} (auto, #{size ? "#{size}B" : "no size in the name"})"
+      end
+
+      # The setting, live (config.yml is re-read on change); auto when it
+      # can't be read.
+      def setting
+        Config.get(SETTING)
+      rescue StandardError
+        "auto"
+      end
+    end
+  end
+end

data/lib/samagotchi/guardrails/rules.rb

@@ -2,6 +2,7 @@
 
 require_relative "verdict"
 require_relative "targets"
+require_relative "model_size"
 
 module Samagotchi
   module Guardrails
@@ -13,6 +14,10 @@ module Samagotchi
     #   path:    "outside_repo", or a glob on the resolved paths (absolute
     #            or "**/…" globs match the absolute path; others the path
     #            relative to the repo root, the cwd outside one)
+    #   models:  "small" (Guardrails::ModelSize, guardrails.small_models),
+    #            or a glob on the bare model name or the model key, or a
+    #            list of them: the rule only votes for a model that matches
+    #            (no model matches none; missing = every model)
     # verdict ask|deny, reason, scopes (for an ask; default all).
     # `guardrails.disable` switches single rules off (#parse_disable).
     # A rule that doesn't parse raises ParseError: the Engine then denies
@@ -21,13 +26,14 @@ module Samagotchi
     class Rules
       class ParseError < StandardError; end
 
-      KEYS = %w[id tool command path verdict reason scopes].freeze
+      KEYS = %w[id tool command path models verdict reason scopes].freeze
       VERDICTS = %w[ask deny].freeze
       GLOB_FLAGS = File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_EXTGLOB
 
-      Rule = Struct.new(:id, :tools, :command, :path, :verdict, :reason, :scopes, :source, keyword_init: true) do
+      Rule = Struct.new(:id, :tools, :command, :path, :models, :verdict, :reason, :scopes, :source, keyword_init: true) do
         def matches?(targets)
           return false unless targets
+          return false unless for_model?(targets.model_name, targets.model_key, -> { targets.small_model? })
           return false if tools && !tool_matches?(targets.tool)
           return false if command && !(targets.command && command.match?(targets.command))
           return false if path && !path_matches?(targets)
@@ -39,6 +45,21 @@ module Samagotchi
           tools.any? { |tool| Rules.glob?(tool) ? File.fnmatch(tool, name.to_s, File::FNM_EXTGLOB) : tool == name }
         end
 
+        # Whether the rule votes for this model (its models:; without one,
+        # for every model). +small+ says whether the model is a small one.
+        def for_model?(name, key, small = -> { ModelSize.small?(name, key) })
+          return true unless models
+          return false if name.nil? || name.empty?
+
+          models.any? do |entry|
+            if entry == "small"
+              small.call
+            else
+              [name, key].compact.any? { |candidate| File.fnmatch(entry, candidate, ModelSize::GLOB_FLAGS) }
+            end
+          end
+        end
+
         def path_matches?(targets)
           return targets.outside_repo? if path == "outside_repo"
 
@@ -83,7 +104,7 @@ module Samagotchi
         end
 
         Rule.new(id: id, tools: tools_of(raw["tool"], label), command: regex_of(raw["command"], label),
-                 path: path_of(raw["path"], label), verdict: verdict.to_sym,
+                 path: path_of(raw["path"], label), models: models_of(raw["models"], label), verdict: verdict.to_sym,
                  reason: (raw["reason"] || "rule #{id}").to_s, scopes: scopes_of(raw["scopes"], label), source: source)
       end
 
@@ -114,6 +135,17 @@ module Samagotchi
         value
       end
 
+      def self.models_of(value, label)
+        return nil if value.nil?
+
+        names = Array(value)
+        unless !names.empty? && names.all? { |n| n.is_a?(String) && !n.strip.empty? }
+          raise ParseError, "#{label}: models must be small, a glob or a list of them"
+        end
+
+        names.map(&:strip)
+      end
+
       def self.scopes_of(value, label)
         return nil if value.nil?
 

data/lib/samagotchi/guardrails/targets.rb

@@ -3,6 +3,7 @@
 require_relative "../tools/tool_path"
 require_relative "../tools/memory"
 require_relative "../log"
+require_relative "model_size"
 
 module Samagotchi
   module Guardrails
@@ -16,6 +17,10 @@ module Samagotchi
 
       attr_reader :tool, :command, :paths, :cwd, :repo_root
 
+      # @return [String, nil] the effective model: its bare name (no host
+      #   prefix) and its key (ModelOverlay.key_for), for a rule's models:
+      attr_reader :model_name, :model_key
+
       # @return [Hash, nil] a plugin tool's arguments (call[:args]), for an
       #   approval of a call whose targets name no command or path; nil for
       #   chi's own tools
@@ -23,10 +28,12 @@ module Samagotchi
 
       # @param call [Hash] the parsed tool call
       # @param context [Context]
-      # @param model_key [String, nil] for a memory_write model overlay
+      # @param model_key [String, nil] for a memory_write model overlay, and
+      #   a rule's models:
+      # @param model_name [String, nil] the bare model name, for a rule's models:
       # @param registry [Tools::Registry, nil] the session's tools: a plugin
       #   tool's entry says what it acts on (its targets:)
-      def self.for(call, context, model_key: nil, registry: nil)
+      def self.for(call, context, model_key: nil, model_name: nil, registry: nil)
         tool = call[:name].to_s
         base = context.cwd
         command = nil
@@ -53,7 +60,8 @@ module Samagotchi
           entry = registry && registry[tool]
           args = call[:args] if entry && !entry.core? && call[:args].is_a?(Hash)
         end
-        new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd), args: args)
+        new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd), args: args,
+            model_name: model_name, model_key: model_key)
       end
 
       # What a plugin tool's targets: callable says the call acts on:
@@ -93,8 +101,10 @@ module Samagotchi
         nil
       end
 
-      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil)
+      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil, model_name: nil, model_key: nil)
         @args = args
+        @model_name = model_name
+        @model_key = model_key
         @tool = tool
         @command = command
         @paths = paths
@@ -104,6 +114,14 @@ module Samagotchi
 
       def shell? = SHELL_TOOLS.include?(@tool)
 
+      # Whether the effective model is a small one (guardrails.small_models,
+      # read when first asked: once per call's targets).
+      def small_model?
+        return @small_model if defined?(@small_model)
+
+        @small_model = ModelSize.small?(@model_name, @model_key)
+      end
+
       # Whether any path is outside the repo root (the cwd outside a repo).
       def outside_repo?
         root = @repo_root || @cwd

data/lib/samagotchi/guardrails.rb

@@ -3,6 +3,7 @@
 require_relative "guardrails/verdict"
 require_relative "guardrails/context"
 require_relative "guardrails/targets"
+require_relative "guardrails/model_size"
 require_relative "guardrails/approval"
 require_relative "guardrails/approvals"
 require_relative "guardrails/protected_paths"

data/lib/samagotchi/session_commands.rb

@@ -234,6 +234,9 @@ module Samagotchi
       rules = @engine.guardrail_rules
       approvals = @engine.guardrail_approvals.entries
       lines = ["guardrails: #{rules.enabled? ? "on" : "off (guardrails.enabled: false; denies still apply)"}"]
+      name = @engine.guardrail_model_name
+      key = @engine.model_key
+      lines << "model: #{name || "none"} — #{Guardrails::ModelSize.describe(name, key)}"
       failures = @engine.guardrail_failures.list
       unless failures.empty?
         lines << "failed to load:"
@@ -248,9 +251,11 @@ module Samagotchi
         match = [
           ("tool #{rule.tools.join(",")}" if rule.tools),
           ("command /#{shorten_pattern(rule.command.source)}/" if rule.command),
-          ("path #{rule.path}" if rule.path)
+          ("path #{rule.path}" if rule.path),
+          ("models #{rule.models.join(",")}" if rule.models)
         ].compact.join(", ")
         off = "disabled (guardrails.disable) — " if rules.disabled?(rule)
+        off ||= "off for this model — " unless rule.for_model?(name, key)
         lines << "  #{idx + 1}. #{rule.id}: #{off}#{rule.verdict} (#{match}) — #{rule.reason} [#{rule.source}]"
       end
       rules.unmatched_disables.each { |entry| lines << "  guardrails.disable: #{entry} matches no rule" }

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -209,9 +209,11 @@ private
         [event[:iteration].to_i, event[:call_index].to_i, event[:tool].to_s]
       end
 
+      # From tool_call_started, less an approval wait (waited_ms): an asked
+      # row counts from the answer.
       def tool_duration_ms(event)
         started_at = @tool_started_at.delete(tool_call_key(event))
-        started_at && ((@clock.call - started_at) * 1000.0)
+        started_at && [((@clock.call - started_at) * 1000.0) - event[:waited_ms].to_f, 0.0].max
       end
     end
   end

data/lib/samagotchi/tool_runner.rb

@@ -25,8 +25,10 @@ module Samagotchi
 
     # @param kernel [KernelLoop] read lazily: Engine sets its hooks after
     #   the kernel is built.
-    def initialize(kernel)
+    # @param clock [#call] monotonic seconds, for the approval wait
+    def initialize(kernel, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
       @kernel = kernel
+      @clock = clock
     end
 
     # @param call_index [Integer] 1-based position of the call in its batch
@@ -54,8 +56,14 @@ module Samagotchi
       emit(on_stream_event, started)
 
       # The ask comes after tool_call_started: the UI shows the tool line,
-      # then the approval under it.
-      settle_ask(verdict) if verdict.ask?
+      # then the approval under it. waited_ms on tool_call_completed lets a
+      # UI that times the row from tool_call_started leave the wait out.
+      waited_ms = nil
+      if verdict.ask?
+        asked_at = @clock.call
+        settle_ask(verdict)
+        waited_ms = ((@clock.call - asked_at) * 1000).round
+      end
       before = verdict.deny? ? NOT_AN_EDIT : file_before(call)
       result = verdict.deny? ? denied(call, verdict) : dispatch(call)
       diff = file_change(call, before)
@@ -75,6 +83,7 @@ module Samagotchi
                     tool: call[:name], output: capped, output_truncated: truncated, activity: result[:activity] }
       completed[:images] = images if images&.any?
       completed[:diff] = diff if diff
+      completed[:waited_ms] = waited_ms if waited_ms
       emit(on_stream_event, completed)
 
       run = { output: output, capped_output: capped, truncated: truncated, activity: result[:activity] }

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -166,6 +166,7 @@ files:
 - lib/samagotchi/bundles/dev/manifest.yml
 - lib/samagotchi/bundles/guardrails/guardrails.md
 - lib/samagotchi/bundles/guardrails/guardrails/rules.yml
+- lib/samagotchi/bundles/guardrails/guardrails/small-models.yml
 - lib/samagotchi/bundles/guardrails/manifest.yml
 - lib/samagotchi/bundles/known-names/hooks/known_names.rb
 - lib/samagotchi/bundles/known-names/known_names.md
@@ -217,6 +218,7 @@ files:
 - lib/samagotchi/guardrails/context.rb
 - lib/samagotchi/guardrails/gate.rb
 - lib/samagotchi/guardrails/load_failures.rb
+- lib/samagotchi/guardrails/model_size.rb
 - lib/samagotchi/guardrails/protected_paths.rb
 - lib/samagotchi/guardrails/rules.rb
 - lib/samagotchi/guardrails/scratch_writes.rb