samagotchi 0.8.1 → 0.10.0

data/lib/samagotchi/config.rb

@@ -6,6 +6,7 @@ require "fileutils"
 require "uri"
 require "set"
 require_relative "atomic_file"
+require_relative "config_text_edit"
 require_relative "log"
 require_relative "paths"
 
@@ -893,33 +894,39 @@ module Samagotchi
       nil
     end
 
-    def write_default_model!(model_name, env: ENV, path: global_path(env: env))
-      resolved = model_name.to_s.strip
-      raise ArgumentError, "model name is required" if resolved.empty?
+    # A top-level section of config.yml as written (nil when absent or the
+    # file doesn't parse); a reader checks its shape.
+    def section(name, env: ENV, path: global_path(env: env))
+      data = read_yaml(path: path)
+      data.is_a?(Hash) ? data[name] : nil
+    end
 
-      if resolved.include?(":") || resolved.include?("/")
-        sep = resolved.include?(":") ? ":" : "/"
-        prefix = resolved.split(sep, 2).first.to_s.strip.downcase
-        begin
-          hosts = hosts_config(env: env, path: path)
-          if hosts && !hosts.empty? && !hosts.key?(prefix) && prefix.match?(HOST_NAME_RE)
-          end
-        rescue StandardError
-          nil
-        end
+    # config.yml `bundles:`: each bundle's settings by name, for its hooks.
+    # @return [Hash{String => Hash}] {} when absent; a section that isn't a
+    #   mapping warns and counts as absent
+    def bundle_settings(env: ENV, path: global_path(env: env))
+      raw = section("bundles", env: env, path: path)
+      return {} if raw.nil?
+      unless raw.is_a?(Hash)
+        Log.warn(:hooks, "bundles_section_invalid", echo: "[samagotchi:hooks] config.yml bundles: must be a mapping of bundle name to settings; ignored")
+        return {}
       end
 
-      raw_data = read_yaml(env: env, path: path) || {}
+      raw.each_with_object({}) { |(name, value), acc| acc[name.to_s] = value.is_a?(Hash) ? value : {} }
+    rescue StandardError
+      {}
+    end
 
-      raw_data["default"] ||= {}
-      if raw_data["default"].is_a?(Hash)
-        raw_data["default"]["model"] = resolved
-      else
-        raw_data["default"] = { "model" => resolved }
-      end
-      FileUtils.mkdir_p(File.dirname(path))
-      AtomicFile.write(path, YAML.dump(raw_data))
-      clear_yaml_cache!(path)
+    # Sets default.model in config.yml; the rest of the file, comments
+    # included, stays as written (ConfigTextEdit).
+    def write_default_model!(model_name, env: ENV, path: global_path(env: env))
+      resolved = model_name.to_s.strip
+      raise ArgumentError, "model name is required" if resolved.empty?
+
+      expected = deep_copy(read_yaml(env: env, path: path) || {})
+      expected["default"] = {} unless expected["default"].is_a?(Hash)
+      expected["default"]["model"] = resolved
+      write_config_key(path, "default", "model", resolved, expected)
       Samagotchi::Config.reload!(cli_overrides: Samagotchi::Config.cli_overrides)
       true
     end
@@ -1003,50 +1010,58 @@ module Samagotchi
       aliases.fetch(value.downcase, value)
     end
 
+    # Words /model takes as arguments (clear/default/none/off reset the
+    # runtime model), so no alias may be named after one.
     RESERVED_MODEL_ALIASES = %w[clear default none off].freeze
 
-    def write_model_alias!(alias_name, model_name, env: ENV, path: global_path(env: env))
+    # What is wrong with +alias_name+ as an alias for +target+, or nil.
+    def model_alias_error(alias_name, target)
       alias_key = alias_name.to_s.strip
-      raise ArgumentError, "alias name is required" if alias_key.empty?
-      raise ArgumentError, "model name is required" if model_name.to_s.strip.empty?
+      return "alias name is required" if alias_key.empty?
 
       lowered_key = alias_key.downcase
-      raise ArgumentError, "alias name '#{alias_key}' is reserved" if RESERVED_MODEL_ALIASES.include?(lowered_key)
-      raise ArgumentError, "alias name must not contain whitespace" if alias_key.match?(/\s/)
-      raise ArgumentError, "alias name must not start with '-'" if alias_key.start_with?("-")
-      raise ArgumentError, "alias name must not contain '/'" if alias_key.include?("/")
-      unless alias_key.match?(/\A[a-z0-9][a-z0-9._-]*\z/i)
-        raise ArgumentError, "alias name must match /[a-z0-9][a-z0-9._-]*/i (got '#{alias_key}')"
-      end
+      return "alias name '#{alias_key}' is reserved" if RESERVED_MODEL_ALIASES.include?(lowered_key)
+      return "alias name must not contain whitespace" if alias_key.match?(/\s/)
+      return "alias name must not start with '-'" if alias_key.start_with?("-")
+      return "alias name must not contain '/'" if alias_key.include?("/")
+      return "alias name must match /[a-z0-9][a-z0-9._-]*/i (got '#{alias_key}')" unless alias_key.match?(/\A[a-z0-9][a-z0-9._-]*\z/i)
+      return "alias must not point to itself" if lowered_key == target.to_s.strip.downcase
 
-      resolved_model = model_name.to_s.strip
-      raise ArgumentError, "alias must not point to itself" if lowered_key == resolved_model.downcase
-
-      raw_data = read_yaml(env: env, path: path) || {}
+      nil
+    end
 
-      aliases_hash = raw_data[MODEL_ALIASES_KEY]
-      unless aliases_hash.is_a?(Hash)
-        aliases_hash = {}
-        raw_data[MODEL_ALIASES_KEY] = aliases_hash
-      end
+    def write_model_alias!(alias_name, model_name, env: ENV, path: global_path(env: env))
+      error = model_alias_error(alias_name, model_name)
+      raise ArgumentError, error if error
+      raise ArgumentError, "model name is required" if model_name.to_s.strip.empty?
 
-      # Normalize existing alias keys to downcase to avoid duplicates like Qwen/qwen
-      normalized = {}
-      aliases_hash.each do |k, v|
-        nk = k.to_s.strip.downcase
-        next if nk.empty?
-        normalized[nk] = v.to_s.strip unless v.to_s.strip.empty?
-      end
-      raw_data[MODEL_ALIASES_KEY] = normalized
+      lowered_key = alias_name.to_s.strip.downcase
+      resolved_model = model_name.to_s.strip
 
-      previous = normalized[lowered_key]
-      normalized[lowered_key] = resolved_model
+      previous = model_aliases(env: env, path: path)[lowered_key]
+      expected = deep_copy(read_yaml(env: env, path: path) || {})
+      aliases = expected[MODEL_ALIASES_KEY].is_a?(Hash) ? expected[MODEL_ALIASES_KEY] : {}
+      aliases.delete_if { |k, _| k.to_s.strip.downcase == lowered_key }
+      aliases[lowered_key] = resolved_model
+      expected[MODEL_ALIASES_KEY] = aliases
+      write_config_key(path, MODEL_ALIASES_KEY, lowered_key, resolved_model, expected)
+      previous
+    end
 
-      FileUtils.mkdir_p(File.dirname(path))
-      AtomicFile.write(path, YAML.dump(raw_data))
+    # Write +section+.+key+ = +value+ into config.yml (+expected+: the whole
+    # file's data after it), through a symlink, keeping the file's mode.
+    def write_config_key(path, section, key, value, expected)
+      target = File.exist?(path) ? File.realpath(path) : path
+      text = File.file?(target) ? File.read(target, encoding: "UTF-8") : nil
+      FileUtils.mkdir_p(File.dirname(target))
+      perm = File.stat(target).mode & 0o7777 if text
+      AtomicFile.write(target, ConfigTextEdit.set(text, section: section, key: key, value: value, expected: expected), perm: perm)
       clear_yaml_cache!(path)
-      previous
     end
+    private_class_method :write_config_key
+
+    def deep_copy(data) = Marshal.load(Marshal.dump(data))
+    private_class_method :deep_copy
 
     def nonempty_str(value)
       str = value.to_s.strip

data/lib/samagotchi/config_text_edit.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "psych"
+
+module Samagotchi
+  # Sets one section.key in config.yml text, line by line, so the user's
+  # comments and layout stay (YAML.dump would drop them), the way
+  # Bootstrap::ConfigWriter inserts a host. A key already in the block is
+  # replaced on its line (a comment after the old value goes with it), a new
+  # one goes at the end of the block, a missing section at the end of the
+  # file. The result is parsed again and must equal +expected+; when it
+  # doesn't, or the text is something a line edit can't handle (a flow-style
+  # section, anchors, a duplicate section), the whole file is dumped from
+  # +expected+ instead.
+  module ConfigTextEdit
+    DEFAULT_INDENT = 2
+
+    module_function
+
+    # @param text [String, nil] the file's text (nil: no file)
+    # @param section [String] a top-level key ("default")
+    # @param key [String] the key under it; an existing key matches in any case
+    # @param value [String] the value, written as a quoted string
+    # @param expected [Hash] the whole file's data after the change
+    # @return [String] the new text
+    def set(text, section:, key:, value:, expected:)
+      edited = text && edit(text, section, key, value)
+      edited && parse(edited) == expected ? edited : YAML.dump(expected)
+    rescue Psych::Exception
+      YAML.dump(expected)
+    end
+
+    def edit(text, section, key, value)
+      return nil if anchors?(text)
+
+      # A key the lines below can't see (flow style, odd quoting) would end up
+      # written twice, and YAML keeps the last one without a word.
+      original = parse(text)
+      original = {} unless original.is_a?(Hash)
+      section_data = original[section]
+      has_key = section_data.is_a?(Hash) && section_data.keys.any? { |k| k.to_s.downcase == key.downcase }
+
+      eol = text.include?("\r\n") ? "\r\n" : "\n"
+      lines = text.split(/(?<=\n)/)
+      lines[-1] = "#{lines[-1]}#{eol}" if lines.any? && !lines[-1].end_with?("\n")
+      header = /\A#{Regexp.escape(section)}:[ \t]*(#.*)?\z/
+      starts = lines.each_index.select { |i| lines[i].chomp.match?(header) }
+      return nil if starts.length > 1
+
+      return nil if starts.empty? && original.key?(section)
+
+      if starts.empty?
+        lines.concat(["#{section}:#{eol}", "#{" " * DEFAULT_INDENT}#{key}: #{scalar(value)}#{eol}"])
+        return lines.join
+      end
+
+      at = starts.first
+      stop = at + 1
+      stop += 1 while stop < lines.length && inside_block?(lines[stop])
+      children = lines[(at + 1)...stop].reject { |line| line.strip.empty? || comment?(line) }
+      child = children.first ? indent(children.first) : DEFAULT_INDENT
+      new_line = "#{" " * child}#{key}: #{scalar(value)}#{eol}"
+      found = ((at + 1)...stop).find { |i| indent(lines[i]) == child && key_of(lines[i])&.downcase == key.downcase }
+      if found
+        lines[found] = new_line
+      else
+        return nil if has_key
+
+        stop -= 1 while stop > at + 1 && (lines[stop - 1].strip.empty? || (comment?(lines[stop - 1]) && indent(lines[stop - 1]) < child))
+        lines.insert(stop, new_line)
+      end
+      lines.join
+    end
+
+    def key_of(line)
+      line[/\A\s*(["']?)([^"':#\s][^"':#]*?)\1:(?:\s|\z)/, 2]
+    end
+
+    def inside_block?(line)
+      return true if line.strip.empty?
+      return false if line.start_with?("---", "...")
+
+      line.start_with?(" ", "\t") || comment?(line)
+    end
+
+    def comment?(line) = line.lstrip.start_with?("#")
+    def indent(line) = line[/\A */].length
+
+    # JSON's quoting is valid YAML: model ids hold "/" and ":".
+    def scalar(value) = JSON.generate(value.to_s)
+
+    def parse(text) = YAML.safe_load(text, permitted_classes: [], aliases: false)
+
+    def anchors?(text)
+      stack = [Psych.parse_stream(text)]
+      until stack.empty?
+        node = stack.pop
+        return true if node.is_a?(Psych::Nodes::Alias) || (node.respond_to?(:anchor) && node.anchor)
+
+        stack.concat(Array(node.children)) if node.respond_to?(:children)
+      end
+      false
+    end
+  end
+end

data/lib/samagotchi/desktop_command.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "cli/command"
+require_relative "cli/flags"
 require_relative "desktop"
 
 module Samagotchi
   # `chi desktop install|upgrade|uninstall|status`: the native helper that
   # sends selected text to live sessions as a context note (macOS for now).
   class DesktopCommand
+    include CLI::Command
+
     USAGE = <<~TEXT
       Usage: chi desktop <install|upgrade|uninstall|status>
         install [--force] [--login]
@@ -21,6 +25,15 @@ module Samagotchi
 
     SUBCOMMANDS = %w[install upgrade uninstall status].freeze
 
+    # --no-register (hidden) on each; --help is an unknown option after the
+    # subcommand.
+    FLAGS = CLI::Flags.new(args: false) { |f| f.switch "--no-register" }
+    INSTALL_FLAGS = CLI::Flags.new(args: false) do |f|
+      f.switch "--no-register"
+      f.switch "--force"
+      f.switch "--login"
+    end
+
     # @param platform [#call] register: → a Desktop::MacOS-like object
     def initialize(argv, stdout: $stdout, stderr: $stderr, platform: nil, supported: Desktop.supported?)
       @argv = argv.dup
@@ -33,7 +46,7 @@ module Samagotchi
     # @return [Integer] 0 ok, 1 failed, 2 usage
     def run
       sub = @argv.shift
-      if sub.nil? || %w[-h --help help].include?(sub)
+      if sub.nil? || HELP_WORDS.include?(sub)
         @stdout.puts(USAGE)
         return 0
       end
@@ -44,7 +57,9 @@ module Samagotchi
         return 1
       end
 
-      options = parse(sub) or return 2
+      options = parse(sub)
+      return options if options.is_a?(Integer)
+
       # --no-register (hidden): no pbs/lsregister/open/pkill, for installs
       # into temp dirs (HOME=…) that must not touch the real Services.
       helper = @platform.call(register: !options[:no_register])
@@ -56,17 +71,14 @@ module Samagotchi
 
     private
 
-    # @return [Hash, nil] nil after a usage error
+    def command_name = "chi desktop"
+
+    # @return [Hash, Integer] the options, or the usage error's exit status
     def parse(sub)
-      flags = { "--no-register" => :no_register }
-      flags.merge!("--force" => :force, "--login" => :login) if sub == "install"
-      @argv.each_with_object({}) do |arg, options|
-        unless flags.key?(arg)
-          usage_error("unknown option #{arg}")
-          return nil
-        end
-        options[flags[arg]] = true
-      end
+      parsed = (sub == "install" ? INSTALL_FLAGS : FLAGS).parse(@argv)
+      return usage_error(parsed.error.message) if parsed.error
+
+      parsed.options
     end
 
     # The warnings come after a done install: a refused or failed one
@@ -136,11 +148,5 @@ module Samagotchi
     def print_warnings(helper)
       helper.warnings.each { |warning| @stderr.puts("warning: #{warning}") }
     end
-
-    def usage_error(message)
-      @stderr.puts("chi desktop: #{message}")
-      @stderr.puts(USAGE)
-      2
-    end
   end
 end

data/lib/samagotchi/edit_preview.rb

@@ -33,8 +33,8 @@ module Samagotchi
       return before if before.is_a?(Hash)
 
       if call[:name].to_s == "edit"
-        result = Tools::Edit.apply(call[:content], path: path, start_line: call[:start_line],
-                                                   end_line: call[:end_line], read: ->(_) { before })
+        result = Tools::Edit.apply(path: path, old_text: call[:old_text], new_text: call[:new_text],
+                                   start_line: call[:start_line], end_line: call[:end_line], read: ->(_) { before })
         return { error: result.delete_prefix("Error: ") } if result.is_a?(String)
 
         after = result.first

data/lib/samagotchi/engine.rb

@@ -11,7 +11,6 @@ require_relative "context_note"
 require_relative "steer"
 require_relative "turn_note"
 require_relative "model_profile"
-require_relative "thought_stream_splitter"
 require_relative "cancellation_controller"
 require_relative "context_window"
 require_relative "kernel_loop"
@@ -107,7 +106,7 @@ module Samagotchi
       # #profile_resolution decides on first need (see there), so building an
       # Engine makes no network call.
       @given_profile = profile ? ModelProfile.normalize(profile) : nil
-      @model_lookup_names = [@default_model_name]
+      @typed_model_name = @default_model_name
       @profile_resolution = nil
       # Ensure the built-in system bundle is installed (lazy, warn-only).
       # This is the single seam for both TUI and non-TUI (web/worker) paths.
@@ -769,7 +768,7 @@ module Samagotchi
       resolved = ModelProfile.check_host!(ModelProfile.required_model_name(aliased), hosts: @host_registry.entries)
       @effective_model_name = resolved
       bare = bare_model_name(resolved)
-      @model_lookup_names = [model_name, aliased, resolved]
+      @typed_model_name = model_name
       # A profile given to .new was for the starting model.
       @given_profile = nil
       @profile_resolution = nil
@@ -844,7 +843,7 @@ module Samagotchi
       # head system prompt invalidates the cache for the entire conversation
       # (prompt re-evaluated every interval). A tail append keeps the prefix
       # intact — only the new reminder suffix is evaluated. Mirrors the
-      # context-status injection at lib/samagotchi/kernel_loop.rb:447.
+      # context guidance line KernelLoop#run appends (ContextStatus#take_guidance).
       messages << { role: "system", content: reminder_text }
       # Atomically mark all due as fired under one lock and clear the
       # IdleReminders latch so the next interval can be detected.
@@ -1107,29 +1106,15 @@ module Samagotchi
       @guardrail_wiring.state_dir = state_dir
     end
 
-    # The gate's core checks, in order (GuardrailWiring#checks).
-    def guardrail_checks
-      @guardrail_wiring.checks
-    end
-
     # The YAML rules, read again when a file changed (GuardrailWiring#rules).
     # @return [Guardrails::Rules]
     def guardrail_rules
       @guardrail_wiring.rules
     end
 
-    # Installed bundles' guardrails/*.yml (GuardrailWiring#bundle_rules).
-    def bundle_guardrail_rules
-      @guardrail_wiring.bundle_rules
-    end
-
     # @return [Guardrails::LoadFailures]
     attr_reader :guardrail_failures
 
-    def guardrail_protected_paths
-      @guardrail_wiring.protected_paths
-    end
-
     # @return [Guardrails::Approvals]
     def guardrail_approvals
       @guardrail_wiring.approvals
@@ -1165,12 +1150,6 @@ module Samagotchi
       @plugin_failures.message if @guardrail_failures_announced
     end
 
-    # The context the gate sees for a tool call now.
-    # @return [Guardrails::Context]
-    def guardrail_context
-      @guardrail_wiring.context
-    end
-
     # Ask the user to approve a call the gate voted `ask` on
     # (GuardrailWiring#request_approval).
     # @param verdict [Guardrails::Verdict]
@@ -2065,7 +2044,7 @@ module Samagotchi
           (task = current_init_task) ? task.cancelled? : @activity_mutex && active_cancel_controller&.cancelled?
         },
         card: ->(**card) { show_card(**card) },
-        steer: ->(text, source) { steer(text, source: source) },
+        steer: ->(text, label) { steer(text, source: hook_source(label)) },
         stop_turn: ->(reason, label) { hook_stop_turn(reason, label) },
         stop_generation: ->(reason, label) { hook_stop_generation(reason, label) },
         ask_model: lambda { |request, timeout:, max_tokens:, cancel_controller:|
@@ -2108,31 +2087,13 @@ module Samagotchi
     end
     private :ask_side_model
 
-    # config.yml `bundles:`: each bundle's settings by name, for its hooks.
-    # @return [Hash{String => Hash}] {} when absent; a section that isn't a
-    #   mapping warns once and counts as absent
+    # config.yml `bundles:` (ConfigFile.bundle_settings), read once: the
+    # bundle hooks and the plugins both want it.
     def bundle_settings
-      # Read once: the bundle hooks and the plugins both want it.
-      @bundle_settings ||= read_bundle_settings
+      @bundle_settings ||= Samagotchi::ConfigFile.bundle_settings
     end
     private :bundle_settings
 
-    def read_bundle_settings
-      data = Samagotchi::ConfigFile.read_yaml(path: Samagotchi::ConfigFile.global_path)
-      section = data.is_a?(Hash) ? data["bundles"] : nil
-      return {} if section.nil?
-      unless section.is_a?(Hash)
-        Log.warn(:hooks, "bundles_section_invalid", echo: "[samagotchi:hooks] config.yml bundles: must be a mapping of bundle name to settings; ignored")
-        return {}
-      end
-
-      section.each_with_object({}) do |(name, value), acc|
-        acc[name.to_s] = value.is_a?(Hash) ? value : {}
-      end
-    rescue StandardError
-      {}
-    end
-    private :read_bundle_settings
 
     # The session's current model as a recap target: its host's OpenAI API
     # (native llama.cpp hosts serve /v1/chat/completions too), key variable
@@ -2168,44 +2129,29 @@ module Samagotchi
     # only notifying the observer.
     # Wrap a raw kernel stream event and fan it out to the turn sink + observers.
     #
-    # Phase 2 (web-stream-rendering): each :generation_chunk is enriched with two
-    # ADDITIVE fields derived from the raw `content` (which is left untouched —
-    # the TUI thinking spinner, analytics, and Bridge replay all rely on raw):
+    # Each :generation_chunk comes split already, by the loop that streamed it:
+    # besides the raw `content` (left untouched — the TUI thinking spinner,
+    # analytics, and Bridge replay rely on it) it carries
     #   * :text     — visible prose (thinking AND tool_call blocks removed)
     #   * :thinking — thinking-only content
-    # The splitter is profile-aware and resets on each :generation_started so a
-    # turn's multiple generations each start clean.
-    #
-    # Enrichment is profile-scoped:
-    #   * Splitting profiles (explicit think close, e.g. Qwen) ALWAYS emit
-    #     `text`/`thinking` on every :generation_chunk — even when empty — so the
-    #     web client can rely on them and never fall back to raw `content`.
-    #   * Non-splitting profiles (nil think close, e.g. Gemma) leave the event
-    #     unchanged; the web client then falls back to raw `content`, preserving
-    #     today's behavior (no regression).
+    # KernelLoop splits a native stream with a ThoughtStreamSplitter per
+    # generation (every profile, Gemma's thought channel included); the chat
+    # loop gets reasoning apart from the answer. The web routes on those
+    # fields (chunk_router.js).
     #
     # With a :generation_progress hook registered, a Hooks::StreamWatch gets
     # each chunk's thinking and text after the UIs had it.
     def build_stream_event_handler(on_event, cancel_controller: nil)
-      splitter = ThoughtStreamSplitter.for_profile(profile)
-      enrich = profile.thought_close ? :always : :never
       watch = stream_watch(cancel_controller)
       proc do |event|
         progress = nil
         case event[:type]
         when :generation_started
-          splitter = ThoughtStreamSplitter.for_profile(profile)
           watch&.started(event[:iteration])
         when :generation_chunk
-          # The chat loop already splits its stream (reasoning arrives apart
-          # from the answer); only raw native chunks are split here.
-          if event.key?(:text)
-            progress = { thinking: event[:thinking], text: event[:text] }
-          else
-            delta = splitter.feed(event[:content])
-            progress = { thinking: delta[:thinking], text: delta[:text] }
-            event = event.merge(text: delta[:text], thinking: delta[:thinking]) if enrich == :always
-          end
+          # A chunk without the lanes (no loop of ours sends one) counts as text.
+          text = event.key?(:text) ? event[:text] : event[:content]
+          progress = { thinking: event[:thinking].to_s, text: text.to_s }
         end
         # The chat loop asked again without the thinking fields: a notice,
         # not an event of its own.
@@ -2300,11 +2246,10 @@ module Samagotchi
       ModelProfile.resolve(names: model_lookup_names(target), entry: target.entry, client: target.client, bare_model: target.bare_model)
     end
 
-    # The names a models: entry may be under: as typed (maybe an alias), the
-    # part after a host prefix, alias-resolved, bare.
+    # The names a models: entry may be under (HostRegistry#lookup_names):
+    # the model as typed at start or at the last /model, and what it became.
     def model_lookup_names(target)
-      typed = @model_lookup_names.first
-      (@model_lookup_names + [@host_registry.parse_qualified_model(typed).last, target.bare_model]).compact
+      @host_registry.lookup_names(@typed_model_name, resolved: @effective_model_name, target: target)
     end
 
     # Everything that holds a profile follows the resolution: the kernel's

data/lib/samagotchi/events.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # The sets of event types more than one place reads (the Worker, the
+  # Bridge's observers, the TUI, the web), kept here once. The web's own
+  # copies (app.js's stream handlers, turn_events.js's snapshotEvents) are
+  # checked against these by spec/events_drift_spec.rb.
+  module Events
+    # A turn is over: it completed, was canceled, or failed.
+    TURN_END = %i[turn_completed turn_canceled turn_failed].freeze
+    # Turn ends that leave the turn in the conversation: a failed turn's
+    # prompt goes back to the composer instead.
+    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
+    # 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).
+    STREAM_FRAMES = %i[snapshot reset stream_closed].freeze
+    SYNTHETIC = %i[merged_input].freeze
+  end
+end

data/lib/samagotchi/guardrail_wiring.rb

@@ -156,13 +156,11 @@ module Samagotchi
     def protected_paths
       @protected ||= begin
         require_relative "memory_bundle/provenance"
-        config = Samagotchi::ConfigFile.read_yaml(path: Samagotchi::ConfigFile.global_path)
-        hooks_dir = config.is_a?(Hash) && config["hooks"].is_a?(Hash) ? config["hooks"]["hooks_dir"] : nil
         Guardrails::ProtectedPaths.new(
           store_dir: File.dirname(@approvals.path),
           bundles_dir: MemoryBundle::Provenance.bundles_dir,
           config_path: Samagotchi::ConfigFile.global_path,
-          hooks_dir: Hooks::Loader.expand_path(hooks_dir || Hooks::Loader.default_hooks_dir)
+          hooks_dir: Hooks::Loader.hooks_dir
         )
       end
     end
@@ -209,8 +207,7 @@ module Samagotchi
     end
 
     def load_rules
-      section = Samagotchi::ConfigFile.read_yaml(path: Samagotchi::ConfigFile.global_path)
-      section = section["guardrails"] if section.is_a?(Hash)
+      section = Samagotchi::ConfigFile.section("guardrails")
       rules = []
       disable = []
       begin

data/lib/samagotchi/guardrails/targets.rb

@@ -4,6 +4,7 @@ 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
@@ -123,9 +124,14 @@ module Samagotchi
       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.