samagotchi 0.75.0 → 0.76.0

data/lib/samagotchi/bundle_command.rb

@@ -146,8 +146,12 @@ module Samagotchi
         return install_profile(expanded_source, scope: scope, force: force, dry_run: false, word: "Install")
       end
 
-      bundle_name = bundle_name_or_fail(expanded_source, "Install") or return 1
-      run_installer(installer_for(expanded_source, bundle_name, scope: scope, force: force), failed: "Install") do |manifest|
+      prepared, bundle_name = prepare_or_fail(expanded_source, "Install")
+      return 1 unless prepared
+      return 1 if installed_under_another_name?(expanded_source, bundle_name, prepared, "Install")
+
+      installer = installer_for(expanded_source, bundle_name, prepared: prepared, scope: scope, force: force)
+      run_installer(installer, failed: "Install") do |manifest|
         print_hooks_and_plugin(manifest)
         print_provenance(bundle_name, manifest)
       end
@@ -164,7 +168,7 @@ module Samagotchi
       dry_run = opts.fetch(:dry_run, false)
       agent = opts[:agent]
       if source.nil? || source.empty?
-        @stderr.puts "Usage: chi bundle upgrade <source> [--scope system|project] [--force] [--dry-run]"
+        @stderr.puts UPGRADE_HELP
         return CLI::Exit::USAGE
       end
       expanded_source = expand_source(source)
@@ -172,18 +176,21 @@ module Samagotchi
         return install_profile(expanded_source, scope: scope, force: force, dry_run: dry_run, word: "Upgrade")
       end
 
-      bundle_name = bundle_name_or_fail(expanded_source, "Upgrade") or return 1
+      prepared, bundle_name = prepare_or_fail(expanded_source, "Upgrade")
+      return 1 unless prepared
+      return 1 if installed_under_another_name?(expanded_source, bundle_name, prepared, "Upgrade")
+
       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)
-        installer = installer_for(expanded_source, bundle_name, scope: scope, force: force, dry_run: dry_run)
+        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
 
           print_provenance(bundle_name, manifest)
         end
       end
-      installer = installer_for(expanded_source, bundle_name, scope: scope, force: force, upgrade: true, dry_run: dry_run)
+      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)
         next dry_run_done if dry_run
@@ -193,12 +200,44 @@ module Samagotchi
       end
     end
 
-    # The bundle's name, or nil after "<word> failed: …".
-    def bundle_name_or_fail(expanded_source, word)
-      bundle_name_for(expanded_source)
-    rescue Samagotchi::MemoryBundle::SourceNormalizer::UnknownSourceError => e
+    # The source normalized once (a git clone, a zip or tar extract) and the
+    # bundle's name, its manifest's name: for every kind of source, a git URL
+    # too. The Installer installs from that extract and removes it. Nil
+    # after "<word> failed: …" (an unknown source, or a missing or invalid
+    # manifest: an install needs one anyway), the extract removed.
+    # @return [Array(MemoryBundle::PreparedSource, String), nil]
+    def prepare_or_fail(expanded_source, word)
+      prepared = Samagotchi::MemoryBundle::PreparedSource.prepare(expanded_source)
+      named = [prepared, Samagotchi::MemoryBundle::Manifest.read(dir: prepared.dir).name]
+    rescue Samagotchi::MemoryBundle::SourceNormalizer::UnknownSourceError,
+           Samagotchi::MemoryBundle::Manifest::ValidationError => e
       @stderr.puts "#{word} failed: #{e.message}"
-      nil
+    ensure
+      # Any failure (an unexpected error too) removes the extract.
+      prepared&.cleanup unless named
+    end
+
+    # A bundle installed from this source under another name: a git URL
+    # bundle recorded before chi named it by its manifest (it took the
+    # repo's name, chi-foo for name: foo). Installing it again would load
+    # both copies' plugin and hooks, so "<word> failed: … installed as
+    # chi-foo" instead (the extract removed). Only when no bundle has the
+    # manifest's name; sources compare by SourceIdentity.
+    # @return [Boolean] refused
+    def installed_under_another_name?(expanded_source, bundle_name, prepared, word)
+      return false if Samagotchi::MemoryBundle::Provenance.new(name: bundle_name).installed?
+
+      identity = Samagotchi::MemoryBundle::SourceIdentity.of(expanded_source)
+      return false unless identity
+
+      other, = Samagotchi::MemoryBundle::Provenance.each_installed.find do |name, bundle|
+        name != bundle_name && !bundle.error? && Samagotchi::MemoryBundle::SourceIdentity.of(bundle.source) == identity
+      end
+      return false unless other
+
+      prepared.cleanup
+      @stderr.puts "#{word} failed: #{expanded_source} is installed as #{other}: `chi bundle uninstall #{other}`, then install it again"
+      true
     end
 
     def installer_for(source, name, scope:, force:, **)
@@ -728,40 +767,14 @@ module Samagotchi
       parsed
     end
 
-    # helpers for bundle_name derivation
+    # The source as given: a git URL as is, a shipped bundle's name as its
+    # dir, anything else as an expanded path.
     def expand_source(src)
       return src if Samagotchi::MemoryBundle::SourceNormalizer.git_url?(src)
 
       Samagotchi::MemoryBundle::SourceNormalizer.shipped_bundle_dir(src) || File.expand_path(src)
     end
 
-    def bundle_name_for(expanded_src)
-      # Try to derive from manifest if possible (skip git clone for speed if possible)
-      if Samagotchi::MemoryBundle::SourceNormalizer.git_url?(expanded_src)
-        # For git URLs, avoid double clone: derive name from URL basename if no manifest yet
-        # Let Installer do the real manifest read; fallback to URL basename
-        base = expanded_src.split("/").last.to_s.split("#").first.to_s
-        base = base.sub(/\.git\z/i, "")
-        return base.empty? ? "bundle" : base
-      end
-      require "yaml"
-      nd = nil
-      owned = false
-      begin
-        nd, owned = Samagotchi::MemoryBundle::SourceNormalizer.normalize(expanded_src)
-        m = Samagotchi::MemoryBundle::Manifest.read(dir: nd)
-        m.name
-      rescue Samagotchi::MemoryBundle::Manifest::ValidationError
-        # Fallback to source basename without archive extensions
-        src = expanded_src
-        name = File.basename(src)
-        name = name.sub(/\.tar\.gz\z/i, "").sub(/\.tgz\z/i, "").sub(/\.zip\z/i, "").sub(/\.tar\z/i, "")
-        name.empty? ? File.basename(nd || src) : name
-      ensure
-        Samagotchi::MemoryBundle::SourceNormalizer.cleanup(nd) if owned
-      end
-    end
-
     def build_conflict_prompt(bundle_name, conflicts, expanded_source)
       lines = []
       lines << "Memory bundle upgrade has conflicts that need interactive resolution."

data/lib/samagotchi/bundles/codex-peer/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: codex-peer
-version: 0.3.1
+version: 0.3.2
 scope: system
 description: "Pair this session with an OpenAI Codex CLI session you work with: the codex_send tool and /codex send it a part of the work (a plan step, a diff, a finding) to validate or as context, with codex queue, and Codex's answer comes back as the codex-outbox context; /codex install-skill installs Codex's chi-peer skill, which pairs"
 trust_level: reviewed
@@ -10,7 +10,7 @@ files:
     description: "Send a part of the work to the paired Codex CLI session (codex_send): only when the user asks, or to reply to its answer in a peer turn; validate, context or question; Codex's answer comes as the codex-outbox context"
 plugin:
   file: plugin.rb
-  sha256: sha256:eb6888e3611b8ed42498cfecab5b430e0ef7a4c2dc7b3c090d015336aa039b11
+  sha256: sha256:b03465566272891237ac1906980ff6956579a4703d3a42c414ce50a81de551f6
 scripts:
   pair: sha256:251448a31959b5c916400eff7909e85c696855d5c16b6b10973ada40915c8051
   chi-peer-SKILL.md: sha256:7c392ac04c115ea1e762ad562b5c4c44c3eca71558ba5d9dfeaeabdd533b6a82

data/lib/samagotchi/bundles/codex-peer/plugin.rb

@@ -168,10 +168,16 @@ class Plugin < Samagotchi::Plugin::Peer
   # [stdout, stderr, status]; both pipes read on threads, so a full one
   # can't block the command.
   def run(*command)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + QUEUE_SECONDS
     Open3.popen3(*command, pgroup: true) do |stdin, stdout, stderr, wait|
       stdin.close
       out, err = [stdout, stderr].map { |io| Thread.new { io.read }.tap { |t| t.report_on_exception = false } }
-      unless wait.join(QUEUE_SECONDS)
+      threads = [wait, out, err]
+      within_deadline = lambda do |thread|
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        thread.join([remaining, 0].max)
+      end
+      unless threads.all?(&within_deadline)
         begin
           Process.kill("KILL", -wait.pid)
         rescue SystemCallError
@@ -179,7 +185,18 @@ class Plugin < Samagotchi::Plugin::Peer
         end
         # The group is gone, so the pipes end: let the readers finish
         # before popen3 closes them.
-        [wait, out, err].each { |t| t.join(1) }
+        cleanup_deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 1
+        threads.each do |thread|
+          remaining = cleanup_deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          thread.join([remaining, 0].max)
+        end
+        # The queue itself finished fine, and only a process it left held
+        # the pipes: the message is likely queued, so don't say "try again"
+        # (a retry would deliver it twice).
+        if wait.join(0) && wait.value.success?
+          raise SendError, "codex queue exited but left a process holding its output (stopped after " \
+                           "#{QUEUE_SECONDS} s): the message may already be queued, check Codex before sending again"
+        end
         raise SendError, "Codex didn't take the message in #{QUEUE_SECONDS} s (codex queue was stopped): try " \
                          "again, or pair again from Codex"
       end

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

@@ -1,10 +1,10 @@
 ---
 name: core
-version: 0.3.0
+version: 0.3.1
 scope: system
 description: "Recommended safety set"
 trust_level: reviewed
-requires_chi: ">= 0.8.0"
+requires_chi: ">= 0.60.0"
 includes:
 - loop-guard
 - check-in

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

@@ -1,10 +1,10 @@
 ---
 name: dev
-version: 0.5.0
+version: 0.5.1
 scope: system
 description: "Developer tools"
 trust_level: reviewed
-requires_chi: ">= 0.34.0"
+requires_chi: ">= 0.72.0"
 includes:
 - known-names
 - mcp

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

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.75.0
+version: 0.76.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/desktop/macos.rb

@@ -152,8 +152,7 @@ module Samagotchi
       def launch_config
         env = { "LANG" => LANG }
         ENV_ALLOWLIST.each { |name| env[name] = @env[name] unless @env[name].to_s.empty? }
-        env["XDG_CONFIG_HOME"] = Paths.config_home(env: @env) if env.key?("XDG_CONFIG_HOME")
-        env["XDG_STATE_HOME"] = Paths.state_home(env: @env) if env.key?("XDG_STATE_HOME")
+        env.merge!(Paths.absolute_xdg(env: env, set: :key))
         config = { "version" => @version, "argv" => [@ruby, @chi_path], "env" => env, "sources_sha" => sources_sha }
         TERMINALS.each { |name| config[name] = @terminals[name] if @terminals[name] }
         config["broadcast_timeout"] = @broadcast_timeout if @broadcast_timeout

data/lib/samagotchi/effective_model.rb

@@ -168,6 +168,11 @@ module Samagotchi
       unresolved(:window_unresolved, e, nil)
     end
 
+    # The window config.yml gives this model or its host
+    # (ContextWindow.setting), never asking a server: a session loaded on
+    # it (Engine#session=, before a worker's Bridge serves). nil when none.
+    def configured_context_window = ContextWindow.setting(target, names: names)
+
     # The window as its loop would see it (ChatLoop#context_window: a remote
     # chat host has no /props, only its model list); nil when it can't be
     # resolved.

data/lib/samagotchi/engine.rb

@@ -1005,6 +1005,9 @@ module Samagotchi
       sync_kernel_client!
       @client.invalidate_context_window!
       @metrics.forget_model_reports!
+      # The last turn's ctx % was the old model's window's
+      # (#announce_switched_context! sends the new one's).
+      @last_context_status = nil
       ref = effective_model_ref
       if persist_default
         ConfigFile.write_default_model!(ref)
@@ -1013,6 +1016,42 @@ module Samagotchi
       ref
     end
 
+    # After /model: how full the context is on the new model's window,
+    # before its first turn: the last turn's count (the old model's
+    # tokenizer's, replaced at the next generation) against the new model's
+    # window (EffectiveModel#context_window, ContextWindow.resolve: the
+    # running server first, one /props GET that a remote chat host is
+    # spared; else the host's cached model list; else the configured
+    # window) and the
+    # session's budget. Sent as a :context_status event (the web's ctx
+    # meter, the attached TUI's status row) with context_window_tokens, and
+    # kept for a client that joins later (#session_state_snapshot; the
+    # window in the metrics' context too, which a page counts from). A window
+    # that can't be resolved sends usage nil: the UIs clear the % until the
+    # next generation. Nothing before the session's first counted turn.
+    # +configured_only+: the configured window only, never asking a server
+    # (EffectiveModel#configured_context_window): a loaded session's (#session=).
+    # @return [Hash, nil] the event sent
+    def announce_switched_context!(configured_only: false)
+      used = @metrics.snapshot.dig(:context, :used_tokens)
+      return nil unless used.is_a?(Integer)
+
+      model = effective_model
+      window = configured_only ? model.configured_context_window : current_context_window(model)
+      display = window && saved_context_status({ used_tokens: used, window_tokens: window.tokens })
+      @last_context_status = display&.dup
+      @metrics.note_context_window(window.tokens, window.source) if window
+      usage = display && { estimated_pct: display[:est_pct], estimated_used_tokens: used, window_tokens: window.tokens,
+                           window_source: window.source.to_s, source: "switch" }
+      event = { type: :context_status, usage: usage, bucket: display&.dig(:bucket),
+                context_window_tokens: window&.tokens, context_window_source: window&.source&.to_s }
+      @session_observer.notify(event)
+      event
+    rescue StandardError => e
+      Log.warn(:model, "switched_context_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      nil
+    end
+
     # ── Hooks API ──────────────────────────────────────────────────────────────
 
     # Register a hook callback for a named lifecycle event.
@@ -1640,8 +1679,30 @@ module Samagotchi
       # A woken worker's /stats and status line count the turns before it.
       bind_metrics(session)
       @used_memories.absorb(session)
+      # Loaded on another model than its last turn ran on (a --resume'd
+      # REPL's --model, a worker woken after a /model with no turn since):
+      # the saved ctx % was that model's window's. Drop it and count it as
+      # /model does, on a configured window only: this runs before a
+      # worker's Bridge serves, so no /props GET or model list here (a slow
+      # or hung host would hold up the worker's start). No configured
+      # window: no % (ctx ?) until the first generation reports one.
+      return unless model_switched_since_last_turn?
+
+      @metrics.forget_model_reports!
+      announce_switched_context!(configured_only: true)
     end
 
+    # Whether the last turn that named its model ran on another one than
+    # the effective model; false before any (or when the ref can't be told).
+    def model_switched_since_last_turn?
+      last = @metrics.last_model_ref
+      !last.nil? && last != effective_model_ref
+    rescue StandardError => e
+      Log.warn(:model, "switch_check_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      false
+    end
+    private :model_switched_since_last_turn?
+
     # @return [IdleRecap, nil] the idle recap detector, or nil when disabled
     attr_reader :recap
 
@@ -2047,7 +2108,8 @@ module Samagotchi
       result = backend(model).complete(
         messages: turn.messages,
         max_iterations: turn.limit,
-        on_stream_event: build_stream_event_handler(turn.on_event, cancel_controller: turn.controller),
+        on_stream_event: build_stream_event_handler(turn.on_event, cancel_controller: turn.controller,
+                                                    model_ref: generation_model_ref(model)),
         cancel_controller: turn.controller,
         model_name: bare_for_backend,
         max_tool_output_chars: max_tool_output_chars,
@@ -2059,6 +2121,18 @@ module Samagotchi
     end
     private :generate
 
+    # The ref (host:model, as asked) a turn's generations ran on: the model
+    # #generate resolved, after the before_turn hooks (which may switch it).
+    # SessionMetrics keys its per-model segments on it. nil when it can't be
+    # named (the turn's record then has none).
+    def generation_model_ref(model)
+      model.ref
+    rescue StandardError => e
+      Log.warn(:turn, "model_ref_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      nil
+    end
+    private :generation_model_ref
+
     # A step-limit Continue's resume_from, when it is inside the messages the
     # run gets (a wrong one only drops reasoning: it is ignored, logged).
     # Entries before it never move between the turns (#turn_messages adds
@@ -2594,13 +2668,17 @@ module Samagotchi
     #
     # With a :generation_progress hook registered, a Hooks::StreamWatch gets
     # each chunk's thinking and text after the UIs had it.
-    def build_stream_event_handler(on_event, cancel_controller: nil)
+    #
+    # +model_ref+: the turn's model (#generation_model_ref), added to each
+    # :generation_started as `model_ref:` (both loops send through here).
+    def build_stream_event_handler(on_event, cancel_controller: nil, model_ref: nil)
       watch = stream_watch(cancel_controller)
       proc do |event|
         progress = SteerCut.lanes(event) if event[:type] == :generation_chunk
         @steer_cut.observe(event, progress)
         case event[:type]
         when :generation_started
+          event = event.merge(model_ref: model_ref) if model_ref
           @thinking_notices.generation_started
           watch&.started(event[:iteration])
         when :generation_retrying
@@ -2626,13 +2704,15 @@ module Samagotchi
 
     # A :generation_completed with the generation's decode speed (`speed:`
     # {decode_tps:, source:}, nil without one), the session's running
-    # token totals (`tokens:`, the snapshot's block) and whether its served
+    # token totals (`tokens:`, the snapshot's block) and its per-model rows
+    # (`model_segments:`, the snapshot's) and whether its served
     # model is an expected one (`served_expected_by:`, its host): the web's info bar
     # reads them from the stream. SessionMetrics closes the generation here,
     # so the event it gets next finds it closed.
     def with_generation_report(event)
       report = @metrics.finish_generation
-      event.merge(speed: report.speed&.to_h, tokens: report.tokens, served_expected_by: served_expected_by(event[:served_model]))
+      event.merge(speed: report.speed&.to_h, tokens: report.tokens, model_segments: report.model_segments,
+                  served_expected_by: served_expected_by(event[:served_model]))
     rescue StandardError => e
       Log.warn(:turn, "generation_report_failed", error: e.class.name, msg: e.message.to_s[0, 200])
       event

data/lib/samagotchi/kernel_loop.rb

@@ -943,19 +943,22 @@ module Samagotchi
     private :emit_llm_context
 
     # A request's re-prefilled tokens, for both loops: of the prompt the
-    # last request on +model+ sent (this kernel's, any turn), what the
-    # server didn't reuse from its cache this time (that prompt less
-    # +cached+), so an LLM context edit's cache break shows, and so does
-    # anything else that rewrote the prompt's middle or lost the cache. nil
-    # under TokenUsage::REPREFILL_MIN_TOKENS (a cache block's rounding), for
-    # a server that reports no cached count (or 0: a cold cache isn't told
-    # from no cache), the first request, a model switch, and the first
-    # request after a warm-up (#warmed_up!).
+    # last request on +model+ through this client (the host) sent (this
+    # kernel's, any turn), what the server didn't reuse from its cache this
+    # time (that prompt less +cached+), so an LLM context edit's cache break
+    # shows, and so does anything else that rewrote the prompt's middle or
+    # lost the cache. nil under TokenUsage::REPREFILL_MIN_TOKENS (a cache
+    # block's rounding), for a server that reports no cached count (or 0: a
+    # cold cache isn't told from no cache), the first request, a model
+    # switch (another bare model, or the same one on another host: the
+    # Engine points #client at the new host's; SessionMetrics counts that
+    # prefill as the switch's), and the first request after a warm-up
+    # (#warmed_up!).
     # @return [Integer, nil]
     def reprefilled_tokens(model, prompt:, cached:)
       previous = @reprefill_baseline
-      @reprefill_baseline = { model: model, prompt: prompt.to_i } if prompt.to_i.positive?
-      return nil unless previous && previous[:model] == model && cached.to_i.positive?
+      @reprefill_baseline = { model: model, client: @client, prompt: prompt.to_i } if prompt.to_i.positive?
+      return nil unless previous && previous[:model] == model && previous[:client].equal?(@client) && cached.to_i.positive?
 
       tokens = previous[:prompt] - cached.to_i
       tokens >= TokenUsage::REPREFILL_MIN_TOKENS ? tokens : nil

data/lib/samagotchi/llm_context_override.rb

@@ -125,7 +125,14 @@ module Samagotchi
         raise ArgumentError, "unknown llm_context field #{field}" unless FIELDS.include?(field)
 
         text = word.to_s.strip
-        [field, text.casecmp?(DEFAULT_WORD) ? nil : send(:"parse_#{field}", text)]
+        value = if text.casecmp?(DEFAULT_WORD)
+                  nil
+                elsif field == :budget_tokens
+                  LLMContextStrategy.budget_tokens(text)
+                else
+                  send(:"parse_#{field}", text)
+                end
+        [field, value]
       end
       (current || new).with(**fields)
     end
@@ -152,11 +159,6 @@ module Samagotchi
       rule || raise(ArgumentError, "unknown llm_context apply #{text} (#{LLMContextStrategy::APPLIES.join(", ")})")
     end
 
-    # "64000", "64k" or "off" (0): LLMContextStrategy.budget_tokens.
-    # .update reaches it (and the other parse_<field>s) by its name.
-    # @return [Integer] 0 for off
-    def self.parse_budget_tokens(text) = LLMContextStrategy.budget_tokens(text)
-
     private_class_method :file_value, :file_strategy, :file_budget
   end
 end

data/lib/samagotchi/memory_bundle/asset_installer.rb

@@ -55,6 +55,7 @@ module Samagotchi
         prune_dropped_hooks if @upgrade && @existing && !@dry_run
         verify_hook_checksums if @manifest && @strict
         incoming_rules = Dir.glob(File.join(@bundle_dir, "guardrails", "*.yml")).sort
+                            .reject { |src| linked_out?(src, "guardrails/#{File.basename(src)}") }
         guardrail_files = install_guardrails(incoming_rules)
         plugin_file = install_plugin
         script_files = install_scripts
@@ -81,11 +82,14 @@ module Samagotchi
         if hook_entries.empty?
           Dir.glob(File.join(@bundle_dir, "hooks", "*.rb")).each { |p| hook_entries[File.basename(p)] = BundleHook.new }
         end
-        hook_entries.each_key do |basename|
+        hook_entries.keys.each do |basename|
           next unless basename.is_a?(String) && !basename.empty?
 
-          @bundle_hooks << basename
           src = File.join(@bundle_dir, "hooks", basename)
+          # A linked hook isn't the bundle's: not installed, counted or recorded.
+          next hook_entries.delete(basename) if (File.symlink?(src) || File.exist?(src)) && linked_out?(src, "hooks/#{basename}")
+
+          @bundle_hooks << basename
           install_hook(basename, src) if File.exist?(src)
         end
       end
@@ -120,6 +124,8 @@ module Samagotchi
       def install_unlisted_hooks
         Dir.glob(File.join(@bundle_dir, "hooks", "*.rb")).each do |src|
           basename = File.basename(src)
+          next if linked_out?(src, "hooks/#{basename}")
+
           @bundle_hooks << basename
           if @dry_run
             @results[basename] = { status: "would_install" }
@@ -207,6 +213,7 @@ module Samagotchi
 
         src = File.join(@bundle_dir, plugin[:file])
         raise Installer::InstallError, "the manifest names plugin #{plugin[:file]}, which the bundle doesn't have" unless File.file?(src)
+        raise Installer::InstallError, "plugin #{plugin[:file]} is a symlink (not installed)" if linked?(src)
 
         if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, Samagotchi::VERSION))
           @warnings << "Plugin #{plugin[:file]} won't load: #{failure}"
@@ -243,9 +250,9 @@ module Samagotchi
       def install_scripts
         scripts = @manifest&.scripts || {}
         scripts.each_key do |file|
-          next if File.file?(File.join(@bundle_dir, "scripts", file))
-
-          raise Installer::InstallError, "the manifest names scripts/#{file}, which the bundle doesn't have"
+          src = File.join(@bundle_dir, "scripts", file)
+          raise Installer::InstallError, "the manifest names scripts/#{file}, which the bundle doesn't have" unless File.file?(src)
+          raise Installer::InstallError, "scripts/#{file} is a symlink (not installed)" if linked?(src)
         end
         return {} if @dry_run
 
@@ -274,6 +281,28 @@ module Samagotchi
         end
       end
 
+      # Whether the bundle file +src+ reads through a symlink: it is one, or
+      # it (or its dir, hooks/ say) resolves outside the bundle dir. A tar,
+      # zip or git repo keeps links; copying through one would install any
+      # file the user can read. MemoryFiles skips linked memories the same
+      # way.
+      def linked?(src)
+        return true if File.symlink?(src)
+
+        root = File.realpath(@bundle_dir)
+        !File.realpath(src).start_with?("#{root}/")
+      rescue SystemCallError
+        true
+      end
+
+      # linked? with a "<label> is a symlink (not installed)" warning.
+      def linked_out?(src, label)
+        return false unless linked?(src)
+
+        @warnings << "#{label} is a symlink (not installed)"
+        true
+      end
+
       # The hook loader skips every hook of a bundle whose requires_chi this
       # chi doesn't meet (Hooks::BundleLoader); say so at install, as
       # install_plugin does for the plugin.

data/lib/samagotchi/memory_bundle/builder.rb

@@ -398,11 +398,10 @@ module Samagotchi
           raise BuildError, "Output file already exists: #{out_path} — remove it or choose different --out"
         end
 
-        # Use zip CLI like source.rb does with unzip
-        Dir.chdir(staging) do
-          result = system("zip", "-r", out_path, ".")
-          raise BuildError, "zip failed for #{out_path} (is zip installed?)" unless result && File.exist?(out_path)
-        end
+        # Use zip CLI like source.rb does with unzip. It runs in the staging
+        # dir (chdir:): Dir.chdir would move the whole process.
+        result = system("zip", "-r", out_path, ".", chdir: staging)
+        raise BuildError, "zip failed for #{out_path} (is zip installed?)" unless result && File.exist?(out_path)
       end
 
       def tar_staging(staging, out_path, format)
@@ -411,15 +410,13 @@ module Samagotchi
           raise BuildError, "Output file already exists: #{out_path} — remove it or choose different --out"
         end
 
-        # Use tar CLI
-        Dir.chdir(staging) do
-          cmd = case format
-                when :tar_gz, :tgz then ["tar", "-czf", out_path, "."]
-                when :tar then ["tar", "-cf", out_path, "."]
-                end
-          result = system(*cmd)
-          raise BuildError, "tar failed for #{out_path}" unless result && File.exist?(out_path)
-        end
+        # Use tar CLI, in the staging dir (chdir:, as zip_staging).
+        cmd = case format
+              when :tar_gz, :tgz then ["tar", "-czf", out_path, "."]
+              when :tar then ["tar", "-cf", out_path, "."]
+              end
+        result = system(*cmd, chdir: staging)
+        raise BuildError, "tar failed for #{out_path}" unless result && File.exist?(out_path)
       end
     end
   end