samagotchi 0.157.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 ""
@@ -666,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)
@@ -733,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/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.157.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:fe4dbb25ce4c9f9b51507a6130fa7bf992a2cc41af2453830eacd27c09a65d1e
+  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").
 
@@ -119,7 +119,7 @@ Bundles are versioned directories/zips/tar.gz/git URLs with a `manifest.yml` and
 | `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/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
 

data/lib/samagotchi/context_sources.rb

@@ -658,13 +658,15 @@ module Samagotchi
     end
 
     # Where a project's source runs: the project root when it is a checkout
-    # (its .git is there), else +fallback+ (the session's folder): a bare
+    # (its .git is there) or a marked folder (MemoryPaths::MARKER), else
+    # +fallback+ (the session's folder): a bare
     # repo, proj/.bare or --separate-git-dir makes the root the git dir
     # itself (MemoryPaths.project_root), and a command run there sees no
     # files.
     def project_cwd(project_root, fallback)
       root = project_root.to_s
-      !root.empty? && File.exist?(File.join(root, ".git")) ? root : fallback
+      checkout = !root.empty? && [".git", MemoryPaths::MARKER].any? { |name| File.exist?(File.join(root, name)) }
+      checkout ? root : fallback
     end
 
     # A deleted session's sources, snapshots, subscriptions and markers.

data/lib/samagotchi/engine.rb

@@ -357,12 +357,7 @@ module Samagotchi
     # toolkit, the tool index, peer sources), then the plugins themselves
     # unless +load+ is false (see #initialize for when).
     def build_tools_and_plugins(load:, task_finish_notes:)
-      # The routes are built already (#initialize), so a bundle's hook file
-      # that raises at fire time is told the same way a chi.on handler is:
-      # once per hook in this worker. The guard covers a hook that raises
-      # before the routes are there (nothing in the Engine's path does).
-      @extension_load = ExtensionLoad.new(hook_failures: @guardrail_failures,
-                                          hook_failed: ->(hook, failed, effect: nil) { @hook_routes&.plugin_hook_failed(hook, failed, effect: effect) })
+      @extension_load = ExtensionLoad.new(hook_failures: @guardrail_failures)
       @hooks = @extension_load.hooks
       # The tools this session offers (the prompts' declarations and the
       # kernel's dispatch): the built-ins, per Engine. execute.description

data/lib/samagotchi/extension_load.rb

@@ -7,20 +7,13 @@ require_relative "plugin/loader"
 
 module Samagotchi
   # What an Engine loads from outside chi as it starts: config.yml's hooks,
-  # installed bundles' hooks and plugins, and config.yml `bundles:` (their
-  # settings). It holds what plugins showed while they loaded (notices,
+  # installed bundles' plugins, and config.yml `bundles:` (their settings). It holds what plugins showed while they loaded (notices,
   # cards): no UI is there yet, so the Engine announces them on the first
   # turn (Engine#announce_load_events!).
   class ExtensionLoad
     # @param hook_failures [Guardrails::LoadFailures] where hooks that fail to load go
-    # @param hook_failed [#call, nil] (label, "Class: message", effect:) when
-    #   an installed bundle's hook file raises at fire time: the Engine's
-    #   HookRoutes, so the user is told once per hook. nil where there is no
-    #   UI to tell (the test kit's sandbox): a hook that raises then says
-    #   nothing, and raises nothing.
-    def initialize(hook_failures:, hook_failed: nil)
+    def initialize(hook_failures:)
       @hook_failures = hook_failures
-      @hook_failed = hook_failed
       @loading = false
       @held_events = []
     end
@@ -40,12 +33,13 @@ module Samagotchi
     end
 
     # The hooks: config.yml's (Hooks::Loader; an empty Registry without a
-    # hooks config), then the installed bundles' added to them.
+    # hooks config). An installed record that still has class-file hooks (a
+    # 0.157 install) adds a not-required failure each, which the Engine
+    # announces at the first turn: they don't load (#tell_retired_hooks).
     # @return [Hooks::Registry]
     def hooks
-      registry = hooks_from_config
-      add_bundle_hooks(registry)
-      registry
+      tell_retired_hooks
+      hooks_from_config
     end
 
     # Load the installed bundles' plugins into +registries+; one that fails
@@ -62,8 +56,7 @@ module Samagotchi
       @loading = false
     end
 
-    # config.yml `bundles:` (ConfigFile.bundle_settings), read once: the
-    # bundle hooks and the plugins both want it.
+    # config.yml `bundles:` (ConfigFile.bundle_settings), read once.
     def bundle_settings
       @bundle_settings ||= Samagotchi::ConfigFile.bundle_settings
     end
@@ -78,36 +71,22 @@ module Samagotchi
       Hooks::Registry.new
     end
 
-    def add_bundle_hooks(registry)
+    # One failure per record whose hooks: map isn't empty; an empty
+    # hooks/ dir is not one, nor a manifest.json that doesn't read (the
+    # plugin loader and the rules report that: a record holding only hooks/
+    # with an unreadable manifest.json is silent at start, as its hooks
+    # wouldn't load anyway; `chi bundle status` lists it unreadable).
+    def tell_retired_hooks
       require_relative "memory_bundle/provenance"
-      settings = bundle_settings
       MemoryBundle::Provenance.each_installed(holding: :hooks) do |bundle_name, bundle|
-        if bundle.error?
-          Log.warn(:hooks, "bundle_manifest_invalid", echo: "[samagotchi:hooks] bundle '#{bundle_name}': #{bundle.error}; its hooks are not loaded",
-                                                      bundle: bundle_name)
-          @hook_failures.add("hooks (bundle #{bundle_name})", bundle.error, required: false)
-          next
-        end
-        bundle_dir = File.join(MemoryBundle::Provenance.bundles_dir, bundle_name)
-        hooks_dir = File.join(bundle_dir, "hooks")
-        manifest = bundle.manifest
-        if manifest.experimental?
-          Log.info(:hooks, "experimental_bundle", echo: "[hooks] Bundle '#{bundle_name}' is experimental — its hooks may change or misbehave.", bundle: bundle_name)
-        end
-        begin
-          Hooks::BundleLoader.load(bundle_name: bundle_name, hooks_dir: hooks_dir, metadata: manifest.hooks, registry: registry,
-                                   failures: @hook_failures, settings: settings[bundle_name.to_s] || {},
-                                   manifest: manifest, hook_failed: @hook_failed)
-        rescue Exception => e # rubocop:disable Lint/RescueException -- a hook's SyntaxError or exit must not stop chi
-          raise if e.is_a?(SignalException) # Ctrl-C and kill signals are the user's
+        next if bundle.error?
 
-          Log.error(:hooks, "bundle_load_failed", echo: "[samagotchi:hooks] bundle '#{bundle_name}' failed to load hooks: #{e.class}: #{e.message}", bundle: bundle_name, error: e.class.name)
-        end
+        Log.warn(:hooks, "bundle_hooks_retired", bundle: bundle_name, hooks: bundle.hooks.size)
+        @hook_failures.add("hooks (bundle #{bundle_name})", MemoryBundle::Manifest::HooksRetired::WORDS, required: false)
       end
-    rescue Exception => e # rubocop:disable Lint/RescueException -- a hook's SyntaxError or exit must not stop chi
-      raise if e.is_a?(SignalException) # Ctrl-C and kill signals are the user's
-
-      Log.error(:hooks, "bundles_load_failed", echo: "[samagotchi:hooks] failed to load bundle hooks: #{e.class}: #{e.message}", error: e.class.name)
+    rescue StandardError => e
+      Log.error(:hooks, "bundles_load_failed", echo: "[samagotchi:hooks] failed to read the installed bundles: #{e.class}: #{e.message}",
+                                               error: e.class.name)
     end
   end
 end

data/lib/samagotchi/guardrails/load_failures.rb

@@ -2,8 +2,9 @@
 
 module Samagotchi
   module Guardrails
-    # What failed to load at Engine start: hooks, bundle hook checksums,
-    # rule files. A required one makes the gate deny every tool call (a
+    # What failed to load at Engine start: config hooks, a required
+    # plugin, rule files, an older chi's class-file bundle hooks (which no
+    # longer load). A required one makes the gate deny every tool call (a
     # guardrail that silently vanished is the failure this guards against);
     # the rest are only announced.
     class LoadFailures

data/lib/samagotchi/guardrails/path_resolve.rb

@@ -153,6 +153,17 @@ module Samagotchi
         (low == low_dir || low.start_with?(File.join(low_dir, ""))) && folds_case?(dir)
       end
 
+      # Whether +root+ is the home folder or a folder above it (symlinks
+      # resolved on both; false for a blank one). ReviewPaths (a participant
+      # turn's project) and MemoryPaths (where a chi project marker is
+      # ignored) ask this.
+      # @param root [String, nil] @param home [String, nil]
+      def home_root?(root, home)
+        return false if home.to_s.empty? || root.to_s.empty?
+
+        under?(real(home.to_s), real(root.to_s))
+      end
+
       # Whether +path+ is in +dir+, not +dir+ itself (.under?'s terms).
       def strictly_under?(path, dir, fold: true)
         return true if path.start_with?(File.join(dir, ""))

data/lib/samagotchi/guardrails/review_paths.rb

@@ -59,11 +59,7 @@ module Samagotchi
       # review turn reads nothing there (#refusal: HOME_ROOT); a pair turn
       # asks the owner before every write (PairBoundary).
       # @param root [String] @param home [String, nil]
-      def self.home_root?(root, home)
-        return false if home.to_s.empty? || root.to_s.empty?
-
-        PathResolve.under?(PathResolve.real(home.to_s), PathResolve.real(root.to_s))
-      end
+      def self.home_root?(root, home) = PathResolve.home_root?(root, home)
 
       # @param root [String, nil] the session's project root (the work tree
       #   top of its folder); nil or blank refuses every path

data/lib/samagotchi/hook_routes.rb

@@ -21,7 +21,7 @@ module Samagotchi
     # How much of a failed hook's error #plugin_hook_failed shows.
     HOOK_FAILURE_CHARS = 300
     # What the notice says the hook now does, by the policy Hooks.wrap gave it
-    # (a chi.on handler is always :log; a bundle's hook file any of the three).
+    # (a chi.on handler :log, or :deny for an on_error: :fail_closed one).
     HOOK_FAILURE_EFFECTS = {
       log: "it's skipped, and only the log has its next failures",
       skip: "it's skipped, and its next failures are silent",
@@ -98,7 +98,7 @@ module Samagotchi
       nil
     end
 
-    # A bundle hook file or a chi.on handler raised (Hooks.wrap; the log has
+    # A chi.on handler raised (Hooks.wrap; the log has
     # every firing of a :log one). Its first failure on this Engine, so in
     # this worker, tells the user, as a plugin that failed to load does; then
     # only the log. One line per label — file, bundle and event — so a

data/lib/samagotchi/hooks.rb

@@ -2,12 +2,11 @@
 
 require_relative "hooks/registry"
 require_relative "hooks/loader"
-require_relative "hooks/bundle_loader"
 require_relative "hooks/stream_watch"
 
 module Samagotchi
-  # Thin wrapper that exposes the Hooks::Registry, Hooks::Loader and
-  # Hooks::BundleLoader (bundle-owned hook plugins).
+  # Thin wrapper that exposes the Hooks::Registry and Hooks::Loader
+  # (config.yml's hooks; a bundle's hook through its plugin, Plugin::Api#on).
   #
   # The Engine holds an instance of Hooks::Registry and provides:
   # - #register_hook(name, &block) — register a turn-scoped hook