samagotchi 0.19.0 → 0.21.0

data/lib/samagotchi/bundles/loop-guard/plugin.rb

@@ -24,6 +24,9 @@
 #   thinking:          the thinking watch (ThinkingWatch::DEFAULTS)
 #     watch: true      false: the tool-call guard only
 #     action: retry    retry (cut, ask again; then stop) | stop | notify
+#     forget_after: 10 good steps (generations with no loop) in a row after a
+#                      cut loop, and the next loop is cut again, not stopped;
+#                      0: never forget, the turn's second loop stops it
 require "digest"
 
 # Sees thinking repeat itself, from the deltas of one generation.
@@ -44,12 +47,19 @@ require "digest"
 #   of 2 or more needs a cycle of distinct sentences (not all alike), and a
 #   period of 1 (one sentence over and over) needs `similarity` +
 #   SAME_MARGIN (0.9 by default: near-identical);
-# - the same sentence max_same times in the generation, in any order.
+# - the same sentence max_same times in the generation, in any order;
+# - a short run: short_run short sentences (under min_words) in a row, at
+#   most short_distinct different ones among the last short_run ("I'll
+#   write it. Go. OK. Writing. Go."). Normal thinking has short sentences
+#   too ("Hmm.", "Fine."), but spread out, or in runs of different ones
+#   (code lines); a sentence of min_words or more ends the run, one with no
+#   letters or digits neither counts nor ends it. Lines inside a ``` code
+#   block are not short sentences.
 # Nothing triggers before min_chars of thinking. O(new chars) per feed.
 class ThinkingWatch
   DEFAULTS = { "watch" => true, "action" => "retry", "min_chars" => 2000, "repeats" => 3, "max_period" => 6,
                "similarity" => 0.5, "min_span_sentences" => 6, "min_span_chars" => 600, "max_same" => 8,
-               "min_words" => 5 }.freeze
+               "min_words" => 5, "short_run" => 24, "short_distinct" => 6, "forget_after" => 10 }.freeze
   ACTIONS = %w[retry stop notify].freeze
   MAX_CARRY = 400
   # One sentence again and again needs this much more alike than a cycle.
@@ -68,10 +78,13 @@ class ThinkingWatch
     out = DEFAULTS.dup
     out["watch"] = !%w[false no off 0].include?(raw["watch"].to_s.downcase) if raw.key?("watch")
     out["action"] = raw["action"].to_s if ACTIONS.include?(raw["action"].to_s)
-    %w[min_chars repeats max_period min_span_sentences min_span_chars max_same min_words].each do |key|
+    %w[min_chars repeats max_period min_span_sentences min_span_chars max_same min_words short_run
+       short_distinct].each do |key|
       number = Integer(raw[key].to_s, exception: false)
       out[key] = number if number&.positive?
     end
+    forget = Integer(raw["forget_after"].to_s, exception: false)
+    out["forget_after"] = forget if forget && forget >= 0
     similarity = Float(raw["similarity"].to_s, exception: false)
     out["similarity"] = similarity if similarity && similarity.positive? && similarity <= 1
     out["repeats"] = 2 if out["repeats"] < 2
@@ -87,12 +100,17 @@ class ThinkingWatch
     @min_span_chars = settings["min_span_chars"]
     @max_same = settings["max_same"]
     @min_words = settings["min_words"]
+    @short_run = settings["short_run"]
+    @short_distinct = settings["short_distinct"]
     @same_similarity = [@similarity + SAME_MARGIN, 0.95].min
     @carry = +""
     @window = [] # the last max_period + 1 sentences
     @run = Array.new(@max_period + 1, 0)
     @run_chars = Array.new(@max_period + 1, 0) # chars of the run's sentences plus the first cycle's
     @counts = Hash.new(0)
+    @short_count = 0  # short sentences in a row
+    @short_window = [] # the last short_run of them, [key, text]
+    @in_code = false
     @thinking_chars = 0
   end
 
@@ -115,7 +133,9 @@ class ThinkingWatch
   # The complete sentences in the carry; the unfinished tail stays.
   def sentences
     parts = @carry.split(SPLIT, -1)
-    @carry = parts.pop.to_s
+    # An empty carry splits into no parts: nil.to_s is frozen, and the next
+    # feed's << would raise (the watch went blind for that generation).
+    @carry = +parts.pop.to_s
     if @carry.length > MAX_CARRY
       cut = @carry.rindex(" ", MAX_CARRY) || MAX_CARRY
       parts << @carry[0, cut]
@@ -125,8 +145,13 @@ class ThinkingWatch
   end
 
   def add(text)
+    if text.strip.start_with?("```")
+      @in_code = !@in_code
+      return nil
+    end
     words = text.downcase.gsub(/[^[:alnum:]]+/, " ").split
-    return nil if words.length < @min_words
+    short = short_loop(text.strip, words) unless @in_code
+    return (short if @thinking_chars >= @min_chars) if words.length < @min_words
 
     key = words.join(" ")
     sentence = Sentence.new(text: text.strip, words: words.map(&:hash).uniq,
@@ -140,6 +165,25 @@ class ThinkingWatch
     cycle || (same >= @max_same ? Loop.new(period: 1, times: same, sentences: [sentence.text], chars: nil) : nil)
   end
 
+  def short_loop(text, words)
+    return nil if words.empty?
+
+    if words.length >= @min_words
+      @short_count = 0
+      @short_window.clear
+      return nil
+    end
+    @short_count += 1
+    @short_window << [words.join(" "), text]
+    @short_window.shift if @short_window.length > @short_run
+    return nil if @short_window.length < @short_run
+
+    distinct = @short_window.uniq(&:first)
+    return nil if distinct.length > @short_distinct
+
+    Loop.new(period: distinct.length, times: @short_count / distinct.length, sentences: distinct.first(3).map(&:last), chars: nil)
+  end
+
   def count(key)
     return @counts[key] += 1 if @counts.key?(key) || @counts.size < MAX_DISTINCT
 
@@ -209,6 +253,7 @@ class Plugin
     return unless @thinking["watch"]
 
     chi.on(:before_generation) do |_event|
+      good_step if @watch
       @watch = ThinkingWatch.new(@thinking)
       @watch_done = false
     end
@@ -242,6 +287,16 @@ class Plugin
     end
   end
 
+  # The generation before this one ended with no loop: a good step. After
+  # forget_after of them in a row the turn's loops are forgotten, so a loop
+  # long after the model recovered is cut and retried, not stopped.
+  def good_step
+    return @good_steps = 0 if @watch_done
+
+    @good_steps += 1
+    @thinking_loops = 0 if @good_steps == @thinking["forget_after"]
+  end
+
   def stop_thinking(ctx, found, what)
     return unless ctx.stop_turn("the model's thinking kept repeating itself (#{what})")
 
@@ -261,6 +316,7 @@ class Plugin
     @denials = 0
     @pending = nil
     @thinking_loops = 0
+    @good_steps = 0
     @watch = nil
   end
 

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

@@ -1,11 +1,11 @@
 ---
 name: mcp
-version: 0.4.0
+version: 0.4.1
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:009dbb3b754958a6d9edb1e3b828f486aa0ddd09ff5b548f0c576abbfea18807
+  sha256: sha256:7c87e14dbdb20d32c37ef2a83f8d56448807ad26564a4034db4f6afbcf8a0323
 requires_chi: ">= 0.8.0"

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

@@ -218,7 +218,11 @@ class Plugin
 
     def ended
       status = @wait.value
-      reason = "the server exited (#{status.exitstatus ? "status #{status.exitstatus}" : "signal #{status.termsig}"})"
+      reason = if status.nil?
+                 "the server exited"
+               else
+                 "the server exited (#{status.exitstatus ? "status #{status.exitstatus}" : "signal #{status.termsig}"})"
+               end
       waiting, closing = @mutex.synchronize do
         @dead ||= reason
         [@pending.values, @closing]
@@ -652,7 +656,7 @@ class Plugin
 
         notes = paths.map do |path|
           images << { path: path, name: File.basename(path) }
-          "[image #{images.size}: #{File.basename(path)}, attached]"
+          "[image #{images.size}: #{File.basename(path)}]"
         end
         [line, *notes].join("\n")
       when "image"
@@ -661,11 +665,21 @@ class Plugin
         next "[image: #{mime}, empty]" if bytes.empty?
 
         images << { bytes: bytes, name: "#{tool}-#{images.size + 1}.#{IMAGE_EXT.fetch(mime, "img")}" }
-        "[image #{images.size}: #{mime}, attached]"
+        "[image #{images.size}: #{mime}]"
       when "audio" then "[audio: #{block["mimeType"] || "unknown type"}]"
       when "resource"
         resource = block["resource"] || {}
-        resource["text"] || "[resource: #{resource["uri"]}]"
+        mime = resource["mimeType"].to_s
+        blob = resource["blob"].to_s
+        if mime.start_with?("image/") && !blob.empty?
+          bytes = blob.unpack1("m")
+          next "[image: #{mime}, empty]" if bytes.empty?
+
+          images << { bytes: bytes, name: "#{tool}-#{images.size + 1}.#{IMAGE_EXT.fetch(mime, "img")}" }
+          "[image #{images.size}: #{mime}]"
+        else
+          resource["text"] || "[resource: #{resource["uri"]}]"
+        end
       when "resource_link" then "[resource link: #{block["uri"]}]"
       else "[#{block["type"] || "unknown"} content]"
       end

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.19.0
+version: 0.21.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:69bc0ec091fdaeedf6e3aa7365275461fe3eba32b2dedc9cf45044176c356af5
   config_modification_protocol.md: sha256:8d8921854e616d840b393cdda6fd911b7d5e8172501bb8293c01f734121ccc21
-  memory_guide.md: sha256:8819678a243590203fa439ad736bf1959af4b4677bc6d2d507bad92c46fb1ccc
+  memory_guide.md: sha256:17126f5adb9ef7b33c40e920ef339388c8c8c045b38a7de825b08760604db4e4
   delegated.md: sha256:0a71d5dfa7127df2d51cb5f0e7214240ed88777e36559430a8724c796d7ae561

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

@@ -94,7 +94,7 @@ Bundles are versioned directories/zips/tar.gz/git URLs with a `manifest.yml` and
 | `build [--scope system\|project] [--name NAME] [--version VER] [--description DESC] [--out PATH] [FILES...]` | **Inverse of install** — builds a shareable bundle from local memories and installed hooks. Infers `zip` vs `dir`/`tar.gz` from `--out` extension; default `chi_system_memories.zip` (system) or `chi_<repo>_memories.zip` (project, named after the project root) v`1.0.0` in `Dir.pwd`. `FILES...` is an optional allowlist of memory basenames (`identity` or `identity.md`); if omitted, all `*.md` except `index.md`/hidden/non-md and the memories other installed bundles own (each named in a `Left out` line) are included. Installed hooks are copied to `hooks/` with their manifest metadata. Computes `sha256:` checksums and writes `manifest.yml` via `Manifest.write`. No provenance write. |
 
 **Scope resolution for install/build:**
-- CLI `--scope` wins over `manifest.yml` `scope`. Default is `system` if none given (`Installer#run`). For `project`, target is the project folder `<system dir>/projects/<basename>_<hash>` of the project root (`Installer#resolve_target_dir`).
+- CLI `--scope` wins over `manifest.yml` `scope`. Default is `system` if none given (`Installer#run`). For `project`, target is the project folder `<system dir>/projects/<basename>_<hash>` of the project root (`MemoryPaths.scope_dir`).
 
 **Example flows:**
 ```bash

data/lib/samagotchi/commands/registry.rb

@@ -28,8 +28,10 @@ module Samagotchi
         def in_ui?(ui) = uis.nil? || uis.include?(ui)
       end
 
-      def initialize
+      # @param entries [Array<Entry>] taken as they are, in order (.from_listing)
+      def initialize(entries: [])
         @entries = []
+        entries.each { |entry| add(entry) }
       end
 
       # A UI without an Engine (attached) learns the session's commands from
@@ -39,8 +41,7 @@ module Samagotchi
       # @param listing [Array<Hash>] #listing, with String or Symbol keys
       # @return [Registry]
       def self.from_listing(listing, base:)
-        registry = new
-        base.entries.each { |entry| registry.send(:add, entry) }
+        registry = new(entries: base.entries)
         known = base.entries.map(&:name)
         Array(listing).each do |item|
           item = item.transform_keys(&:to_sym)

data/lib/samagotchi/config.rb

@@ -107,6 +107,9 @@ module Samagotchi
       # The guardrails settings are config.yml only: a parent agent must not switch a child's guardrails off from its
       # own environment (SAMAGOTCHI_GUARDRAILS_ENABLED=false). SessionManager.spawn_options unsets them for a worker too.
       Entry.new(key: "guardrails.enabled",       yaml_path: %w[guardrails enabled],       type: :bool,   default: true,             expose: %i[config]),
+      # Which rules vote: auto (the default) leaves out the rules tagged `modes: [strict]`; strict runs them all. An unknown
+      # value warns and is auto.
+      Entry.new(key: "guardrails.mode",          yaml_path: %w[guardrails mode],          type: :enum,   default: "auto",           expose: %i[config], enum_values: %w[auto strict]),
       # 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[config]),

data/lib/samagotchi/context_usage.rb

@@ -26,9 +26,9 @@ module Samagotchi
       usage = {} unless usage.is_a?(Hash)
 
       # The token counts come from the same parser SessionMetrics uses.
-      counts = TokenUsage.from_payload(payload_hash) || {}
-      prompt_tokens = counts[:prompt_tokens]
-      completion_tokens = counts[:completion_tokens]
+      counts = TokenUsage.from_payload(payload_hash)
+      prompt_tokens = counts&.prompt_tokens
+      completion_tokens = counts&.completion_tokens
 
       total_tokens = first_positive_integer(
         usage["total_tokens"], usage[:total_tokens],

data/lib/samagotchi/engine.rb

@@ -1637,12 +1637,25 @@ module Samagotchi
     def stopped_before_model(turn)
       reason = turn.controller.reason
       end_turn(turn, "canceled") do |seconds|
-        [nil, { type: :turn_canceled, cancellation_reason: reason, duration_ms: (seconds * 1000).round }]
+        [nil, { type: :turn_canceled, cancellation_reason: reason, cancelled_by: cancelled_by(turn),
+                duration_ms: (seconds * 1000).round }]
       end
       LLM::ModelResult.new(text: "", canceled: true, cancellation_reason: reason)
     end
     private :stopped_before_model
 
+    # Who stopped a turn a hook stopped or cut (the controller's detail: the
+    # bundle, or the hook's label), for the UIs' "stopped by loop-guard";
+    # nil for any other cancel.
+    def cancelled_by(turn)
+      return nil unless turn.controller.reason == :hook
+
+      detail = turn.controller.detail
+      by = detail[:by].to_s if detail.is_a?(Hash)
+      by unless by.nil? || by.empty?
+    end
+    private :cancelled_by
+
     # The turn's settings for the kernel (LLM::TurnSettings): vision,
     # sampling and thinking, the thinking resolved before the hooks run.
     # The model name is added in #generate, after the hooks that may switch
@@ -1744,7 +1757,7 @@ module Samagotchi
       end_turn(turn, canceled ? "canceled" : "completed", exhausted: !canceled && result.exhausted?) do |seconds|
         kept = kept_messages(turn, result, seconds)
         if canceled
-          [kept, { type: :turn_canceled, cancellation_reason: result.cancellation_reason,
+          [kept, { type: :turn_canceled, cancellation_reason: result.cancellation_reason, cancelled_by: cancelled_by(turn),
                    duration_ms: (seconds * 1000).round }]
         else
           # For a client that attaches later (session_state_snapshot).
@@ -2298,6 +2311,7 @@ module Samagotchi
         # not an event of its own.
         next thinking_refused(event) if event[:type] == :thinking_refused
 
+        event = with_generation_report(event) if event[:type] == :generation_completed
         emit_event(on_event, event)
         watch.feed(**progress) if watch && progress
         if event[:type] == :generation_completed
@@ -2307,6 +2321,19 @@ module Samagotchi
       end
     end
 
+    # A :generation_completed with the generation's decode speed (`speed:`
+    # {decode_tps:, source:}, nil without one) and the session's running
+    # token totals (`tokens:`, the snapshot's block): the web's info bar
+    # reads them from the stream. SessionMetrics closes the generation here,
+    # so the event it gets next finds it closed.
+    def with_generation_report(event)
+      report = @metrics.finish_generation
+      event.merge(speed: report.speed&.to_h, tokens: report.tokens)
+    rescue StandardError
+      event
+    end
+    private :with_generation_report
+
     # The turn's StreamWatch, or nil when no hook listens.
     def stream_watch(cancel_controller)
       return nil unless cancel_controller && @hooks.any?(Hooks::StreamWatch::EVENT)
@@ -2322,8 +2349,8 @@ module Samagotchi
       rescue StandardError
         nil
       end
-      # Turn-scoped sink: receives the original event hash (no event_seq),
-      # byte-for-byte unchanged. Sink errors are isolated and never break the
+      # Turn-scoped sink: receives the event hash as the stream handler
+      # passed it (no event_seq; a :generation_completed has its report). Sink errors are isolated and never break the
       # kernel loop (same as KernelLoop's own handling).
       if on_event
         begin

data/lib/samagotchi/events.rb

@@ -13,7 +13,7 @@ module Samagotchi
     TURN_KEPT = %i[turn_completed turn_canceled].freeze
     # The kinds of a running turn's parts (Bridge::TurnAccumulator), which a
     # joining UI replays as live events.
-    PART_KINDS = %w[thinking text tool input steer reminder notice].freeze
+    PART_KINDS = %w[generation thinking text tool input steer reminder notice].freeze
     # Types no Engine emits that a UI handles: the Bridge's stream frames
     # and the web's one synthetic replay event (a prompt merged into the
     # turn, turn_events.js snapshotEvents).

data/lib/samagotchi/guardrail_wiring.rb

@@ -279,7 +279,8 @@ module Samagotchi
         @failures.add("rules in config.yml", e.message, required: true, group: :rules)
       end
       Guardrails::Rules.new(rules + bundle_rules, disable: disable,
-                            enabled: Samagotchi::Config.get("guardrails.enabled") != false)
+                            enabled: Samagotchi::Config.get("guardrails.enabled") != false,
+                            mode: Samagotchi::Config.get("guardrails.mode") || "auto")
     end
 
     # The dry-run diff of an edit/write call for its approval; a preview

data/lib/samagotchi/guardrails/approval.rb

@@ -44,6 +44,8 @@ module Samagotchi
             args: args_for_card(targets),
             cwd: targets&.cwd,
             repo_root: targets&.repo_root,
+            # The repository's name (a worktree's main checkout's folder).
+            repo_name: targets&.repo_name,
             branch: verdict.context&.branch(targets&.cwd || verdict.context.cwd),
             rule: verdict.rule,
             source: verdict.source,
@@ -92,7 +94,7 @@ module Samagotchi
       end
 
       def label(scope, verdict)
-        place = verdict.targets&.repo_root ? "in this repo" : "in this directory"
+        place = verdict.targets&.repo_root ? "in this repo (#{verdict.targets.repo_name})" : "in this directory"
         case scope
         when "once" then "Allow once"
         when "session" then "Allow this call for the session"
@@ -129,9 +131,8 @@ module Samagotchi
         what = Approval.args_text(targets&.args, limit: ARGS_CHARS) if what.to_s.empty?
         lines = ["#{tool}: #{what}"]
         if targets
-          repo = targets.repo_root
           branch = verdict.context&.branch(targets.cwd)
-          where = repo ? "repo #{File.basename(repo)}#{", branch #{branch}" if branch}" : "not in a repo"
+          where = targets.repo_root ? "repo #{targets.repo_name}#{", branch #{branch}" if branch}" : "not in a repo"
           lines << "  in #{targets.cwd} (#{where})"
         end
         who = verdict.rule ? ["rule #{verdict.rule}", verdict.source].compact.join(", ") : (verdict.source || "hook")

data/lib/samagotchi/guardrails/approvals.rb

@@ -16,6 +16,10 @@ module Samagotchi
     #             this session;
     #   repo    — this exact call in this repo (the cwd outside a repo);
     #   rule    — anything this rule (from this source) asks about here.
+    # "This repo" is the repository (repo: its common git dir), so an
+    # approval holds in every worktree of it; repo_root, the worktree it
+    # was given in, is kept for showing, and an entry from before repo:
+    # still matches that exact folder.
     # "once" is never stored. A file that doesn't parse is moved aside to
     # approvals.json.corrupt-<UTC time>[-N], with a warning, and the store
     # starts empty: it only means more asks, and nothing is overwritten.
@@ -62,13 +66,14 @@ module Samagotchi
       def self.find_in(list, verdict)
         key = key_for(verdict)
         place = place_for(verdict)
+        repo = verdict.targets&.repo
+        here = ->(e) { e["repo"] ? e["repo"] == repo : e["repo_root"] == place }
         session_id = verdict.context&.session_id
         list.find do |e|
           case e["scope"]
           when "session" then session_id && e["session_id"] == session_id && e["key"] == key
-          when "repo" then e["repo_root"] == place && e["key"] == key
-          when "rule" then verdict.rule && e["rule"] == verdict.rule && e["source"] == verdict.source &&
-                           e["repo_root"] == place
+          when "repo" then here.(e) && e["key"] == key
+          when "rule" then verdict.rule && e["rule"] == verdict.rule && e["source"] == verdict.source && here.(e)
           end
         end
       end
@@ -81,8 +86,9 @@ module Samagotchi
                   "rule" => verdict.rule, "source" => verdict.source, "created_at" => Time.now.utc.iso8601 }
         case scope
         when "session" then entry.merge!("session_id" => verdict.context&.session_id, "key" => key_for(verdict))
-        when "repo" then entry.merge!("repo_root" => place_for(verdict), "key" => key_for(verdict))
-        when "rule" then entry["repo_root"] = place_for(verdict)
+        when "repo"
+          entry.merge!("repo_root" => place_for(verdict), "repo" => verdict.targets&.repo, "key" => key_for(verdict))
+        when "rule" then entry.merge!("repo_root" => place_for(verdict), "repo" => verdict.targets&.repo)
         end
         entry.compact
       end

data/lib/samagotchi/guardrails/context.rb

@@ -24,6 +24,11 @@ module Samagotchi
       end
 
       def repo_root(dir = @cwd) = @git.root(dir)
+      # The git hooks dir of +dir+'s repo (core.hooksPath honoured), or nil.
+      def hooks_dir(dir = @cwd) = @git.hooks(dir)
+      # +dir+'s repository: its absolute common git dir (<root>/.git for a
+      # plain checkout; the same for every worktree of it), or nil.
+      def repo(dir = @cwd) = @git.common_dir(dir)
       def branch(dir = @cwd) = @git.branch(dir)
 
       # The hook event's context: hash.
@@ -41,6 +46,8 @@ module Samagotchi
       end
 
       def root(dir) = info(dir)[:root]
+      def hooks(dir) = info(dir)[:hooks]
+      def common_dir(dir) = info(dir)[:common_dir]
       def branch(dir) = info(dir)[:branch]
 
       private
@@ -53,16 +60,16 @@ module Samagotchi
       def probe(dir)
         return {} unless File.directory?(dir)
 
-        out, status = Open3.capture2e("git", "-C", dir, "rev-parse", "--show-toplevel", "--abbrev-ref", "HEAD")
-        lines = out.lines.map(&:strip)
-        # A repo with no commits yet has no HEAD: only the root answers.
-        unless status.success?
-          out, status = Open3.capture2e("git", "-C", dir, "rev-parse", "--show-toplevel")
-          return {} unless status.success?
+        paths = ["--show-toplevel", "--git-path", "hooks", "--git-common-dir"]
+        out, status = Open3.capture2e("git", "-C", dir, "rev-parse", *paths, "--abbrev-ref", "HEAD")
+        # A repo with no commits yet has no HEAD: only the paths answer.
+        out, status = Open3.capture2e("git", "-C", dir, "rev-parse", *paths) unless status.success?
+        return {} unless status.success?
 
-          lines = [out.strip]
-        end
-        { root: lines[0], branch: lines[1] }
+        lines = out.lines.map(&:strip)
+        # --git-path and --git-common-dir are relative to dir (core.hooksPath too).
+        { root: lines[0], hooks: lines[1] && File.expand_path(lines[1], dir),
+          common_dir: lines[2] && File.expand_path(lines[2], dir), branch: lines[3] }
       rescue SystemCallError
         {}
       end

data/lib/samagotchi/guardrails/parent_approvals.rb

@@ -2,6 +2,7 @@
 
 require_relative "../config"
 require_relative "../paths"
+require_relative "../memory_paths"
 require_relative "../hooks/loader"
 require_relative "approval"
 require_relative "protected_paths"
@@ -42,9 +43,12 @@ module Samagotchi
       # Rules that ask about chi's own config and hooks: the core
       # ProtectedPaths asks and the guardrails bundle's shell rule.
       PROTECTED_RULES = %w[chi-config chi-hooks shell-touches-chi].freeze
-      # A shell command naming chi's config, hooks or guardrails (the
-      # guardrails bundle's shell-touches-chi, less .git/hooks).
+      # A shell command naming chi's config, hooks or guardrails as text
+      # (broad: a parent may not allow what only looks like one).
       CHI_TEXT = %r{\.config/samagotchi|samagotchi/config\.yml|samagotchi/hooks|samagotchi/guardrails|memories/\.bundles}
+      # The guardrails bundle's shell-touches-chi, for a word it can't
+      # resolve to a path (Guardrails::ShellPaths): CHI_TEXT and .git/hooks.
+      CHI_SHELL_TEXT = Regexp.union(CHI_TEXT, %r{\.git/hooks})
 
       module_function
 
@@ -101,10 +105,12 @@ module Samagotchi
         command.match?(CHI_TEXT) || dirs.any? { |dir| command.include?(dir) || command.include?(ProtectedPaths.real(dir)) }
       end
 
-      # chi's config dir, the hooks dir and the approval store's dir.
+      # chi's config dir, the hooks dir, the approval store's dir and the
+      # installed bundles' dir.
       def chi_dirs
         hooks = begin Hooks::Loader.hooks_dir rescue nil end
-        [ConfigFile.config_dir, hooks, File.join(Paths.state_dir, "guardrails")]
+        bundles = begin MemoryPaths.bundles_dir rescue nil end
+        [ConfigFile.config_dir, hooks, File.join(Paths.state_dir, "guardrails"), bundles]
           .compact.map { |dir| dir.to_s.chomp("/") }.reject(&:empty?).uniq
       end