samagotchi 0.55.0 → 0.57.0

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

@@ -1,6 +1,6 @@
 ---
 name: core
-version: 0.1.0
+version: 0.2.0
 scope: system
 description: "Recommended safety set"
 trust_level: reviewed
@@ -9,3 +9,4 @@ includes:
 - loop-guard
 - check-in
 - guardrails
+- slow-commands

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

@@ -1,12 +1,12 @@
 ---
 name: mcp
-version: 0.6.1
+version: 0.6.2
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session; the model searches their tools with find_mcp_tools and calls one with mcp_call (<server>/<tool>); /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:7778b1a8f82a043c06c0289a191bc2847c844665de0c961edb493f787f435ad5
+  sha256: sha256:8b2c0cf8a48d99b32e320506676d93d8069f9fda4a2ee101112073780a5c4f8a
 # 0.37.0 (published 2026-10-07) is the release whose targets: take acts_as:, args: and label:.
 requires_chi: ">= 0.37.0"

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

@@ -276,7 +276,15 @@ class Plugin
   # +client+ is the running process's (a restart replaces it; the
   # service's stop closes the current one), +restarts+ how many it had.
   Server = Struct.new(:name, :config, :service, :state, :error, :tools, :listed, :timeout, :cwd, :command, :env,
-                      :digest, :cached_at, :relist, :relisting, :client, :restarts, :tokens, :info, keyword_init: true)
+                      :digest, :cached_at, :relist, :relisting, :client, :restarts, :tokens, :info, keyword_init: true) do
+    # Its state and tools, never the env (values often a token) or the
+    # command's args (which may carry a token too): a failing spec or a
+    # debugger would print those. `command` and `env` are nil before the
+    # server is resolved.
+    def inspect = "#<Server #{name} state=#{state} command=#{Array(command).first} env=#{(env || {}).keys.join(",")} tools=#{Array(tools).size}>"
+
+    def pretty_print(printer) = printer.text(inspect)
+  end
 
   def initialize(settings = {})
     @settings = settings
@@ -291,6 +299,12 @@ class Plugin
     @left_out_lock = Mutex.new
   end
 
+  # The servers' names, never @settings (the raw servers config, env values
+  # included): a failing spec prints the plugin.
+  def inspect = "#<Plugin mcp servers=#{@servers.map(&:name).join(",")}>"
+
+  def pretty_print(printer) = printer.text(inspect)
+
   # Each server's tools come from its cache (tools-<server>.json in the
   # bundle's data dir, keyed by a digest of its config) when there is one:
   # the server then starts on the first call of one of its tools (start:

data/lib/samagotchi/bundles/slow-commands/manifest.yml

@@ -0,0 +1,11 @@
+---
+name: slow-commands
+version: 0.1.0
+scope: system
+description: "Remembers commands that ran past the execute limit in a project; the next identical execute is denied once a turn with advice to run it with task_create and task_wait; /slow-commands lists and forgets them"
+trust_level: reviewed
+plugin:
+  file: plugin.rb
+  sha256: sha256:00a35b8f930d8f99a908b99c5eb3a5e97b1209c63c616037072580d92d3c8639
+# after_tool_call's call:, elapsed_ms: and result: (0.57.0)
+requires_chi: ">= 0.57.0"

data/lib/samagotchi/bundles/slow-commands/plugin.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+# The slow-commands bundle (docs/plugins.md, The slow-commands bundle): an
+# `execute` that ran past its limit (or close to it) is remembered for the
+# project, and the next identical `execute` is denied with advice: start it
+# with task_create, then task_wait with a timeout that fits.
+#
+# A command is keyed by its project (the session's git checkout, else its
+# working directory) and its text: the ShellLex words and operators joined
+# by one space, the call's cwd: folded in as a leading `cd <dir> &&`
+# (relative to the project), and a trailing output filter dropped (a final
+# 2>&1, `| tail …`, `| head …`, `| grep …`: they don't change how long it
+# runs). Arguments stay: `bundle exec rspec` (the suite) is not
+# `bundle exec rspec spec/x_spec.rb`. Input that ends inside a quote, $(…)
+# or heredoc is never recorded, nor one with a $(…), backticks or a heredoc
+# cat/tee read as data: ShellLex makes those one placeholder, so different
+# commands would share a key.
+#
+# after_tool_call records: timed out, or ran at least warn_ratio of the
+# limit -> slow; ran under half of it with exit 0 -> the entry is dropped
+# (a fast failure says nothing about the suite's length), unless a trailing
+# filter was stripped: `rspec | tail` exits with tail's 0 when rspec failed,
+# and a `| head` can end it early. A stopped or
+# denied call records nothing. A key is denied once per turn: the model
+# running it again in the same turn is let through (maybe it got faster),
+# and that run records the new truth. before_turn resets it.
+#
+# Store: <data_dir>/commands.json, a list of {project, command, slow_at,
+# limit_s, elapsed_s, timed_out}, re-read on each lookup (another session's
+# record counts at once), written whole (AtomicFile), entries older than
+# ttl_days dropped on write.
+#
+# The advice names how long a finished task of the same command took: the
+# project's tmp/tasks/*/task.json read as files (never TaskRuntime's
+# list_records, which mkdirs, runs ps and writes), the exit_code file's
+# mtime minus started_at (finished_at is when chi noticed).
+#
+# Settings (config.yml, bundles: slow-commands:):
+#   mode: deny        deny | notify (warn the user, never deny)
+#   warn_ratio: 0.8   a run this share of the limit or longer is slow
+#   ttl_days: 14      entries older than this are forgotten
+#
+# /slow-commands lists this project's entries; /slow-commands forget <n|all>
+# drops them.
+require "json"
+require "pathname"
+require "time"
+require "samagotchi/atomic_file"
+require "samagotchi/guardrails/shell_lex"
+require "samagotchi/tools/execute"
+require "samagotchi/tools/task_runtime"
+
+class Plugin
+  SOURCE = "bundle slow-commands"
+  FILE = "commands.json"
+  FILTERS = %w[tail head grep].freeze
+  TIMED_OUT = /\A#{Regexp.escape(Samagotchi::Tools::Execute::TIMEOUT_PREFIX)} (\d+)s/
+  STOPPED = [Samagotchi::Tools::Execute::STOPPED_BY_USER, Samagotchi::Tools::Execute::NOT_RUN_ON_STOP].freeze
+  LEX = Samagotchi::Guardrails::ShellLex
+  SHORT_CHARS = 60
+  WAIT_DEFAULT = 600
+
+  def initialize(settings = {})
+    @mode = settings["mode"].to_s == "notify" ? :notify : :deny
+    ratio = Float(settings["warn_ratio"].to_s, exception: false)
+    @warn_ratio = ratio && ratio.positive? && ratio <= 1 ? ratio : 0.8
+    @ttl_days = positive(settings["ttl_days"]) || 14
+    reset
+  end
+
+  def register(chi)
+    chi.on(:before_turn) { |_event| reset }
+    chi.on(:before_tool_call) { |event, ctx| before(event, ctx) }
+    chi.on(:after_tool_call) { |event, ctx| after(event, ctx) }
+    chi.command "/slow-commands", "commands that ran past the execute limit here; forget <n|all> drops them",
+                anytime: true do |args, ctx|
+      command(args.to_s.strip, ctx)
+    end
+  end
+
+  # The command text as the store keys it, or nil when it can't be keyed
+  # (empty, unterminated). +cwd+: where it runs (nil: the session's).
+  def self.normalize(text, cwd:, project:, base:)
+    text = text.to_s.strip
+    return nil if text.empty? || LEX.unterminated?(text)
+
+    tokens = LEX.lex(text)
+    return nil if tokens.any? { |kind, value| kind == :word && value.include?("\0") }
+
+    tokens = strip_filters(tokens)
+    return nil if tokens.empty?
+
+    words = tokens.map { |kind, value| kind == :op ? value.tr("\n", ";") : quote(value) }
+    dir = folded_dir(cwd, project: project, base: base)
+    words = ["cd", quote(dir), "&&", *words] if dir
+    words.join(" ")
+  end
+
+  # Whether the key dropped a trailing output filter (2>&1, | tail …):
+  # the exit code is then the filter's, and the run may have been cut short.
+  def self.filtered?(text)
+    tokens = LEX.lex(text.to_s.strip)
+    tokens.pop while tokens.last && tokens.last[0] == :op && [";", "\n"].include?(tokens.last[1])
+    strip_filters(tokens).size != tokens.size
+  end
+
+  # Drops a trailing 2>&1 word and `| tail/head/grep …` filters, and a
+  # trailing ; or newline, until none is left.
+  def self.strip_filters(tokens)
+    tokens = tokens.dup
+    loop do
+      before = tokens.size
+      tokens.pop while tokens.last && tokens.last[0] == :op && [";", "\n"].include?(tokens.last[1])
+      tokens.pop if tokens.last && tokens.last[0] == :word && tokens.last[1] == "2>&1"
+      pipe = tokens.rindex { |kind, value| kind == :op && value == "|" }
+      if pipe && tokens[(pipe + 1)..].all? { |kind, _| kind == :word } && FILTERS.include?(tokens[pipe + 1]&.at(1))
+        tokens = tokens[0...pipe]
+      end
+      return tokens if tokens.size == before
+    end
+  end
+
+  def self.quote(word)
+    word.empty? || word.match?(/[\s'"]/) ? "'#{word.gsub("'", "'\\\\''")}'" : word
+  end
+
+  # The run dir relative to +project+, or nil for the project itself.
+  def self.folded_dir(cwd, project:, base:)
+    dir = File.expand_path(cwd.to_s.strip.empty? ? base : cwd.to_s.strip, base)
+    rel = Pathname.new(dir).relative_path_from(Pathname.new(File.expand_path(project))).to_s
+    rel == "." ? nil : rel
+  rescue ArgumentError
+    dir
+  end
+
+  private
+
+  def reset
+    @denied = {}
+  end
+
+  def before(event, ctx)
+    call = event[:call]
+    verdict = event[:guardrail]
+    return unless call.is_a?(Hash) && call[:name].to_s == Samagotchi::Tools::Execute::NAME && verdict
+    return if verdict.deny?
+
+    key = key_for(call, ctx)
+    return unless key
+    return if @denied[key]
+
+    entry = live_entries(ctx).find { |e| e["project"] == key[0] && e["command"] == key[1] }
+    return unless entry
+
+    @denied[key] = true
+    if @mode == :notify
+      ctx.notify("execute #{short(key[1])}: #{what(entry)} before", level: :warn)
+      return
+    end
+
+    verdict.deny!("slow command", source: SOURCE, advice: advice(entry, ctx, key))
+    ctx.notify("execute #{short(key[1])}: #{what(entry)} before, denied", level: :warn)
+  end
+
+  def after(event, ctx)
+    call = event[:call]
+    return unless event[:tool].to_s == Samagotchi::Tools::Execute::NAME && call.is_a?(Hash)
+
+    elapsed_ms = event[:elapsed_ms]
+    result = event[:result].to_s
+    return if elapsed_ms.nil? || STOPPED.any? { |text| result.start_with?(text) }
+
+    key = key_for(call, ctx)
+    return unless key
+
+    limit = Samagotchi::Tools::Execute.timeout_seconds
+    if (timed_out = result[TIMED_OUT, 1])
+      remember(ctx, key, limit_s: timed_out.to_i, elapsed_s: timed_out.to_i, timed_out: true)
+    elsif elapsed_ms >= @warn_ratio * limit * 1000
+      remember(ctx, key, limit_s: limit, elapsed_s: (elapsed_ms / 1000.0).round, timed_out: false)
+    elsif elapsed_ms < 0.5 * limit * 1000 && exit_zero?(result) && !self.class.filtered?(call[:content])
+      forget_key(ctx, key)
+    end
+  end
+
+  def key_for(call, ctx)
+    project = project_of(ctx)
+    command = self.class.normalize(call[:content], cwd: call[:cwd], project: project, base: ctx.cwd)
+    command ? [project, command] : nil
+  end
+
+  def project_of(ctx) = ctx.repo_root || ctx.cwd
+
+  def exit_zero?(result)
+    result.scan(/^exit: (-?\d+)/).last == ["0"]
+  end
+
+  # --- the store ---
+
+  def store_path(ctx) = File.join(ctx.data_dir, FILE)
+
+  def entries(ctx)
+    list = JSON.parse(File.read(store_path(ctx)))
+    list.is_a?(Array) ? list.select { |e| e.is_a?(Hash) && e["project"] && e["command"] } : []
+  rescue Errno::ENOENT, JSON::ParserError
+    []
+  end
+
+  def live_entries(ctx) = entries(ctx).select { |e| live?(e) }
+
+  def live?(entry)
+    Time.iso8601(entry["slow_at"].to_s) > Time.now - (@ttl_days * 86_400)
+  rescue ArgumentError
+    false
+  end
+
+  def save(ctx, list)
+    Samagotchi::AtomicFile.write(store_path(ctx), "#{JSON.pretty_generate(list.select { |e| live?(e) })}\n")
+  end
+
+  def remember(ctx, key, limit_s:, elapsed_s:, timed_out:)
+    list = entries(ctx).reject { |e| e["project"] == key[0] && e["command"] == key[1] }
+    list << { "project" => key[0], "command" => key[1], "slow_at" => Time.now.utc.iso8601,
+              "limit_s" => limit_s, "elapsed_s" => elapsed_s, "timed_out" => timed_out }
+    save(ctx, list)
+  end
+
+  def forget_key(ctx, key)
+    list = entries(ctx)
+    kept = list.reject { |e| e["project"] == key[0] && e["command"] == key[1] }
+    save(ctx, kept) if kept.size != list.size
+  end
+
+  # --- the deny's advice ---
+
+  def advice(entry, ctx, key)
+    took = task_duration(ctx, key)
+    wait = took ? [WAIT_DEFAULT, ((took * 1.5) / 60.0).ceil * 60].max : WAIT_DEFAULT
+    date = entry["slow_at"].to_s[0, 10]
+    seen = if entry["timed_out"]
+             "This command ran past the execute limit (#{entry["limit_s"]} s) here on #{date}."
+           else
+             "This command took #{duration(entry["elapsed_s"])} of the execute limit (#{entry["limit_s"]} s) here on #{date}."
+           end
+    text = "#{seen} Start it with task_create, then task_wait (timeout #{wait})."
+    took ? "#{text} A finished task of this command took #{duration(took)}." : text
+  end
+
+  # Seconds the newest finished (exit 0) task of this key took, or nil.
+  def task_duration(ctx, key)
+    roots = [ctx.cwd, project_of(ctx)].uniq
+    records = roots.flat_map do |root|
+      Dir.glob(File.join(root, Samagotchi::Tools::TaskRuntime::TASKS_DIR, "*", "task.json"))
+    end.uniq
+    found = records.filter_map { |path| finished_task(path, ctx, key) }
+    found.max_by(&:first)&.last
+  end
+
+  # [started_at, seconds] for a task record of +key+ that ended with exit 0.
+  def finished_task(path, ctx, key)
+    record = JSON.parse(File.read(path))
+    exit_code = File.join(File.dirname(path), Samagotchi::Tools::TaskRuntime::EXIT_CODE_FILENAME)
+    return nil unless File.file?(exit_code) && File.read(exit_code).strip == "0"
+
+    command = self.class.normalize(record["command"], cwd: record["cwd"], project: key[0], base: ctx.cwd)
+    return nil unless command == key[1]
+
+    started = Time.iso8601(record["started_at"].to_s)
+    seconds = (File.mtime(exit_code) - started).round
+    seconds.negative? ? nil : [started, seconds]
+  rescue StandardError
+    nil
+  end
+
+  # --- /slow-commands ---
+
+  def command(args, ctx)
+    project = project_of(ctx)
+    mine = live_entries(ctx).select { |e| e["project"] == project }.sort_by { |e| e["slow_at"].to_s }
+    case args
+    when ""
+      return "slow-commands: none recorded for #{project}" if mine.empty?
+
+      lines = mine.each_with_index.map do |e, i|
+        "#{i + 1}. #{e["command"]}: #{what(e)} (#{e["slow_at"].to_s[0, 10]})"
+      end
+      "slow-commands in #{project}:\n#{lines.join("\n")}\n/slow-commands forget <n|all> drops an entry"
+    when /\Aforget\s+(all|\d+)\z/
+      which = Regexp.last_match(1)
+      drop = which == "all" ? mine : [mine[which.to_i - 1]].compact
+      return "slow-commands: no entry #{which} (/slow-commands lists them)" if drop.empty?
+
+      save(ctx, entries(ctx).reject { |e| drop.any? { |d| d["project"] == e["project"] && d["command"] == e["command"] } })
+      "slow-commands: forgot #{drop.size == 1 ? drop.first["command"] : "#{drop.size} commands"}"
+    else
+      "usage: /slow-commands (list this project's slow commands), /slow-commands forget <n|all>"
+    end
+  end
+
+  # --- text ---
+
+  def what(entry)
+    entry["timed_out"] ? "ran past #{entry["limit_s"]} s" : "took #{duration(entry["elapsed_s"])} of #{entry["limit_s"]} s"
+  end
+
+  def duration(seconds)
+    seconds = seconds.to_i
+    seconds < 60 ? "#{seconds}s" : "#{seconds / 60}m#{format("%02d", seconds % 60)}s"
+  end
+
+  def short(command)
+    text = command.to_s
+    text.length > SHORT_CHARS ? "#{text[0, SHORT_CHARS - 1]}…" : text
+  end
+
+  def positive(value)
+    number = Integer(value.to_s, exception: false)
+    number&.positive? ? number : nil
+  end
+end

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

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

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.55.0
+version: 0.57.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:dfc19266259a9af1e0d769b7e0f67996b740b0c9921fdf3dadad973f6e5c144a
-  config_modification_protocol.md: sha256:45064ac6b19863e1646d15891d0e9cc7a8f10ab981a0d25d6e13891591538b8a
-  memory_guide.md: sha256:15cd3b24eda853cc458371c6c75809a2d4b5352311d075aaa4384926b5221c27
+  config_modification_protocol.md: sha256:d908921b5988244fb2a03fe04e693d0e7a1dfadf8cd77704e9232826db7eb2d7
+  memory_guide.md: sha256:d16919387c42d229498f470fc4078245a15faee872480ffbeffe2e27897624e4
   delegated.md: sha256:aedaa1e756a244904c5560fff0424e06fb468bbdcb0358bccefe321d67cd2614

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
 - Integrity: each file's sha256 is recorded at install; a hook/plugin/rule file changed afterwards is not loaded (rules: every call denied) until reinstalled. It is an integrity check, not proof of authorship.
 - Installing = trusting its Ruby code (hooks, plugin), like a gem. Install only copies; the code runs at the next session start (`Engine.new`), so a running worker needs a restart to pick it up.
 - A bundle without `*.md` (btw, mcp, loop-guard) adds no line to the prompt's memory index.
-- Profiles are shipped bundles with only `includes:` (bundle names): `core` (loop-guard, check-in, guardrails; `chi bootstrap` installs it) and `dev` (known-names, mcp, btw, skills, source-links). `chi bundle install core` installs the ones not installed and records them; a bundle the user uninstalled stays out on a later install, upgrade or `chi update`, which install only bundles new to the profile. `chi bundle uninstall core` removes its recorded bundles, then core (`docs/memory.md` "Bundle profiles").
+- Profiles are shipped bundles with only `includes:` (bundle names): `core` (loop-guard, check-in, guardrails, slow-commands; `chi bootstrap` installs it) and `dev` (known-names, mcp, btw, skills, source-links, github-pr, coordinator). `chi bundle install core` installs the ones not installed and records them; a bundle the user uninstalled stays out on a later install, upgrade or `chi update`, which install only bundles new to the profile. `chi bundle uninstall core` removes its recorded bundles, then core (`docs/memory.md` "Bundle profiles").
 
 ### CLI — `chi bundle`
 

data/lib/samagotchi/cache_confirm.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # The confirm step before a session setting change that restarts the
+  # prompt cache (/thinking, /reasoning-history): such a change, sent
+  # without --yes from a person at a web tab or a chi TUI, changes nothing
+  # and replies with what it costs and the line that applies it. Two steps,
+  # no stored state: the reply carries a Confirm (SessionCommands::Result,
+  # the worker's command_ran), the TUI prefills its line, the web draws an
+  # Apply button that sends it.
+  module CacheConfirm
+    YES_FLAGS = %w[--yes -y].freeze
+    # The costs worth asking about (Thinking.cache_cost,
+    # ReasoningHistory.cache_cost); :tail and nil are not.
+    COSTLY = %i[full provider history].freeze
+
+    # The line that applies a change, and the question the reply ends with.
+    Confirm = Data.define(:line, :text) do
+      # The plain form the worker's command_ran carries.
+      # @return [Hash] symbol keys
+      def to_h = { line: line, text: text }
+    end
+
+    module_function
+
+    # A command's argument words with --yes / -y (anywhere) taken out.
+    # @param args [String] what follows the command name
+    # @return [Array(String, Boolean)] the rest, stripped and downcased, and
+    #   whether --yes was there
+    def split(args)
+      words = args.to_s.strip.downcase.split
+      yes = words.any? { |word| YES_FLAGS.include?(word) }
+      [(words - YES_FLAGS).join(" "), yes]
+    end
+
+    # Whether a change must ask first: the effective level changes, the
+    # cost is one of COSTLY, and the session has a model reply (a cache to
+    # restart at all).
+    def needed?(cost:, history:, changed:)
+      changed && history && COSTLY.include?(cost)
+    end
+
+    # The Confirm for +name+ set to +word+: the line with --yes, and the
+    # question naming it.
+    # @return [Confirm]
+    def confirm(name, word)
+      line = "#{name} #{word} --yes"
+      Confirm.new(line: line, text: "Nothing changed yet: send `#{line}` to apply.")
+    end
+  end
+end

data/lib/samagotchi/client_id.rb

@@ -39,8 +39,20 @@ module Samagotchi
     HUMAN_PREFIXES = [WEB_PREFIX, TUI_PREFIX].freeze
     HUMAN_IDS = [CLI_SEND].freeze
 
+    # A person at a screen that shows a command's reply and can answer it
+    # (#interactive?): a web tab, an attached chi TUI.
+    INTERACTIVE_PREFIXES = [WEB_PREFIX, TUI_PREFIX].freeze
+
     module_function
 
+    # Whether +client_id+ is a web tab or a chi TUI, which see a command's
+    # reply and can send the line it asks for (CacheConfirm); chi send, a
+    # delegate, a plugin, chi itself and nil are not.
+    def interactive?(client_id)
+      id = client_id.to_s
+      INTERACTIVE_PREFIXES.any? { |prefix| id.start_with?(prefix) }
+    end
+
     # Whether +client_id+ (a turn's or a line's origin) is a human's input.
     def human?(client_id)
       return true if client_id.nil?

data/lib/samagotchi/config.rb

@@ -187,6 +187,10 @@ module Samagotchi
       # is bin/chi's own --thinking; models: and hosts: entries rank below
       # the flag and the env, above config.yml's value.
       Entry.new(key: "thinking.level",           yaml_path: %w[thinking level],           type: :string, default: "default",       expose: %i[env config]),
+      # Which of its reasoning a chat host's model gets back (ReasoningHistory):
+      # the environment only, for A/B runs; models: and hosts: entries are
+      # the config surface.
+      Entry.new(key: "reasoning_history",        yaml_path: %w[reasoning_history],        type: :string, default: nil,              expose: %i[env]),
 
       Entry.new(key: "default.max_tokens",       yaml_path: %w[default max_tokens],       type: :integer, default: nil,              expose: %i[env config cli]),
       Entry.new(key: "max_tool_output_chars",    yaml_path: %w[max_tool_output_chars],    type: :integer, default: 10_000,          expose: %i[env config cli]),
@@ -269,9 +273,9 @@ module Samagotchi
     # Maps of named entries and the keys an entry may hold
     # (ConfigFile.hosts_config, ConfigFile.model_settings).
     MAP_ENTRY_KEYS = {
-      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking enabled
-                    remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens models].freeze,
-      "models" => %w[profile vision sampling thinking window_tokens llm_context_strategy llm_context_apply
+      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking
+                    reasoning_history enabled remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens models].freeze,
+      "models" => %w[profile vision sampling thinking reasoning_history window_tokens llm_context_strategy llm_context_apply
                      llm_context_budget_tokens].freeze
     }.freeze
     # The keys a hosts.<name>.models entry may hold (HostModel.parse_map).

data/lib/samagotchi/context_command.rb

@@ -10,6 +10,7 @@ require_relative "session"
 require_relative "cli/command"
 require_relative "cli/exit"
 require_relative "cli/flags"
+require_relative "redacted_inspect"
 
 module Samagotchi
   # `chi context`: attach live external text to sessions (ContextSources).
@@ -18,6 +19,7 @@ module Samagotchi
   # reads the text with context_read.
   class ContextCommand
     include CLI::Command
+    include RedactedInspect
 
     USAGE = <<~TEXT
       Usage: chi context <add|push|ls|show|refresh|rm|mute|unmute> [options] [TARGET]

data/lib/samagotchi/desktop/macos.rb

@@ -11,6 +11,7 @@ require_relative "../version"
 require_relative "../self_report"
 require_relative "../installed_gem"
 require_relative "../config"
+require_relative "../redacted_inspect"
 
 module Samagotchi
   module Desktop
@@ -22,6 +23,8 @@ module Samagotchi
     # command goes through the runner, and the dirs are injectable, so specs
     # (and smokes with register: false) never touch the real system.
     class MacOS
+      include RedactedInspect
+
       class Error < StandardError
       end