samagotchi 0.156.0 → 0.158.0

data/lib/samagotchi/bundle_command.rb

@@ -39,7 +39,7 @@ module Samagotchi
           List installed bundles and the ones shipped with chi that aren't installed.
 
         build [--scope system|project] [--name NAME] [--version VER] [--description DESC] [--out PATH] [FILES...]
-          Build local memories and installed hooks (and plugin) into a shareable bundle (dir or zip).
+          Build local memories and an installed plugin, rules and scripts into a shareable bundle (dir or zip).
           --scope selects source dir (default: system). --out inferred from extension; default <name>.zip.
           FILES... optional allowlist of *.md basenames to include (default: all but installed bundles' ones);
           a named memory brings its model overlays (<name>.<model-key>.md).
@@ -75,7 +75,7 @@ module Samagotchi
           It also installs a bundle whose requires_chi this chi doesn't meet: without --force that install is
           refused, and the bundle is not written anywhere.
         install --dev PATH
-          Install the bundle in the local directory PATH as a link to it: its plugin, hooks, rules and scripts
+          Install the bundle in the local directory PATH as a link to it: its plugin, rules and scripts
           are PATH's own files (an edit applies at the next worker or chi web restart, with no re-install) and
           their sha256 isn't checked, for this bundle only. Its memories are copied; re-install with --force to
           pick up memory edits. Upgrade refuses it; uninstall removes the link, never PATH's files.
@@ -90,7 +90,7 @@ module Samagotchi
       Usage: chi bundle build [--scope system|project] [--name NAME] [--version VER] [--description DESC] [--out PATH] [FILES...]
 
         build [--scope system|project] [--name NAME] [--version VER] [--description DESC] [--out PATH] [FILES...]
-          Build local memories and installed hooks into a shareable bundle (dir or zip).
+          Build local memories and an installed plugin, rules and scripts into a shareable bundle (dir or zip).
           --scope selects source dir (default: system). --out inferred from extension; default <name>.zip.
           FILES... optional allowlist of *.md basenames to include (default: all but installed bundles' ones);
           a named memory brings its model overlays (<name>.<model-key>.md).
@@ -200,7 +200,7 @@ module Samagotchi
 
       installer = installer_for(expanded_source, bundle_name, prepared: prepared, scope: scope, force: force, dev: dev)
       run_installer(installer, failed: "Install") do |manifest|
-        print_hooks_and_plugin(manifest)
+        print_plugin(manifest)
         print_provenance(bundle_name, manifest)
       end
     end
@@ -236,7 +236,7 @@ module Samagotchi
 
       unless Samagotchi::MemoryBundle::Provenance.new(name: bundle_name).installed?
         @stderr.puts "Bundle '#{bundle_name}' not installed — falling back to install"
-        # (no Hooks/Plugin lines here)
+        # (no Plugin line here)
         installer = installer_for(expanded_source, bundle_name, prepared: prepared, scope: scope, force: force, dry_run: dry_run)
         return run_installer(installer, failed: "Install") do |manifest|
           next dry_run_done if dry_run
@@ -246,7 +246,7 @@ module Samagotchi
       end
       installer = installer_for(expanded_source, bundle_name, prepared: prepared, scope: scope, force: force, upgrade: true, dry_run: dry_run)
       run_installer(installer, failed: "Upgrade") do |manifest|
-        print_hooks_and_plugin(manifest, plugin: !dry_run)
+        print_plugin(manifest, plugin: !dry_run)
         next dry_run_done if dry_run
 
         # Its summary said so, to someone reading.
@@ -304,7 +304,7 @@ module Samagotchi
     # Runs +installer+, prints its summary, then yields the manifest.
     # Ensures the extracted source dir is cleaned up even if an exception
     # occurs between installer.run and the block (e.g. summary,
-    # print_hooks_and_plugin). The block (upgrade_conflicts) still sees
+    # print_plugin). The block (upgrade_conflicts) still sees
     # the files because cleanup happens after the block returns or raises.
     # @return [Integer] the block's exit status, or 1 after "<failed> failed: …"
     def run_installer(installer, failed:)
@@ -318,8 +318,7 @@ module Samagotchi
       installer.cleanup_source!
     end
 
-    def print_hooks_and_plugin(manifest, plugin: true)
-      @stdout.puts "Hooks: #{manifest.hooks.size} hook(s) (#{manifest.hooks.keys.join(", ")})" if manifest&.hooks&.any?
+    def print_plugin(manifest, plugin: true)
       return unless plugin && manifest&.plugin
 
       # Installed with --force past its requires_chi: the Engine won't load it.
@@ -425,8 +424,6 @@ module Samagotchi
         puts_trashed(uninstaller.trashed_files, uninstaller.trash_dir)
         @stdout.puts uninstaller.trash_copy_line if uninstaller.trash_copy_line
         @stdout.puts "Removed: #{uninstaller.removed_files.join(", ")}" unless uninstaller.removed_files.empty?
-        hook_removed = uninstaller.removed_files.count { |f| f.start_with?("hooks/") }
-        @stdout.puts "Hooks removed: #{hook_removed}" if hook_removed > 0
         uninstaller.warnings.each { |w| @stdout.puts w }
         0
       rescue Samagotchi::MemoryBundle::Uninstaller::UninstallError => e
@@ -519,22 +516,14 @@ module Samagotchi
           @stdout.puts "  #{k}: #{label}"
         end
         @stdout.puts "  #{manifest_line(st.provenance)}"
-        # Hooks
         manifest = st.provenance.manifest
-        hooks = manifest.hooks
         trust = manifest.trust_level || "experimental"
         commit = st.provenance.source_commit
-        @stdout.puts "  trust_level: #{trust}" if hooks.any? || trust
+        @stdout.puts "  trust_level: #{trust}"
         @stdout.puts "  source_commit: #{commit}" if commit
-        if hooks.any?
-          @stdout.puts "  Hooks (#{hooks.size}):"
-          hooks.each do |hk, hook|
-            hook_path = File.join(Samagotchi::MemoryBundle::Provenance.new(name: name).hooks_dir, hk)
-            exists = File.exist?(hook_path) ? "ok" : "missing"
-            @stdout.puts "    #{hk}: #{hook.events_field} on_error=#{hook.on_error} priority=#{hook.priority} [#{exists}]"
-          end
-          @stdout.puts "    requires_chi: #{manifest.requires_chi}" if st.hooks_requires_failure
-          @stdout.puts "    not loaded: #{st.hooks_requires_failure}" if st.hooks_requires_failure
+        unless st.retired_hooks.empty?
+          @stdout.puts "  Hooks (#{st.retired_hooks.size}): not loaded: #{Samagotchi::MemoryBundle::Manifest::HooksRetired::WORDS}"
+          st.retired_hooks.each { |file, state| @stdout.puts "    #{file} [#{state}]" }
         end
         if (plugin = st.plugin)
           note = plugin[:state] == "modified" ? " (edited after install: not loaded; reinstall the bundle)" : ""
@@ -555,11 +544,10 @@ module Samagotchi
 
           st = Samagotchi::MemoryBundle::Status.bundle_status(bname)
           mods = st.files.values.count { |v| v[:behind] || v[:missing] || v[:unreadable] }
-          hooks_count = st.provenance.manifest.hooks.size
-          hook_info = hooks_count > 0 ? " hooks=#{hooks_count}" : ""
+          hook_info = st.retired_hooks.empty? ? "" : " hooks=#{st.retired_hooks.size}"
           plugin = st.plugin
           mods += 1 if plugin && (plugin[:state] != "ok" || plugin[:requires_failure])
-          mods += 1 if st.hooks_requires_failure
+          mods += 1 unless st.retired_hooks.empty?
           mods += 1 if st.scope_error
           plugin_info = plugin ? " plugin=#{plugin[:file]}" : ""
           includes = st.provenance.includes
@@ -606,15 +594,12 @@ module Samagotchi
       rescue ArgumentError => e
         @stderr.puts "Bundle '#{bname}': #{e.message}"; return 1
       end
-      hooks = record.manifest.hooks
       plugin_path = prov.plugin_path(record)
       plugin_file = plugin_path && File.basename(plugin_path)
       if file_arg
-        # Try file first, then hook
+        # A memory first, then the plugin (an older chi's hook is no file of the bundle's)
         if record.owns?(file_arg)
           diff_memory(prov, target_dir, file_arg)
-        elsif hooks.key?(file_arg)
-          diff_hook(prov, file_arg, hooks[file_arg])
         elsif plugin_file && [plugin_file, "plugin/#{plugin_file}"].include?(file_arg)
           diff_plugin(prov, record, plugin_path)
         else
@@ -627,10 +612,6 @@ module Samagotchi
           diff_memory(prov, target_dir, key)
           @stdout.puts ""
         end
-        hooks.each do |key, hook|
-          diff_hook(prov, key, hook)
-          @stdout.puts ""
-        end
         if plugin_file
           diff_plugin(prov, record, plugin_path)
           @stdout.puts ""
@@ -639,9 +620,12 @@ module Samagotchi
       0
     end
 
+    # The base and the file; a marked one also the bundle's text it stays
+    # behind (its source-less FileState says which).
     def diff_memory(prov, target_dir, key)
-      print_base_and_current(key, prov.base_path(key), File.join(target_dir, key))
-      print_incoming(prov, key)
+      state = Samagotchi::MemoryBundle::FileState.of(key, record: prov.record, provenance: prov, target_dir: target_dir, source_dir: nil)
+      print_base_and_current(key, state.paths[:base], state.paths[:current])
+      print_incoming(prov, key) if state.marked?
     end
 
     # The bundle's text a file stays behind (Provenance#incoming_path), so the
@@ -663,11 +647,6 @@ module Samagotchi
       end
     end
 
-    def diff_hook(prov, key, hook)
-      print_base_and_current("hooks/#{key}", prov.base_path(key), File.join(prov.hooks_dir, key))
-      @stdout.puts hook_metadata_line(hook)
-    end
-
     def diff_plugin(prov, record, plugin_path)
       file = File.basename(plugin_path)
       print_base_and_current("plugin/#{file}", prov.plugin_base_path(file), plugin_path)
@@ -730,10 +709,6 @@ module Samagotchi
       "includes=#{here.join(",")}#{"  left out=#{gone.join(",")}" unless gone.empty?}"
     end
 
-    def hook_metadata_line(hook)
-      "--- metadata: #{hook.events_field} on_error=#{hook.on_error} priority=#{hook.priority} sha256=#{hook.sha256}"
-    end
-
     def build(rest)
       parsed = parse_flags(BUILD_FLAGS, rest, "build", help: BUILD_HELP)
       return parsed if parsed.is_a?(Integer)

data/lib/samagotchi/bundles/known-names/manifest.yml

@@ -1,17 +1,14 @@
 ---
 name: known-names
-version: 0.1.9
+version: 0.2.0
 requires_chi: ">= 0.150.0"
 scope: system
 description: Catches a near-miss of a protected name (home folder, login, git name, repo name, names from config) in a tool call and rejects it with the right spelling; mode ask / correct optional
 trust_level: reviewed
 files:
   known_names.md: sha256:d5348b95b6c655017b541910b36e384220da280818160201f6ec9a50e1e4287c
-hooks:
-  known_names.rb:
-    sha256: sha256:d7eed0dd0f418d8099a147ed124c6e6062b8c752035dd6b5aa5e926e29941c8b
-    event: before_tool_call
-    on_error: log
-    priority: 50
+plugin:
+  file: plugin.rb
+  sha256: sha256:d140612e6c34a9d2d205bf818a2a0797ad1e133829481f354aaa9e56698017e3
 # config.yml bundles: known-names: (another key warns; an older chi ignores this)
 settings: [names, ignore, mode, derive, min_length, max_distance]

data/lib/samagotchi/bundles/known-names/{hooks/known_names.rb → plugin.rb}

@@ -243,3 +243,20 @@ class KnownNames
     Array(value).map { |name| name.to_s.strip }.reject(&:empty?)
   end
 end
+
+# What chi loads: one KnownNames, built once from config.yml
+# `bundles: known-names:` when the plugin loads, on before_tool_call at
+# priority 50. A raise in the handler is logged and the call goes on
+# (chi.on's log policy); KnownNames#call turns its own errors into a
+# notice first.
+class Plugin
+  PRIORITY = 50
+
+  def initialize(settings = {})
+    @names = KnownNames.new(settings)
+  end
+
+  def register(chi)
+    chi.on(:before_tool_call, priority: PRIORITY) { |event, _ctx| @names.call(event) }
+  end
+end

data/lib/samagotchi/bundles/source-links/manifest.yml

@@ -1,17 +1,14 @@
 ---
 name: source-links
-version: 0.6.3
+version: 0.7.0
 scope: system
 description: Links source refs (JIRA tickets, GitHub issues, …) in the model's answer — inline links in the web, refs in a waiting question's reply, and a one-line note after the turn (note false turns it off); sources are configured patterns
 trust_level: reviewed
 requires_chi: ">= 0.150.0"
 files:
   source_links.md: sha256:ace01a0f7c308a0ae54ece714c31c0e6d7a49c372d98111030e6d268320bed3a
-hooks:
-  source_links.rb:
-    sha256: sha256:21d7a9f7c381c653b126b625feed0e0b6422eaa84c8dfe716b6c5b41644a33b3
-    events: [after_turn, question_asked]
-    on_error: log
-    priority: 90
+plugin:
+  file: plugin.rb
+  sha256: sha256:b4a777d8b6135f80e248dd21b5370c91dfcf2aea17057734e77241eb9cc4afe4
 # config.yml bundles: source-links: (another key warns; an older chi ignores this)
 settings: [sources, max, note]

data/lib/samagotchi/bundles/source-links/{hooks/source_links.rb → plugin.rb}

@@ -59,10 +59,10 @@ require "samagotchi/ref"
 # action, "Open in <name>", the ref's URL. A URL that isn't http(s) stays a
 # markdown link only. The web's ref menu shows the action.
 #
-# The hook is on :question_asked too (the manifest's events:, chi newer than
-# 0.97.0): while a question of the model's (or an approval of its call)
-# waits, the refs in the reply that asks it, and in the question's text and
-# options, are refs on that reply, the same as an answer's. The web pairs
+# The hook is on :question_asked too (Plugin below hooks both events): while
+# a question of the model's (or an approval of its call) waits, the refs in
+# the reply that asks it, and in the question's text and options, are refs
+# on that reply, the same as an answer's. The web pairs
 # them in the stage's asking slot, on the question's card and on that step
 # in the history (a ref only in the question's text pairs there alone). No
 # links in the text and no note line for it: the turn's end has those.
@@ -657,3 +657,22 @@ class SourceLinks
     value.to_s.gsub(/[^A-Za-z0-9\-._~]/) { |c| c.bytes.map { |b| format("%%%02X", b) }.join }
   end
 end
+
+# What chi loads: one SourceLinks, built once from config.yml
+# `bundles: source-links:` when the plugin loads, on after_turn and
+# question_asked at priority 90 (its state, the remotes it asked git for,
+# is shared). A raise in the handler is logged and the turn goes on
+# (chi.on's log policy).
+class Plugin
+  PRIORITY = 90
+
+  def initialize(settings = {})
+    @links = SourceLinks.new(settings)
+  end
+
+  def register(chi)
+    %i[after_turn question_asked].each do |event|
+      chi.on(event, priority: PRIORITY) { |payload, _ctx| @links.call(payload) }
+    end
+  end
+end

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

@@ -76,7 +76,7 @@ guardrails:
   disable: [guardrails:git-rebase]
 ```
 
-- `bundles:` map of installed bundle name → its settings (one Hash, string keys, handed to the bundle's hook/plugin `initialize(settings)`). Read when a session's Engine starts: after a change restart the session's worker (`chi sessions stop <id>`). Unknown keys are ignored by the bundle, not validated. `chi bundle list` names the bundles; each bundle's keys are in `docs/bundles.md` / `docs/guardrails.md`.
+- `bundles:` map of installed bundle name → its settings (one Hash, string keys, handed to the bundle's plugin `initialize(settings)`). Read when a session's Engine starts: after a change restart the session's worker (`chi sessions stop <id>`). Unknown keys are ignored by the bundle, not validated. `chi bundle list` names the bundles; each bundle's keys are in `docs/bundles.md` / `docs/guardrails.md`.
 
 ```yaml
 bundles:

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.156.0
+version: 0.158.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:709bd52710bf6c50334a89a10742ea1554c5985cc2d7c4e7571e526cc4479526
-  config_modification_protocol.md: sha256:25ed2d4901f00eeea226db5eb2b75a05d6cdee4015ac8daa4bed624f745c3922
-  memory_guide.md: sha256:8b7727b939b9c04486ca59859561023dcc319a73e0f5b47b3fcf5741edaa69e2
+  self_map.md: sha256:750822b3488b302c6e32638e6224f270d8e06b50ea85cd6e0bb5a6ff12eed1d8
+  config_modification_protocol.md: sha256:44cf7bdac8e526805bff36b76b54fefecd41db30ca525c2ed661d78fe9155dd8
+  memory_guide.md: sha256:91e8fd248a155afad6b825097d9ee0a0215ba0b79092c8ab25501c0fc19dedfc
   delegated.md: sha256:a0d6ddcd4a8be06526d964898611775fd251cfd9d145a9d16afaccaa503597bd

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

@@ -15,7 +15,7 @@ This memory teaches you (the agent) how to use Samagotchi memories — persisten
 | `system` | `$XDG_CONFIG_HOME/samagotchi/memories/`, default `~/.config/samagotchi/memories/` (`MemoryPaths.system_dir`) | User-wide preferences, identity, cross-project knowledge |
 | `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 that folder (not the root: in a linked worktree, work stays in the worktree). Outside a repository the root is the working directory. A separate clone is a different project.
+- 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 that folder (not the root: in a linked worktree, work stays in the worktree). A separate clone is a different project. Outside a repository, a folder marked by `chi project init` (its `.chi/project.yml`) is the project for it and every subfolder; outside both, the root is the working directory.
 - `index.md` lives in each scope dir and contains auto-managed lines like `- **name** · scope · date · bytes — description`; a memory a bundle installed adds `· from <bundle>` before the 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
@@ -101,11 +101,11 @@ Writing or updating a toolkit memory is free like writing a skill; say so in the
 
 ## Memory Bundles — shareable packs
 
-Bundles are versioned directories/zips/tar.gz/git URLs with a `manifest.yml` and any of: memories (`*.md`), `hooks/*.rb` (bundle hooks, `docs/hooks.md`), `guardrails/*.yml` (rules, `docs/guardrails.md`), a `plugin.rb` (commands, tools, hooks, services; `docs/plugins.md`). They are shareable and installable.
+Bundles are versioned directories/zips/tar.gz/git URLs with a `manifest.yml` and any of: memories (`*.md`), `guardrails/*.yml` (rules, `docs/guardrails.md`), a `plugin.rb` (commands, tools, hooks, services; `docs/plugins.md`; class-file `hooks/*.rb` are retired: chi refuses a source with them, `docs/hooks.md`). They are shareable and installable.
 
-- Manifest: `files:` (memory → `sha256:`), `hooks:` (file → sha256/event/on_error/priority), `plugin: {file: plugin.rb, sha256: sha256:…}`, `requires_chi: ">= 0.1.30"` (gem-style), `needs:` (outside commands looked up on `PATH`, advisory; `docs/memory.md` "Bundles that need outside commands").
-- 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.
+- Manifest: `files:` (memory → `sha256:`), `plugin: {file: plugin.rb, sha256: sha256:…}`, `requires_chi: ">= 0.1.30"` (gem-style), `needs:` (outside commands looked up on `PATH`, advisory; `docs/memory.md` "Bundles that need outside commands").
+- Integrity: each file's sha256 is recorded at install; a 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 (the 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, slow-commands; `chi bootstrap` installs it) and `dev` (known-names, mcp, btw, skills, source-links, github-pr, coordinator, claude-peer, codex-peer). `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").
 
@@ -114,12 +114,12 @@ Bundles are versioned directories/zips/tar.gz/git URLs with a `manifest.yml` and
 | Command | Purpose |
 |---------|---------|
 | `install <source> [--scope system\|project] [--force]` | Install from dir/zip/tar.gz/git URL. `--force` overwrites existing entries, otherwise skips them; a skipped file stays the user's (not recorded, never upgraded or removed by the bundle). It also installs a bundle whose `requires_chi` this chi doesn't meet: without `--force` that install is refused (`NAME can't be installed: it requires chi …`). Writes provenance to `.bundles/<name>/` (base snapshots + `manifest.json`) and updates `index.md`. Warns on double-brace placeholders and checksum mismatches (strict mode). |
-| `upgrade <source\|name> [--force] [--dry-run] [--agent]` | A bare `name` is an installed bundle: chi upgrades it from the source its record keeps (its git URL with the `#ref` it recorded, its folder, or the archive it came from) — a dev install is refused, and a record whose source is gone says so and asks for the path or URL. Otherwise 3-way merge upgrade (base vs current vs incoming) per `Merger::Upgrade#outcome` (`Merger.classify`, then a text merge where both sides changed): `install` (new file), `noop` (current==incoming), `fast_forward` (current==base, not edited → auto-update), `keep` (incoming==base → preserve local edits), `merged` (both edited, a text merge with `git` comes out clean → the file takes it, the old one goes to the bundle trash, and entries both sides added under a `Changelog` heading are kept), `conflict` (both edited, a real conflict, or no `git` or base → the file stays untouched and marked, reported as `X stays behind 0.8.0: …` with why and what it missed, needs a retry, `--force`, which copies it to the trash first, or interactive `memory_write` resolution). A marked file is retried at the same version: the system bundle's at each chi start and on `chi update`, another shipped bundle's on `chi update`, any other bundle's on `chi bundle upgrade`. A file marked by an older chi merges normally when its recorded base is a version chi shipped (an installed samagotchi gem still has it); otherwise it merges only if the bundle takes out or rewords no line it still holds, and if it does, it stays behind until resolved by hand, with `--agent` or with `--force`, and the retry can't fix that. Pruned files (removed from new bundle) are kept if locally edited, otherwise warned. |
+| `upgrade <source\|name> [--force] [--dry-run] [--agent]` | A bare `name` is an installed bundle: chi upgrades it from the source its record keeps (its git URL with the `#ref` it recorded, its folder, or the archive it came from) — a dev install is refused, and a record whose source is gone says so and asks for the path or URL. Otherwise 3-way merge upgrade (base vs current vs incoming) per `Merger::Upgrade#decision` (the file's `FileState` and its `FileActions` row, then a text merge where both sides changed): `install` (new file), `noop` (current==incoming), `fast_forward` (current==base, not edited → auto-update), `keep` (incoming==base → preserve local edits), `merged` (both edited, a text merge with `git` comes out clean → the file takes it, the old one goes to the bundle trash, and entries both sides added under a `Changelog` heading are kept), `conflict` (both edited, a real conflict, or no `git` or base → the file stays untouched and marked, reported as `X stays behind 0.8.0: …` with why and what it missed, needs a retry, `--force`, which copies it to the trash first, or interactive `memory_write` resolution). A marked file is retried at the same version: the system bundle's at each chi start and on `chi update`, another shipped bundle's on `chi update`, any other bundle's on `chi bundle upgrade`. A file marked by an older chi merges normally when its recorded base is a version chi shipped (an installed samagotchi gem still has it); otherwise it merges only if the bundle takes out or rewords no line it still holds, and if it does, it stays behind until resolved by hand, with `--agent` or with `--force`, and the retry can't fix that. Pruned files (removed from new bundle) are kept if locally edited, otherwise warned. |
 | `uninstall <bundle> [--force]` | Moves the bundle's memory files to `.bundles/.trash/<bundle>-<time>/` (refuses locally edited ones unless `--force`; keeps a file another installed bundle also lists), removes their `index.md` lines, deletes the provenance dir. |
 | `status [<bundle>]` | Provenance + per-file `ok|modified|missing|unreadable|no-index` vs stored checksum and base snapshot, and what stays behind or merged at a chi start; `issues=` counts files behind, missing or unreadable, not edits; a model overlay (`<name>.<key>.md`) has no index line and reads `ok (model overlay)`. |
 | `diff <bundle> [file]` | Prints `base` (provenance snapshot) vs `current` (on-disk) for each file. |
 | `list` | Lists installed bundles (`name v<version> scope files installed_at`, plus the shipped version when newer) and the bundles shipped with chi that are not installed (`install <name>` installs one), grouped under their profile; an installed profile shows `includes=` and `left out=`. |
-| `build [--scope system\|project] [--name NAME] [--version VER] [--description DESC] [--out PATH] [FILES...]` | **Inverse of install** — builds a shareable bundle from local memories and installed hooks. Infers `zip` vs `dir`/`tar.gz` from `--out` extension; default `chi_system_memories.zip` (system) or `chi_<repo>_memories.zip` (project, named after the project root) v`1.0.0` in `Dir.pwd`. `FILES...` is an optional allowlist of memory basenames (`identity` or `identity.md`); if omitted, all `*.md` except `index.md`/hidden/non-md and the memories other installed bundles own (each named in a `Left out` line) are included. Installed hooks are copied to `hooks/` with their manifest metadata. Computes `sha256:` checksums and writes `manifest.yml` via `Manifest.write`. No provenance write. |
+| `build [--scope system\|project] [--name NAME] [--version VER] [--description DESC] [--out PATH] [FILES...]` | **Inverse of install** — builds a shareable bundle from local memories and an installed bundle's plugin, rules and scripts. Infers `zip` vs `dir`/`tar.gz` from `--out` extension; default `chi_system_memories.zip` (system) or `chi_<repo>_memories.zip` (project, named after the project root) v`1.0.0` in `Dir.pwd`. `FILES...` is an optional allowlist of memory basenames (`identity` or `identity.md`); if omitted, all `*.md` except `index.md`/hidden/non-md and the memories other installed bundles own (each named in a `Left out` line) are included. Computes `sha256:` checksums and writes `manifest.yml` via `Manifest.write`. No provenance write. |
 
 **Scope resolution for install/build:**
 - CLI `--scope` wins over `manifest.yml` `scope`. Default is `system` if none given (`Installer#run`). For `project`, target is the project folder `<system dir>/projects/<basename>_<hash>` of the project root (`MemoryPaths.scope_dir`).

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

@@ -51,7 +51,7 @@
   normal session: it shows in `chi sessions list` with `↳ <parent>`, and the user can steer it
   with `chi --attach <id>`. While I wait for a child, its tool approvals go to my user as my own
   approvals (I see only how each was answered); see `docs/sessions.md` "Delegating".
-- Bundles extend me: memories, `hooks/*.rb`, `guardrails/*.yml`, and a `plugin.rb` that adds slash
+- Bundles extend me: memories, `guardrails/*.yml`, and a `plugin.rb` that adds slash
   commands (`anytime:` ones run mid-turn), model tools (they can return images I see), hooks,
   cards, side answers (`ask_model`), System 1 judgments (`chi.judgment`, `ctx.judge`), HTTP calls (`ctx.http`),
   child sessions and services (e.g. MCP server processes). Shipped: `btw` (`/btw` side question),

data/lib/samagotchi/child_move.rb

@@ -60,23 +60,23 @@ module Samagotchi
       move = []
       refuse = []
       SessionManager.children_of(prev_id, state_dir: state_dir).each do |row|
-        subtree = [row[:id], *SessionManager.descendant_ids(row[:id], state_dir)]
+        subtree = [row.id, *SessionManager.descendant_ids(row.id, state_dir)]
         next if (subtree & open_ids).empty?
 
-        if row[:archived]
+        if row.archived
           # An open delegate below an archived one: the archive's cascade
           # would take it, the move doesn't (only unarchived ones move).
           refuse.concat(open.select { |c| subtree.include?(c.id) }.map do |c|
-            c.with(why: "under archived #{row[:id][0, 8]}; unarchive that one or archive this one")
+            c.with(why: "under archived #{row.short_id}; unarchive that one or archive this one")
           end)
           next
         end
 
-        why = unmovable(row[:id], state_dir: state_dir)
+        why = unmovable(row.id, state_dir: state_dir)
         if why
-          refuse << SessionContinue::OpenChild.new(id: row[:id], short_id: row[:id][0, 8], why: why)
+          refuse << SessionContinue::OpenChild.new(id: row.id, short_id: row.short_id, why: why)
         else
-          move << row[:id]
+          move << row.id
         end
       end
       Plan.new(move: move, refuse: refuse)

data/lib/samagotchi/child_reports.rb

@@ -335,8 +335,8 @@ module Samagotchi
       before = kept ? kept.after : current
       # A follow-up's turn (DelegateCursor#turn) is reported by its own
       # reply, as delegate_result takes it, not a newer queued turn's.
-      wait = ReplyWait.call(child_id, state_dir: @state_dir, cursor: before.reply_file, baseline: before.baseline,
-                                      timeout: 0, turn: before.turn)
+      wait = ReplyWait.call(child_id, state_dir: @state_dir, **ReplyWait::Target.from_cursor(before, child: child).to_h,
+                                      timeout: 0)
       return nil unless reportable?(wait)
 
       claim_id = before.report_claim&.id || SecureRandom.hex(16)

data/lib/samagotchi/children_status.rb

@@ -5,7 +5,8 @@ require_relative "session"
 require_relative "archive_store"
 require_relative "git_head"
 require_relative "reply_wait"
-require_relative "worker_link"
+require_relative "owner_lock"
+require_relative "session_row"
 require_relative "tools/delegate"
 require_relative "tools/delegate_cursor"
 
@@ -50,44 +51,47 @@ module Samagotchi
     def of(parent_id, state_dir:, include_archived: false)
       cursors = Tools::DelegateCursors.read(parent_id, state_dir: state_dir)
       SessionManager.children_of(parent_id, state_dir: state_dir).filter_map do |row|
-        next if row[:archived] && !include_archived
+        next if row.archived && !include_archived
 
-        session = load(row[:id], state_dir: state_dir)
+        session = load(row.id, state_dir: state_dir)
         session && child(session, row, cursors, state_dir: state_dir)
       end
     end
 
     # The cheap path for the glance views: only the children in the
-    # parent's delegates.json (one Session.load and an owner check each, no
+    # parent's delegates.json (one Session.load and a SessionRow each, no
     # scan). Its keys can also name a fork the model passed to delegate
     # session: or a deleted child: only live delegates of this parent count,
     # archived ones don't.
     # @return [Counts]
     def counts(parent_id, state_dir:)
       cursors = Tools::DelegateCursors.read(parent_id, state_dir: state_dir)
+      budgets = SessionRow.budgets
       children = cursors.keys.filter_map do |id|
         session = load(id, state_dir: state_dir)
         next unless session&.delegate? && session.parent_id == parent_id
         next if ArchiveStore.archived?(Session.session_dir(id, state_dir: state_dir))
 
-        child(session, summary_of(session, state_dir: state_dir), cursors, state_dir: state_dir)
+        dir = Session.session_dir(id, state_dir: state_dir)
+        child(session, SessionRow.build(session, session_dir: dir, owner: OwnerLock.owner(dir), budgets: budgets), cursors,
+              state_dir: state_dir)
       end
       Counts.new(running: children.count { |c| c.state == "running" },
                  waiting: children.count { |c| c.state == "waiting" },
                  unreported: children.count { |c| c.last_reply && !c.reported })
     end
 
-    # @param row [Hash] a children_of row, or summary_of's keys
+    # @param row [SessionRow] the child's row
     # @param cursors [Hash] the parent's delegates.json
     def child(session, row, cursors, state_dir:)
       reply = ReplyWait.newest_reply(session.id, state_dir: state_dir)
       cursor = Tools::DelegateCursors.get_from(cursors, session.id)
-      Child.new(id: session.id, short_id: session.id[0, 8], title: (session.title || row[:preview]).to_s,
-                state: state_of(session, row, reply), waiting: row[:waiting], live: !!row[:live],
+      Child.new(id: session.id, short_id: session.id[0, 8], title: (session.title || row.preview).to_s,
+                state: state_of(session, row, reply), waiting: row.waiting, live: !!row.live,
                 delegate: session.delegate?, cwd: session.working_directory, branch: GitHead.branch(session.working_directory),
                 last_reply: reply && first_line(session.id, reply, state_dir: state_dir),
                 last_reply_at: reply && reply_time(reply), reported: !reply.nil? && reported?(session, cursor, reply),
-                updated_at: session.updated_at, archived: !!row[:archived])
+                updated_at: session.updated_at, archived: !!row.archived)
     end
     private_class_method :child
 
@@ -97,8 +101,8 @@ module Samagotchi
     private_class_method :reported?
 
     def state_of(session, row, reply)
-      return "waiting" if row[:waiting]
-      return "running" if Tools::Delegate.running?(row)
+      return "waiting" if row.waiting
+      return "running" if row.running_or_starting?
       return "stopped" if session.status == Session::STATUS_STOPPED
 
       outcome = session.last_turn&.outcome
@@ -109,16 +113,6 @@ module Samagotchi
     end
     private_class_method :state_of
 
-    # The keys of a children_of row that state_of and child read, for a
-    # session counts loaded itself.
-    def summary_of(session, state_dir:)
-      live = WorkerLink.resolve(Session.session_dir(session.id, state_dir: state_dir), unlink: false).worker_owned?
-      { live: live, busy: live && session.status == Session::STATUS_RUNNING, saved_status: session.status,
-        updated_at: session.updated_at, waiting: session.waiting_question(live: live)&.dig(:kind),
-        preview: session.last_prompt.to_s }
-    end
-    private_class_method :summary_of
-
     def first_line(id, file, state_dir:)
       text = File.read(File.join(ReplyWait.reply_dir(id, state_dir: state_dir), file), 4096)
       text.each_line.map(&:strip).find { |line| !line.empty? }.to_s

data/lib/samagotchi/cli/parent_wait.rb

@@ -17,9 +17,6 @@ module Samagotchi
     # override the constants (specs stub them on the class).
     module ParentWait
       POLL_INTERVAL = ReplyWait::POLL_INTERVAL
-      # No live worker this long while waiting: it died before it could mark
-      # the session (a worker takes well under a second to start).
-      WORKER_GONE_AFTER = 5
       FORMATS = %w[text json].freeze
 
       # @return [Integer] the exit status
@@ -59,26 +56,15 @@ module Samagotchi
         nil
       end
 
-      # Wait for the session's next reply past +cursor+ (ReplyWait) and
-      # report it. Ctrl-C leaves the turn running (130).
-      # @param owner_grace [Numeric, nil] seconds with no live worker before
-      #   it counts as gone; nil waits for whatever wakes one
-      # @param turn [String, nil] the enqueued_id of the turn waited for
-      #   (ReplyWait's turn:): a queued message's, or the turn an answer or
-      #   a --wait with no message is about (ReplyWait.own_turn)
-      # @param queued [Boolean] +turn+ is a queued message's (ReplyWait's
-      #   queued:)
-      # @param ended_before [Boolean] a last_turn that ended before the
-      #   baseline is the answer (ReplyWait's ended_before:) — the
-      #   --wait-with-no-message's settled session
-      # @param report_turn_id [String, nil] the turn id to include in the
-      #   report, even when ReplyWait uses the next-reply path
+      # Wait for what +target+ binds (ReplyWait) and report it. Ctrl-C
+      # leaves the turn running (130).
+      # @param target [ReplyWait::Target] which turn, from the cursor and
+      #   baseline prepare_wait read; its report_turn_id is the turn id the
+      #   report names, even when ReplyWait takes the next reply
       # @return [Integer] the exit status
-      def wait_for_reply(id, cursor:, baseline:, timeout:, owner_grace: self.class::WORKER_GONE_AFTER, turn: nil,
-                         queued: false, ended_before: false, report_turn_id: turn)
-        result = @access.wait_reply(id, cursor: cursor, timeout: timeout, baseline: baseline, owner_grace: owner_grace,
-                                        poll_interval: self.class::POLL_INTERVAL, turn: turn, queued: queued,
-                                        ended_before: ended_before)
+      def wait_for_reply(id, target:, timeout:)
+        report_turn_id = target.report_turn_id
+        result = @access.wait_reply(id, **target.to_h, timeout: timeout, poll_interval: self.class::POLL_INTERVAL)
         result.turn_id = report_turn_id if report_turn_id && !report_turn_id.to_s.empty?
         result.text = result.text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
         @reported = true

data/lib/samagotchi/config.rb

@@ -373,6 +373,9 @@ module Samagotchi
       # The stage view's working set (files, memories and URLs the turn brought into context): a rail in the stage, a
       # footprint under each finished turn and a "set N" chip in place of the mem chip; ?working_set=1|0 overrides it per page load.
       Entry.new(key: "web.working_set",          yaml_path: %w[web working_set],          type: :bool,    default: true,            expose: %i[env config cli], lifecycle: :web_start),
+      # Opt-in: the page checks each finished turn against a reload of it (one full read per turn end) and chi web logs
+      # reload_checked, with reload_mismatch and the kinds that differed (counts only, no content).
+      Entry.new(key: "web.reload_check",         yaml_path: %w[web reload_check],         type: :bool,    default: false,           expose: %i[env config cli], lifecycle: :web_start),
       # Quick replies next to Annotate in the page's selection bubble, "|"-separated (a YAML list works too); "" leaves only Annotate.
       Entry.new(key: "web.annotate_presets",     yaml_path: %w[web annotate_presets],     type: :string, default: "Agreed|Could you please elaborate?", expose: %i[env config cli], lifecycle: :web_start),
       # What a file ref (a tool row's file, a diff line) opens on this machine: a preset (vscode, vscode-insiders, cursor, zed, none) or a URL template with {path} and an optional {line} (Web::Editor).

data/lib/samagotchi/context_command.rb

@@ -409,17 +409,19 @@ module Samagotchi
     end
 
     # A project's sources: local only (SessionAccess::Contract), this
-    # machine's checkout.
+    # machine's checkout or marked folder.
     def project_target
-      unless MemoryPaths.in_repo?(@cwd)
-        error_line("#{command_name}: --project needs a git repository, and #{@cwd} is in none")
+      found = MemoryPaths.lookup(@cwd)
+      unless found.project?
+        error_line("#{command_name}: --project needs a project (a git repository, or a folder marked with " \
+                   "`chi project init`), and #{@cwd} is in none")
         return nil
       end
 
-      root = MemoryPaths.project_root(@cwd)
+      root = found.root
       # Its sources run in the root, or in this checkout when the root is a
       # git dir (ContextSources.project_cwd).
-      Target.new(session_id: nil, project_root: root, cwd: MemoryPaths.work_tree_root(@cwd) || @cwd,
+      Target.new(session_id: nil, project_root: root, cwd: found.top || @cwd,
                  label: "project #{File.basename(root)}")
     end