samagotchi 0.8.0 → 0.9.0

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,8 @@
 require_relative "../tools/tool_path"
 require_relative "../tools/memory"
 require_relative "../log"
+require_relative "model_size"
+require_relative "../memory_bundle/index_sync"
 
 module Samagotchi
   module Guardrails
@@ -16,6 +18,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 +29,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 +61,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 +102,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,10 +115,23 @@ 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).
+      # A memory's file doesn't count (MemoryBundle::IndexSync.memory_scope):
+      # write/edit there is what memory_write does, unasked; index.md, the
+      # bundles dir and the rest of chi's config dir still count.
       def outside_repo?
         root = @repo_root || @cwd
-        @paths.any? { |p| p != root && !p.start_with?(File.join(root, "")) }
+        @paths.any? do |p|
+          p != root && !p.start_with?(File.join(root, "")) && !MemoryBundle::IndexSync.memory_scope(p)
+        end
       end
 
       # The hook event's targets: hash.

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/log_subscriber.rb

@@ -123,8 +123,12 @@ module Samagotchi
     def on_tool_call_completed(event)
       # A tool's output can be any bytes (invalid UTF-8 would fail the match).
       output = event[:output].to_s.scrub
+      # ms leaves out a guardrail approval wait (waited_ms, logged apart).
+      waited = event[:waited_ms].to_i
+      ms = since(@tool_started_at.delete([event[:iteration], event[:call_index]]))
+      ms = [ms - waited, 0].max if ms
       log(:info, :tool_call_completed, iteration: event[:iteration], tool: event[:tool],
-                                       ms: since(@tool_started_at.delete([event[:iteration], event[:call_index]])),
+                                       ms: ms, waited_ms: (waited if waited.positive?),
                                        output_chars: output.length, truncated: event[:output_truncated] || nil,
                                        error: tool_error?(output) || nil)
     end

data/lib/samagotchi/memory_bundle/index_sync.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "index_updater"
+require_relative "../tools/memory"
+require_relative "../model_overlay"
+require_relative "../log"
+
+module Samagotchi
+  module MemoryBundle
+    # Keeps a memory's managed index.md line current when the file tools
+    # (write, edit) change it, as memory_write does: the ToolRunner calls
+    # .refresh after a write/edit that changed its file (one it could diff:
+    # a memory over 1 MB isn't refreshed). The line's description is kept.
+    #
+    # Only a *.md right in the project or system memories dir (the dirs
+    # memory_write writes to) counts: not index.md, not a hidden file, not a
+    # model overlay (<name>.<key>.md next to its <name>.md; a memory whose
+    # name has a dot and a sibling of the same stem reads as an overlay too,
+    # a leftover ambiguity). Writes into another project's folder and
+    # execute's writes aren't seen.
+    module IndexSync
+      SCOPES = %w[project system].freeze
+
+      # @param path [String] the file write/edit changed
+      # @return [Boolean] whether an index line was written
+      def self.refresh(path)
+        path = File.expand_path(path.to_s)
+        scope = memory_scope(path)
+        return false unless scope && File.file?(path)
+
+        name = File.basename(path, ".md")
+        return false if overlay?(path, name)
+
+        IndexUpdater.update_index(scope, name, File.size(path), nil)
+      rescue StandardError => e
+        Log.warn(:memory, "index_sync_failed", path: path, error: "#{e.class}: #{e.message}")
+        false
+      end
+
+      # "project" or "system" when +path+ is a memory's file (or an
+      # overlay's): a *.md right in that scope's memories dir, not index.md,
+      # not hidden, not a symlink. nil otherwise. The guardrails' outside_repo
+      # uses it too: write/edit there is what memory_write does. A symlink
+      # isn't: write/edit follow it to wherever it points, memory_write
+      # replaces the link.
+      def self.memory_scope(path)
+        path = File.expand_path(path.to_s)
+        name = File.basename(path, ".md")
+        return nil unless File.extname(path) == ".md"
+        return nil if name == IndexUpdater::MEMORY_INDEX || name.start_with?(".") || File.symlink?(path)
+
+        dir = real(File.dirname(path))
+        SCOPES.find { |s| real(Tools::MemoryRead.memories_dir(s)) == dir }
+      rescue StandardError
+        nil
+      end
+
+      def self.overlay?(path, name)
+        match = File.basename(path).match(ModelOverlay::OVERLAY_SUFFIX_PATTERN)
+        return false unless match
+
+        base = name.delete_suffix(".#{match[1]}")
+        File.file?(File.join(File.dirname(path), "#{base}.md"))
+      end
+
+      def self.real(dir)
+        File.realpath(dir)
+      rescue SystemCallError
+        File.expand_path(dir)
+      end
+    end
+  end
+end

data/lib/samagotchi/memory_bundle/installer.rb

@@ -86,6 +86,8 @@ module Samagotchi
         all_files_in_bundle = []
         provenance = Provenance.new(name: @name)
         existing_provenance = provenance.read
+        # A plain install over an installed bundle: summary points at upgrade.
+        @reinstall = existing_provenance && !@upgrade && !@force && !@dry_run
 
         Dir.glob(File.join(normalized_dir, "*.md")).each do |file_path|
           file_key = File.basename(file_path)
@@ -125,12 +127,17 @@ module Samagotchi
                 classification = Merger.classify(base_path: base_path, current_path: target_path, incoming_path: file_path)
                 @results[file_key] = { status: classification.to_s }
                 @conflicts[file_key] = { base: base_path, current: target_path, incoming: file_path } if classification == :conflict
+              elsif FileUtils.identical?(file_path, target_path)
+                @results[file_key] = { status: "skipped", reason: "already up to date" }
               else
                 @results[file_key] = { status: "would_skip" }
               end
             else
               @results[file_key] = { status: "would_install" }
             end
+          elsif File.exist?(target_path) && !@force && FileUtils.identical?(file_path, target_path)
+            @results[file_key] = { status: "skipped", reason: "already up to date" }
+            update_target_index(target_scope, target_path, file_key)
           elsif File.exist?(target_path) && !@force
             @results[file_key] = { status: "skipped", reason: "already exists" }
             @warnings << "Skipped #{file_key} (already exists; use --force to overwrite)"
@@ -252,13 +259,19 @@ module Samagotchi
         if @dry_run
           incoming_rules.each { |src| @results["guardrails/#{File.basename(src)}"] = { status: "would_install" } }
         else
+          # Same bytes as installed: reported as up to date, not "Installed".
+          unchanged = incoming_rules.select do |src|
+            dest = File.join(guardrails_target, File.basename(src))
+            File.file?(dest) && FileUtils.identical?(src, dest)
+          end
           FileUtils.rm_rf(guardrails_target)
           unless incoming_rules.empty?
             FileUtils.mkdir_p(guardrails_target)
             incoming_rules.each do |src|
               dest = File.join(guardrails_target, File.basename(src))
               FileUtils.cp(src, dest)
-              @results["guardrails/#{File.basename(src)}"] = { status: "installed" }
+              @results["guardrails/#{File.basename(src)}"] =
+                unchanged.include?(src) ? { status: "skipped", reason: "already up to date" } : { status: "installed" }
               guardrail_files_for_provenance[File.basename(src)] = dest
             end
           end
@@ -278,7 +291,8 @@ module Samagotchi
           all_files_in_bundle.each do |file_key|
             next if @conflicts.key?(file_key)
             status = @results[file_key] ? @results[file_key][:status].to_s : nil
-            next if %w[kept kept_pruned fast_forward updated].include?(status)
+            # skipped: not copied, so a local edit isn't a bad download.
+            next if %w[kept kept_pruned fast_forward updated skipped].include?(status)
             # For dry-run, fast_forward would appear as "fast_forward", updated not yet
             target_path = File.join(target_dir, file_key)
             next unless File.exist?(target_path)
@@ -340,7 +354,13 @@ module Samagotchi
           else
             all_files_in_bundle.each do |file_key|
               target_path = File.join(target_dir, file_key)
-              provenance_files[file_key] = target_path if File.exist?(target_path)
+              next unless File.exist?(target_path)
+
+              # Skipped for a local edit: keep the installed base, so the
+              # next upgrade still sees the edit (not a fast-forward over it).
+              base_path = provenance.base_path(file_key)
+              kept = existing_provenance && @results.dig(file_key, :reason) == "already exists" && File.exist?(base_path)
+              provenance_files[file_key] = kept ? base_path : target_path
             end
           end
           # Build hooks metadata for provenance
@@ -409,6 +429,7 @@ module Samagotchi
         lines << "Conflicts: #{conflicts.join(', ')}" unless conflicts.empty?
         lines.concat(@warnings) unless @warnings.empty?
         lines.concat(@placeholder_warnings) unless @placeholder_warnings.empty?
+        lines << "#{@name} is already installed; `chi bundle upgrade #{@name}` updates it and keeps local edits" if @reinstall
 
         lines.any? ? lines.join("\n") : "No files to install."
       end

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/session_manager.rb

@@ -224,11 +224,11 @@ module Samagotchi
     #   a turn running, recap = the saved recap's first sentence, project =
     #   Session#project_root
     def self.session_summaries(live: false, cwd: nil, limit: nil, include_tests: true, exclude: nil, state_dir: nil,
-                               project_root: nil, include_archived: false)
+                               project_root: nil, include_archived: false, sort: nil, order: nil)
       sd = state_dir || Session.default_state_dir
       root = cwd && folder_path(cwd)
       roots = {}
-      summaries = Session.list(state_dir: sd, sort: "updated_at", order: "desc", project_root: project_root,
+      summaries = Session.list(state_dir: sd, sort: sort || "updated_at", order: order || "desc", project_root: project_root,
                                            include_archived: include_archived).lazy
                          .reject { |s| (!include_tests && s.test_run) || s.id == exclude }
                          .select { |s| root.nil? || in_folder?(s.working_directory, root) }

data/lib/samagotchi/session_metrics.rb

@@ -427,7 +427,8 @@ module Samagotchi
         ).merge(
           status: status.empty? ? "ok" : status,
           completed_at: finished_at.iso8601(3),
-          duration_ms: elapsed_ms(active[:started_monotonic])
+          # Less a guardrail approval wait (ToolRunner's waited_ms).
+          duration_ms: [elapsed_ms(active[:started_monotonic]) - event[:waited_ms].to_i, 0].max
         )
       end
     end

data/lib/samagotchi/sessions_command.rb

@@ -120,11 +120,12 @@ module Samagotchi
     end
 
     def list_summaries(project, scope_note)
-      live, cwd, limit, include_archived, format = @opts.values_at(:live, :cwd, :limit, :include_archived, :format)
+      live, cwd, limit, include_archived, format, sort, order =
+        @opts.values_at(:live, :cwd, :limit, :include_archived, :format, :sort, :order)
       summaries = Samagotchi::SessionManager.session_summaries(
         live: live, cwd: cwd, limit: limit || (live ? 10 : nil), include_tests: Samagotchi::Session.test_session_env?,
         project_root: project,
-        include_archived: include_archived
+        include_archived: include_archived, sort: sort, order: order
       )
       case format
       when "json"

data/lib/samagotchi/system_prompt.rb

@@ -175,11 +175,12 @@ module Samagotchi
           System scope:  ~/.config/samagotchi/memories/ (cross-project)
           memory_read accepts optional scope (project|system).
           memory_write requires explicit scope and entry name.
+          For a small change to an existing memory, `edit` its file (<scope dir>/<name>.md)
+          instead of rewriting it all with memory_write; its index line is refreshed either way.
           User prompts may contain memory shorthand like #entry_name.
           Treat #entry_name as a memory reference, not as a file path.
           If shorthand includes a scope prefix, such as #project/entry_name or #system/entry_name,
           preserve that scope when reading the memory.
-          Keep each scope's index.md updated when adding/updating entries.
           Each scope's `index.md` is auto-maintained by `memory_write` (one
           managed line per entry with name/scope/date/size); free-form sections
           are preserved. The verbatim `index` write (`name: "index"`) is kept.

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_declarations.rb

@@ -123,7 +123,7 @@ module Samagotchi
       },
       {
         name: "memory_write",
-        description: "Write or update a memory entry in scoped memories. Scope is required: project or system. Use the `name` parameter for the entry name (use `name`, NOT `path` — the file tools use `path`); each scope's index.md is auto-maintained (one managed line per entry); use name \"index\" to write the index file verbatim. If the user asks to save guidance for the current model only, pass current_model_only: true to save a model-specific overlay.",
+        description: "Write or update a memory entry in scoped memories. Scope is required: project or system. Use the `name` parameter for the entry name (use `name`, NOT `path` — the file tools use `path`); each scope's index.md is auto-maintained (one managed line per entry); use name \"index\" to write the index file verbatim. For a small change to an existing memory (a step, a line), `edit` its file (<scope dir>/<name>.md) instead of rewriting it all; its index line is refreshed either way. If the user asks to save guidance for the current model only, pass current_model_only: true to save a model-specific overlay.",
         parameters: {
           type: "object",
           properties: {

data/lib/samagotchi/tool_runner.rb

@@ -6,6 +6,7 @@ require_relative "vision_context"
 require_relative "log"
 require_relative "edit_preview"
 require_relative "tools/tool_path"
+require_relative "memory_bundle/index_sync"
 
 module Samagotchi
   # The single per-call path both loops use: the tool_call_started and
@@ -25,8 +26,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,11 +57,18 @@ 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)
+      refresh_memory_index(call) if diff
       result = approved(result, verdict) if verdict.allow? && verdict.decided_by
       result, images = attach_images(call, result) if result[:images]
 
@@ -75,6 +85,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] }
@@ -108,6 +119,12 @@ module Samagotchi
       nil
     end
 
+    # A write/edit that changed a memory's file refreshes its index line,
+    # as memory_write does (MemoryBundle::IndexSync; a no-op elsewhere).
+    def refresh_memory_index(call)
+      MemoryBundle::IndexSync.refresh(Tools::ToolPath.normalize(call[:path]))
+    end
+
     # A tool's output can hold bytes that aren't UTF-8 (`printf '\xff'`, a
     # binary file). They become "?" here, before the output reaches the
     # conversation, the events and the saved session: JSON.generate raises

data/lib/samagotchi/tools/memory.rb

@@ -204,9 +204,8 @@ module Samagotchi
         # The verbatim "write to index.md" behavior (path: "index") must not
         # trigger upsert logic.
         unless entry_name == MEMORY_INDEX
-          index_path = self.index_path_for(resolved_scope)
           if manage_index(resolved_scope, entry_name, bytes, description)
-            message += " Index updated: #{index_path}"
+            message += " Index line refreshed automatically."
           end
         end
 

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
   # 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.9.0
 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
@@ -254,6 +256,7 @@ files:
 - lib/samagotchi/log_subscriber.rb
 - lib/samagotchi/memory_bundle.rb
 - lib/samagotchi/memory_bundle/builder.rb
+- lib/samagotchi/memory_bundle/index_sync.rb
 - lib/samagotchi/memory_bundle/index_updater.rb
 - lib/samagotchi/memory_bundle/installer.rb
 - lib/samagotchi/memory_bundle/listing.rb