samagotchi 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4db526cc3c79a4e5aa8061f124ff09e65e289415074fcb51c71c25ccee1ab0c9
-  data.tar.gz: c30c2094cb357df9fe4e5618956e0c1a559ea0a2765709605488d03c5febbb87
+  metadata.gz: 9290117f26040b725e12c5cd18bf2a8858a573f34e2323e5a56517c030f95d7f
+  data.tar.gz: 7e5d1e2e8a285424b907172038f6bab1045b1388129241cc1a32cb26132437ae
 SHA512:
-  metadata.gz: 2ad7fd71ecfee430c9dec6d9b51971b1e7fdc38c099c5f4a868ad07add50a21ac293f6c686e5f8aca9b0d3bd919ee49e1d79336ac1fe1ac4926d6ace2de24adb
-  data.tar.gz: 5856a9fe2fcb23b4802626ee918e7015cc718d74b4d17828265377a606cb76fdf80badb3f5d0e314c76bcd3ceb4629fc3f79ab735275fd102c1a2895b54b4f3d
+  metadata.gz: d70bd257f5b82a2057077e2142adf5601f4bc652a0e820c695b5ecff305156c0270815374054e41d6403ecb0ee4579fd75fda84f670094e99a21f7cf73e34b5c
+  data.tar.gz: 961269d190e236ecbe3a3ce0dae6d18d86adf93f5c16aa8246dd91e10a43b73152c8595a4e6377491aaf86e74d8558b225893364dc6dd226634d6b94a7484504

data/CHANGELOG.md

@@ -8,6 +8,57 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-10-01
+
+### Changed
+
+- A small change to a memory or skill can go through `edit` on its file instead of rewriting it all with
+  `memory_write`; the prompt, the memory guide and the nudge below say so. `write`/`edit` on a memory's file
+  refresh its line in `index.md` (date, size; the description is kept), and the default guardrails no longer ask
+  before them as "writes outside the repository".
+- The system prompt no longer tells the model to keep `index.md` updated (`memory_write` does it); its result
+  says "Index line refreshed automatically." instead of naming the index file.
+- `skills` bundle 0.1.1 (`chi update`; needs chi 0.9.0): a skill changed some other way (an `execute` running `sed`) counts as
+  updated: you get the usual "skill X updated" line, `/skill diff` has the old text, and the nudge and the turn-end
+  "wasn't updated" line no longer fire for it. The nudge asks to `edit` the changed step rather than rewrite the
+  whole skill.
+
+### Fixed
+
+- `chi bundle install` of a bundle that's already installed no longer says "Skipped X (already exists; use --force
+  to overwrite)" for a file that's the same as the bundle's; it skips it quietly and says once that
+  `chi bundle upgrade NAME` updates the bundle and keeps local edits. A file skipped for a local edit no longer
+  also reports a checksum mismatch.
+- `chi bundle install` and `upgrade` no longer list a bundle's unchanged guardrail rule files as "Installed"; they
+  are skipped as already up to date like its memory files.
+- A memory file you edited, then `chi bundle install` of its bundle again (skipped for the edit), no longer gets
+  overwritten by the next `chi bundle upgrade`: the re-install kept your edit as the bundle's base, so the upgrade
+  took it as unedited.
+- `chi sessions list --sort/--order` is no longer ignored with `--live`, `--cwd` or `--format`.
+- A tool's time in the web's turn timing and the debug log's `tool_call_completed ms:` no longer counts the wait for
+  a guardrail approval; the log line shows the wait as `waited_ms:`.
+
+Update with `chi update` (bundles: `skills` 0.1.1).
+
+## [0.8.1] - 2026-10-01
+
+### Added
+
+- Guardrail rules can name the models they apply to (`models: small`, or globs on the model name). The guardrails
+  bundle (0.2.0, `chi update`; needs chi 0.8.1) adds two asks only small models get: `git checkout -- <file>` /
+  `git restore` (discards uncommitted changes) and `git stash drop`/`clear`. Small is `guardrails.small_models`:
+  `auto` (the default: 32B or less by the size in the model's name, an MoE's active size counting), a list of
+  globs, or `[]` for none. A chi older than 0.8.1 that shares the bundles dir (a checkout next to the gem, or a
+  worker still running after a gem update) doesn't know `models:` and denies every tool call until it is
+  restarted on the new chi.
+
+### Fixed
+
+- A tool row's time in the REPL and the attached TUI no longer counts the wait for a guardrail approval
+  (`blocked (2m 54s)` for a call denied at once).
+- docs/guardrails.md: rules are read again on the next tool call after config.yml or a bundle's rules change, with
+  no restart.
+
 ## [0.8.0] - 2026-10-01
 
 ### Added
@@ -462,7 +513,9 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.8.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.9.0...HEAD
+[0.9.0]: https://github.com/dm1try/samagotchi/compare/v0.8.1...v0.9.0
+[0.8.1]: https://github.com/dm1try/samagotchi/compare/v0.8.0...v0.8.1
 [0.8.0]: https://github.com/dm1try/samagotchi/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/dm1try/samagotchi/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/dm1try/samagotchi/compare/v0.5.1...v0.6.0

data/docs/configuration.md

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

data/docs/guardrails.md

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

data/docs/memory.md

@@ -12,7 +12,8 @@ Tool behavior:
 - `memory_read`: `scope` is optional.
 - If `scope` is provided (`project` or `system`), only that scope is read.
 - If `scope` is omitted, read falls back from project to system.
-- `memory_write`: `scope` is required (`project` or `system`). The entry name is passed via the `name` parameter (not `path` — the file tools use `path`). On success, the return value includes the full file path, so you can use the `edit` tool directly for targeted updates.
+- `memory_write`: `scope` is required (`project` or `system`). The entry name is passed via the `name` parameter (not `path` — the file tools use `path`). On success, the return value includes the full file path. For a small change to an existing memory (a step, a line) the model is told to `edit` that file rather than rewrite it all with `memory_write`.
+- `write`/`edit` that change a `*.md` right in a scope dir refresh its managed `index.md` line (date, bytes; the description is kept), as `memory_write` does. A memory created with `write` gets a line with no description; any other `.md` written there gets a line too. Model overlays (`<name>.<key>.md` next to `<name>.md`), files in another project's folder and files changed by `execute` are left out.
 
 ## Model-Specific Memory Overlays
 
@@ -51,8 +52,9 @@ chi is told about skills by the system bundle (`identity.md`, every turn, and
   looks unexpected on the way (a failing check, a warning the skill doesn't
   mention), chi stops, says what it saw and asks how to go on.
 - **Updating.** When a step turned out different (a renamed script, an extra
-  step), chi fixes the skill in the same turn: those steps changed, the rest
-  kept, a dated Changelog line added. No confirmation.
+  step), chi fixes the skill in the same turn: those steps changed (with `edit`
+  on its file, so a small fix doesn't resend the whole skill), the rest kept, a
+  dated Changelog line added. No confirmation.
 
 A skill is plain Markdown, no frontmatter:
 

data/docs/plugins.md

@@ -940,16 +940,24 @@ skills> skill release updated (+2 −1): 1. Run `scripts/verify.sh`; stop if it
 The line is the file on disk changing, whatever the tool answered; a denied
 write shows nothing.
 
+A skill read in the turn is also watched for changes made another way (an
+`execute` running `sed`, a script): after each other tool call, and at the
+turn's end, its file is compared with the content last seen (at the read, or
+after the last write). A change shows the same line, keeps the content last
+seen as a version (so `/skill diff` has it) and counts as the skill updated.
+A plain read keeps no version.
+
 **The nudge** (`nudge: true`). Some models, finding a skill's step broken,
 skip it and go on without fixing the skill. In a turn that read a skill
 (`memory_read` of a `skill_*` name, or `read` of its file), the first failing
 tool call after it (an `execute` that exited non-zero, a tool error) steers
 the model once: *"A step of skill release failed. Find out why before skipping
-it; if the skill is out of date, fix it now: memory_write the whole skill,
-its title and every section as they were, that step fixed, a Changelog line
-added."* If the turn ends with a failed step and the
-skill not rewritten, one line says so: `skill release was followed, a step
-failed, the skill wasn't updated`. A failure unrelated to the skill (a test
+it; if the skill is out of date, fix it now: edit the step that changed in
+its file (or memory_write the whole skill) and add a Changelog line."* No
+steer once a skill read this turn has changed, by any tool. If the turn ends
+with a failed step and no skill read changed, one line says so: `skill
+release was followed, a step failed, the skill wasn't updated`. A failure
+unrelated to the skill (a test
 meant to fail) can set it off too: once per turn, and only after a skill was
 read.
 

data/docs/releasing.md

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

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

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

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

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

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

@@ -1,10 +1,10 @@
 ---
 name: skills
-version: 0.1.0
+version: 0.1.1
 scope: system
 description: "Skills (skill_<name> memories, the steps of a task done together): /skill save, list, show and diff; older versions kept with a short diff line on every update; a nudge when a followed skill's step fails"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:76758d41e75db107e0a6f7ce35b9eac4944052746af16aeba30f38210cc436dc
-requires_chi: ">= 0.4.0"
+  sha256: sha256:ecf76de5d0f4d07a0e87b96cdc13b0bbc22369f8eea843bfd22c6fade469dfca
+requires_chi: ">= 0.9.0"

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

@@ -13,13 +13,20 @@
 # shows a line: "skill release updated (+2 −1): …" or "skill release saved
 # (project, 14 lines)".
 #
+# A skill read in this turn is also watched for changes made some other way
+# (an execute running sed, a script): after each other tool call, and at the
+# turn's end, its file is compared with the content last seen (at the read,
+# or after the last write above); a change keeps that content as a version,
+# shows the same line and counts as the skill updated.
+#
 # The nudge (nudge: true), for models that skip a failing step instead of
 # fixing the skill: in a turn that read a skill (memory_read of a skill_*
 # name, or a read of its file), the first failing tool call after it (an
 # execute with "exit: N", N ≠ 0, or with no exit line an Error: line near
 # the top; any tool's "[tool] Error: …") steers the model once to find out
-# why and fix the skill. At the turn's end, a failed step with no rewrite of
-# the skill gets a notice line.
+# why and fix the skill, unless a skill read was changed already (by any
+# tool, see above). At the turn's end, a failed step with no change to a
+# skill read gets a notice line.
 #
 # Settings (config.yml, bundles: skills:):
 #   history_keep: 20   older versions kept per skill
@@ -31,8 +38,7 @@ class Plugin
   WRITE_TOOLS = %w[memory_write write edit].freeze
   NOTICE_WIDTH = 60 # the changed line in an update's notice
   NUDGE = "A step of skill %s failed. Find out why before skipping it; if the skill is out of date, fix it now: " \
-          "memory_write the whole skill, its title and every section as they were, that step fixed, a Changelog " \
-          "line added."
+          "edit the step that changed in its file (or memory_write the whole skill) and add a Changelog line."
   NOT_FAILURES = %w[memory_read memory_write].freeze
   USAGE = "usage: /skill save [name] [--system] | list | show <name> | diff <name> [N]"
 
@@ -79,16 +85,38 @@ class Plugin
   def after_tool_call(event, ctx)
     stash = @stash
     @stash = nil
+    stash = nil unless stash && stash[:tool] == event[:tool].to_s
+    changed_elsewhere(ctx) unless stash
     step_failed(event) if @nudge && !@read.empty?
-    return unless stash && stash[:tool] == event[:tool].to_s
+    return unless stash
 
     now = File.file?(stash[:path]) ? File.read(stash[:path]) : nil
     return if now.nil? || now == stash[:old]
 
-    @written << stash[:name]
+    @written |= [stash[:name]]
+    @seen[stash[:name]] = { path: stash[:path], scope: stash[:scope], content: now }
     ctx.notify(change_notice(stash, now))
   end
 
+  # A skill read this turn whose file differs from the content last seen was
+  # changed by something other than the write tools (an execute's sed, say):
+  # keep what was there as a version, show the change, count the skill as
+  # updated (any change counts, the user's own edit too). A file gone since
+  # is left alone.
+  def changed_elsewhere(ctx)
+    @seen.each do |name, seen|
+      now = File.file?(seen[:path]) ? File.read(seen[:path]) : nil
+      next if now.nil? || now == seen[:content]
+
+      keep_version(ctx, seen[:scope], name, seen[:content]) if seen[:content]
+      ctx.notify(change_notice({ name: name, scope: seen[:scope], old: seen[:content] }, now))
+      seen[:content] = now
+      @written |= [name]
+    end
+  rescue SystemCallError => e
+    ctx.log.warn(:watch_failed, error: e.class.name, msg: e.message)
+  end
+
   def change_notice(stash, now)
     name = stash[:name]
     return "skill #{name} saved (#{stash[:scope]}, #{now.lines.size} lines)" unless stash[:old]
@@ -105,21 +133,42 @@ class Plugin
 
   def reset_turn
     @read = []      # skills read this turn, in order
+    @seen = {}      # of those, name => {path:, scope:, content:} last seen
     @written = []   # skills changed this turn
     @failed = false # a step failed after a skill was read
     @nudged = false
   end
 
   def note_read(tool, event)
-    names = case tool
+    found = case tool
             when "memory_read"
+              scope = event.dig(:call, :scope).to_s.strip
+              scope = nil unless memory_dirs.key?(scope)
+              # A skill not written yet is watched where memory_write would
+              # put it by default: the read scope, else project.
               event.dig(:call, :content).to_s.split(",").map(&:strip).select { |entry| entry.start_with?("skill_") }
-                   .filter_map { |entry| skill_name(entry) }
+                   .filter_map do |entry|
+                     name = skill_name(entry) or next
+                     unwritten = File.join(memory_dirs[scope || "project"], "skill_#{name}.md")
+                     [name, skill_path(name, scope: scope) || unwritten]
+                   end
             when "read"
-              Array(event.dig(:targets, :paths)).filter_map { |path| skill_at(path)&.last }
+              Array(event.dig(:targets, :paths)).filter_map { |path| (at = skill_at(path)) && [at.last, path] }
             else []
             end
-    @read |= names
+    found.each { |name, path| watch(name, path) }
+    @read |= found.map(&:first)
+  end
+
+  # Remember a read skill's content (nil: not written yet) the first time in
+  # a turn: a later read mustn't hide a change made in between.
+  def watch(name, path)
+    return if @seen.key?(name) || path.nil?
+
+    content = File.file?(path) ? File.read(path) : nil
+    @seen[name] = { path: File.expand_path(path), scope: skill_at(path)&.first, content: content }
+  rescue SystemCallError
+    nil
   end
 
   def step_failed(event)
@@ -127,7 +176,7 @@ class Plugin
     return if NOT_FAILURES.include?(tool) || !failure?(tool, event[:output].to_s)
 
     @failed = true
-    return if @nudged
+    return if @nudged || @read.any? { |name| @written.include?(name) }
 
     @nudged = !!event[:steer]&.call(format(NUDGE, @read.join(", ")))
   end
@@ -146,6 +195,7 @@ class Plugin
   end
 
   def after_turn(ctx)
+    changed_elsewhere(ctx)
     return unless @nudge && @failed
 
     missed = @read - @written

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

@@ -8,6 +8,6 @@
 - **Skills**: a skill is a memory named `skill_<name>` holding the steps of a repeatable task we did together (sections Steps, Gotchas, Changelog; `memory_write description:` says when to use it).
   When the user asks to keep how we did something ("let's memorize this", "save this as a skill", `/skill save`), write it right away with `memory_write` (project scope; system only when the user asks or it isn't about this project), then show it briefly.
   Before a task that a `skill_*` in the memory index matches, read it and follow it.
-  When a step turned out different (a renamed command, an extra step, a gotcha), update the skill in the same turn: fix those steps, keep the rest as it was, add a dated Changelog line.
+  When a step turned out different (a renamed command, an extra step, a gotcha), update the skill in the same turn: `edit` those steps in its file (memory_write only to rewrite it all), keep the rest as it was, add a dated Changelog line.
   When a skill's step fails or its file/command is missing, find out why (look around, read nearby READMEs) before skipping it; a step that says stop means stop and ask.
   While following a skill, when anything looks unexpected (a check fails, output differs from what a step says, a warning the skill doesn't mention): stop, don't improvise a fix, tell the user what you saw and ask how to go on. Read each command's whole output, including warnings, before the next step.

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.8.0
+version: 0.9.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
-  identity.md: sha256:d6f40d5e44096537d337c4ffda86823446f8b59eb8b8cc47014e97ec16f019c9
+  identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
   self_map.md: sha256:93c788fadaf98adeb8946b4a357d2372bd6ebb439042d7cef8dda8fb44187315
   config_modification_protocol.md: sha256:24e95727488daa80ac3008e020d8be098c7a1882153b7a61aba35450f72b86b7
-  memory_guide.md: sha256:50c076fb6bda7ed010877ff664bb2e9e904418fe08b058ebaa911d4e82e9a683
+  memory_guide.md: sha256:81b911b9a015f0924c48162b3dc4b6376309e743765074419a99fab46e480858
   delegated.md: sha256:0a71d5dfa7127df2d51cb5f0e7214240ed88777e36559430a8724c796d7ae561

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

@@ -6,7 +6,7 @@ This memory teaches you (the agent) how to use Samagotchi memories — persisten
 
 - Plain Markdown files (`*.md`) stored outside the repo so they persist.
 - Loaded at startup into your system prompt as **Project memories** and **System memories** indexes (blank-name `memory_read`).
-- You manage them via tools, not shell file ops. On write, `index.md` is auto-maintained — do not edit it manually.
+- You manage them via tools (`memory_write`, or `edit` on a memory's file for a small change), not shell file ops. `index.md` is auto-maintained on every write — do not edit it manually.
 
 ## Scopes — where files live
 
@@ -16,7 +16,7 @@ This memory teaches you (the agent) how to use Samagotchi memories — persisten
 | `project` | `<system dir>/projects/<basename>_<hash>/` (`MemoryPaths.project_dir`: `basename(root)` + 8-char `MD5(root)`, root = `MemoryPaths.project_root`) | Repo-specific conventions, workflow, stack decisions |
 
 - The project root is the git repository: its common git dir, which every linked worktree shares. All worktrees and subdirectories of one repository share one project folder; the system prompt shows the resolved root and folder. Outside a repository the root is the working directory. A separate clone is a different project.
-- `index.md` lives in each scope dir and contains auto-managed lines like `- **name** · scope · date · bytes — description`. Your free-form sections in `index.md` are preserved but managed lines are owned by `memory_write`.
+- `index.md` lives in each scope dir and contains auto-managed lines like `- **name** · scope · date · bytes — description`. Your free-form sections in `index.md` are preserved but managed lines are owned by `memory_write` (and refreshed when `write`/`edit` change a memory's file).
 
 ## Tools you have
 
@@ -34,7 +34,8 @@ This memory teaches you (the agent) how to use Samagotchi memories — persisten
 - `name` is the entry name **without** `.md` (the tool adds it). Use `name`, **not** `path` — `path` belongs to the file tools and is ignored here. `name: "index"` is a verbatim write to `index.md` (no auto-index update) — rarely needed.
 - `scope` is **required** — never omit. Prefer `project` for repo conventions, `system` for user preferences.
 - `description` is appended to the managed `index.md` line (`— description`). Replaces previous description if given; otherwise preserves existing one.
-- On success returns `Memory 'name' saved to <scope> scope (N bytes). Index updated: …` — confirm `bytes` and `scope`.
+- For a small change to an existing memory (a step, a line), `edit` its file instead of rewriting it all: the path is in `memory_write`'s result and the scope dirs are in the prompt. Its index line is refreshed either way.
+- On success returns `Memory 'name' saved to <scope> scope (N bytes). File written: <path> Index line refreshed automatically.` — confirm `bytes` and `scope`; the index needs nothing from you.
 
 **When to write:**
 - After learning a durable preference (e.g. commit style, test command, coding guideline) that the user confirmed or you observed repeatedly — ask before overwriting existing entries where appropriate.
@@ -67,7 +68,7 @@ Shape (plain Markdown, no frontmatter):
 - **Scope**: `project` by default; `system` when the user asks, or when the skill is clearly not about this project.
 - **Saving**: on a request to keep how something was done ("let's memorize this", "save this as a skill", `/skill save`), write it at once, then show it briefly. On an ambiguous one ("I like how we did that") you may ask whether to save it.
 - **Following**: before a task a `skill_*` index line matches, `memory_read` it and follow its steps. A step that fails or names a missing file or command: find out why (look around, read nearby READMEs) before skipping it; a step that says stop means stop and ask. When anything looks unexpected (a check fails, output differs from what a step says, a warning the skill doesn't mention): stop, don't improvise a fix, tell the user what you saw and ask. Read each command's whole output, including warnings, before the next step.
-- **Updating**: when a step turned out different, rewrite the skill with `memory_write` in the same turn: fix those steps, keep the rest as it was, add a dated Changelog line. No confirmation needed.
+- **Updating**: when a step turned out different, update the skill in the same turn: `edit` those steps in its file (`<scope dir>/skill_<name>.md`), or rewrite it with `memory_write`; keep the rest as it was, add a dated Changelog line. No confirmation needed.
 - **The `skills` bundle** (`chi bundle install skills`, optional) adds `/skill save [name] [--system]`, `/skill list`, `/skill show <name>`, `/skill diff <name> [N]`; it keeps older versions and shows a short diff line after each update.
 
 ## Memory Bundles — shareable packs

data/lib/samagotchi/config.rb

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

data/lib/samagotchi/engine.rb

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

data/lib/samagotchi/guardrail_wiring.rb

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

data/lib/samagotchi/guardrails/gate.rb

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