samagotchi 0.88.0 → 0.89.0

data/lib/samagotchi/bundle_command.rb

@@ -10,7 +10,7 @@ module Samagotchi
   # subcommands have their own flags).
   class BundleCommand
     USAGE = <<~TEXT
-      Usage: chi bundle <install|upgrade|uninstall|status|diff|list|build|trash|new|test|check> [options]
+      Usage: chi bundle <install|upgrade|uninstall|status|diff|list|build|trash|new|test|check|try> [options]
 
         install <source> [--scope system|project] [--force]
           Install a memory bundle from a directory, zip, tar archive, or git URL.
@@ -52,17 +52,26 @@ module Samagotchi
         check [PATH] [--fix] [--set KEY=VALUE]
           Check a bundle you're writing (default: the current dir): manifest, files, sha256 lines,
           requires_chi, and an install + load in a sandbox. --fix rewrites stale sha256 lines.
+
+        try PATH -p TEXT [options]
+          Run one non-interactive model turn with a bundle installed in an isolated sandbox.
     TEXT
 
     # Each subcommand's --help (and only --help: -h and help are taken as
     # the source or name).
     INSTALL_HELP = <<~TEXT
       Usage: chi bundle install <source> [--scope system|project] [--force]
+             chi bundle install --dev PATH
 
         install <source> [--scope system|project] [--force]
           Install a memory bundle from a directory, zip, tar archive, or git URL,
           or a bundle shipped with chi by name (see: chi bundle list).
           --force overwrites existing entries; default skips them.
+        install --dev PATH
+          Install the bundle in the local directory PATH as a link to it: its plugin, hooks, 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.
     TEXT
     UPGRADE_HELP = "Usage: chi bundle upgrade <source> [--scope system|project] [--force] [--dry-run] [--agent|--no-agent]"
     UNINSTALL_HELP = "Usage: chi bundle uninstall <bundle> [--scope system|project] [--force]"
@@ -108,6 +117,19 @@ module Samagotchi
         --set KEY=VALUE  a setting for the load (config.yml bundles: <name>: KEY), repeatable
         Exit status: 0 no errors, 1 errors, 2 usage.
     TEXT
+    TRY_HELP = <<~TEXT
+      Usage: chi bundle try PATH -p TEXT [--model NAME] [--memory NAME] [--mute NAME] [--toolkit NAME]
+             [--thinking LEVEL] [--set KEY=VALUE] [--json] [--keep] [--timeout SECONDS]
+
+        Install PATH and run one non-interactive turn in an isolated temporary config, state and work directory.
+        The user's hosts, keys and ordinary runtime settings are retained; their bundles, hooks, guardrails,
+        memories, prompt additions, sessions and attached context sources are not. Shipped guardrails and a
+        $1 cost cap are installed for the run. --set KEY=VALUE sets the tried bundle's config.yml bundles entry;
+        --set cost-cap.cap=N overrides the cap (unlike chi --set BUNDLE.KEY=VALUE, these are config settings).
+        --memory and --mute accept comma-separated names and repeat. --keep retains the sandbox and debug log.
+        --json prints the experimental machine-readable trace.
+        Exit status: child turn's status; 1 on install failure or timeout; 2 for usage; 130 on Ctrl-C.
+    TEXT
 
     # The subcommands' flags: --help only; a word not starting with -- is
     # a positional (install's source, -h included). --scope takes whatever
@@ -115,8 +137,12 @@ module Samagotchi
     INSTALL_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
       f.value "--scope"
       f.switch "--force"
+      f.switch "--dev"
+    end
+    UNINSTALL_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
+      f.value "--scope"
+      f.switch "--force"
     end
-    UNINSTALL_FLAGS = INSTALL_FLAGS
     UPGRADE_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
       f.value "--scope"
       f.switch "--force"
@@ -135,6 +161,19 @@ module Samagotchi
       f.switch "--fix"
       f.value "--set", key: :set, repeat: true
     end
+    TRY_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A-/) do |f|
+      f.value "-p", "--prompt", key: :prompt
+      f.value "--model"
+      f.value "--memory", repeat: true
+      f.value "--mute", repeat: true
+      f.value "--toolkit"
+      f.value "--thinking"
+      f.value "--set", repeat: true
+      f.switch "--json"
+      f.switch "--keep"
+      f.value "--timeout"
+      f.refuse "--attach", "--shared", "chi bundle try can't use --attach or --shared"
+    end
     TRASH_FLAGS = CLI::Flags.new(help: %w[--help], flag_pattern: /\A--/) do |f|
       f.switch "--empty"
       f.switch "--dry-run"
@@ -169,8 +208,9 @@ module Samagotchi
       when "new" then new_bundle(@argv[1..])
       when "test" then test_bundle(@argv[1..])
       when "check" then check(@argv[1..])
+      when "try" then try_bundle(@argv[1..])
       else
-        @stderr.puts "Unknown bundle subcommand: #{sub}. Use: install, upgrade, uninstall, status, diff, list, build, trash, new, test, check"
+        @stderr.puts "Unknown bundle subcommand: #{sub}. Use: install, upgrade, uninstall, status, diff, list, build, trash, new, test, check, try"
         CLI::Exit::USAGE
       end
     end
@@ -185,11 +225,21 @@ module Samagotchi
       source = parsed.args.last
       scope = opts[:scope]
       force = opts.fetch(:force, false)
+      dev = opts.fetch(:dev, false)
       if source.nil? || source.empty?
         @stderr.puts "Usage: chi bundle install <source> [--scope system|project] [--force]"
         return CLI::Exit::USAGE
       end
-      expanded_source = expand_source(source)
+      if dev && (Samagotchi::MemoryBundle::SourceNormalizer.git_url?(source) || !File.directory?(source))
+        @stderr.puts "chi bundle install --dev takes a local directory (the bundle's source), not #{source}"
+        return CLI::Exit::USAGE
+      end
+      expanded_source = dev ? File.realpath(source) : expand_source(source)
+      if dev && File.dirname(expanded_source) == File.realpath(Samagotchi::MemoryBundle::SourceNormalizer::SHIPPED_DIR)
+        @stderr.puts "chi bundle install --dev cannot be used with chi-shipped bundles or profiles; " \
+                     "use chi bundle install #{File.basename(expanded_source)} instead"
+        return CLI::Exit::USAGE
+      end
       if Samagotchi::MemoryBundle::Profile.shipped_meta?(expanded_source)
         return install_profile(expanded_source, scope: scope, force: force, dry_run: false, word: "Install")
       end
@@ -198,7 +248,7 @@ module Samagotchi
       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)
+      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_provenance(bundle_name, manifest)
@@ -457,7 +507,7 @@ module Samagotchi
           @stdout.puts "Bundle '#{name}' not installed."
           return 0
         end
-        @stdout.puts "Bundle: #{name} v#{st[:provenance].version} scope=#{status_scope(st)} installed=#{st[:provenance].installed_at}"
+        @stdout.puts "Bundle: #{name} v#{st[:provenance].version}#{dev_label(st[:provenance])} scope=#{status_scope(st)} installed=#{st[:provenance].installed_at}"
         if st[:scope_error]
           @stdout.puts "Target: (unknown scope: this chi can't resolve it; upgrade chi or reinstall the bundle)"
         else
@@ -519,12 +569,19 @@ module Samagotchi
           plugin_info = plugin ? " plugin=#{plugin[:file]}" : ""
           includes = st[:provenance].includes
           includes_info = includes ? " includes=#{includes.join(",")}" : ""
-          @stdout.puts "  #{bname} v#{st[:provenance].version} scope=#{status_scope(st)} files=#{st[:files].size}#{hook_info}#{plugin_info}#{includes_info} issues=#{mods}"
+          @stdout.puts "  #{bname} v#{st[:provenance].version}#{dev_label(st[:provenance])} scope=#{status_scope(st)} files=#{st[:files].size}#{hook_info}#{plugin_info}#{includes_info} issues=#{mods}"
         end
       end
       0
     end
 
+    # " dev → /path (missing)" when a dev install's source isn't there, else "".
+    def dev_label(record)
+      return "" unless record.dev
+
+      " dev → #{record.source}#{" (missing)" unless File.directory?(record.source)}"
+    end
+
     # "team (unknown)" for a scope this chi can't resolve (Status#bundle_status).
     def status_scope(st) = st[:scope_error] ? "#{st[:scope]} (unknown)" : st[:scope]
 
@@ -844,7 +901,7 @@ module Samagotchi
       parsed = parse_flags(CHECK_FLAGS, rest, "check", help: CHECK_HELP)
       return parsed if parsed.is_a?(Integer)
 
-      settings = check_settings(parsed.options.fetch(:set, [])) or return CLI::Exit::USAGE
+      settings = check_settings(parsed.options.fetch(:set, []), label: "check") or return CLI::Exit::USAGE
       if parsed.args.size > 1
         @stderr.puts "chi bundle check takes one PATH (#{parsed.args.join(" ")})"
         return CLI::Exit::USAGE
@@ -858,14 +915,163 @@ module Samagotchi
       Check.new(dir, fix: parsed.options.fetch(:fix, false), settings: settings, stdout: @stdout).run
     end
 
+    def try_bundle(rest)
+      parsed = parse_flags(TRY_FLAGS, rest, "try", help: TRY_HELP)
+      return parsed if parsed.is_a?(Integer)
+
+      options = parsed.options
+      if options[:prompt].nil? || parsed.args.size != 1
+        @stderr.puts "Usage: chi bundle try PATH -p TEXT [options]"
+        return CLI::Exit::USAGE
+      end
+      path = parsed.args.first
+      unless File.directory?(path)
+        @stderr.puts "chi bundle try: #{path} isn't a folder"
+        return CLI::Exit::USAGE
+      end
+      if options.values_at(:model, :toolkit, :thinking, :memory, :mute).flatten.compact.any?(&:empty?)
+        @stderr.puts "chi bundle try: model, toolkit, thinking, memory and mute values cannot be empty"
+        return CLI::Exit::USAGE
+      end
+      require_relative "thinking"
+      if options[:thinking] && !Thinking::LEVELS.map(&:to_s).include?(options[:thinking])
+        @stderr.puts "chi bundle try: --thinking takes #{Thinking::LEVELS.join(", ")}, not #{options[:thinking]}"
+        return CLI::Exit::USAGE
+      end
+
+      timeout = parse_try_timeout(options[:timeout])
+      return CLI::Exit::USAGE unless timeout
+
+      set_pairs = []
+      cost_cap = 1
+      cost_cap_override = false
+      require_relative "bundle_session_settings"
+      Array(options[:set]).each do |pair|
+        key, sep, value = pair.partition("=")
+        if sep.empty?
+          @stderr.puts "chi bundle try: --set takes KEY=VALUE, not #{pair}"
+          return CLI::Exit::USAGE
+        end
+        if key == "cost-cap.cap"
+          cost_cap = BundleSessionSettings.typed(value)
+          cost_cap_override = true
+          unless (cost_cap.is_a?(Numeric) && cost_cap >= 0) || cost_cap == false
+            @stderr.puts "chi bundle try: --set cost-cap.cap takes a non-negative number or off"
+            return CLI::Exit::USAGE
+          end
+        else
+          set_pairs << pair
+        end
+      end
+      settings = check_settings(set_pairs, label: "try")
+      return CLI::Exit::USAGE unless settings
+
+      require_relative "bundle_command/try/sandbox"
+      require_relative "bundle_command/try/run"
+      require_relative "bundle_command/try/trace"
+      sandbox = nil
+      begin
+        sandbox = Try::Sandbox.new(path, bundle_settings: settings, cost_cap: cost_cap,
+                                   cost_cap_override: cost_cap_override)
+        sandbox.install
+        result = Try::Run.new(sandbox).run(prompt: options[:prompt], options: options, timeout: timeout)
+        trace = Try::TraceReader.new(state_home: sandbox.state_home, session_id: result.session_id)
+                              .read(exit_code: result.exit_status, answer: result.stdout, stderr: result.stderr,
+                                    sandbox: options[:keep] ? sandbox.root : nil)
+        render_try_trace(trace, json: options[:json], child_stderr: result.stderr)
+        @stderr.puts "chi bundle try: timed out after #{timeout} seconds" if result.timed_out
+        result.exit_status
+      rescue Try::Sandbox::Error => e
+        @stderr.puts e.message
+        e.status
+      ensure
+        report_try_sandbox(sandbox) if options[:keep] && sandbox
+        sandbox&.cleanup unless options[:keep]
+      end
+    end
+
+    def render_try_trace(trace, json:, child_stderr:)
+      error_lines = child_stderr.lines.reject { |line| line.start_with?("Session: ") }
+      @stderr.write(error_lines.join)
+      if json
+        render_trace_lines(trace, @stderr, include_answer: false)
+        @stdout.puts JSON.generate(trace.to_h.transform_keys(&:to_s))
+      else
+        render_trace_lines(trace, @stdout, include_answer: true)
+      end
+    end
+
+    def report_try_sandbox(sandbox)
+      @stderr.puts "sandbox: #{sandbox.root}"
+      @stderr.puts "debug log: #{File.join(sandbox.state_home, "samagotchi", "samagotchi.log")}"
+    end
+
+    def render_trace_lines(trace, output, include_answer:)
+      output.puts "tools:"
+      trace.tools.each do |tool|
+        output.puts format("  %d %-16s %-7s %dms  %s", tool[:index], tool[:name], tool[:status],
+                           tool[:duration_ms], JSON.generate(tool[:args].to_s[0, 60]))
+      end
+      trace.notices.each { |notice| output.puts "notices: [#{notice["hook"] || "hook"}] #{notice["text"]}" }
+      trace.cards.each do |card|
+        output.puts "card: #{[card["title"], card["body"]].compact.join(" — ")}"
+      end
+      trace.questions.each do |entry|
+        question = entry.dig("pending_question", "question").to_s
+        outcome = if entry["cancelled"] && entry["reason"] == "non_interactive"
+                    "unanswerable (non_interactive)"
+                  elsif entry["cancelled"]
+                    "cancelled (#{entry["reason"]})"
+                  elsif entry["answer"]
+                    "answered"
+                  else
+                    "unanswered"
+                  end
+        output.puts "questions: #{JSON.generate(question)} -> #{outcome}"
+      end
+      if trace.interactive_blocked
+        count = trace.denied.size + trace.questions.count { |question| question["cancelled"] && question["reason"] == "non_interactive" }
+        output.puts "warn: #{count} question(s)/call(s) couldn't be answered"
+      end
+      if include_answer
+        answer_lines = trace.answer.lines
+        output.puts "answer:"
+        answer_lines.first(10).each { |line| output.puts "  #{line.chomp}" }
+        output.puts "  … (truncated)" if answer_lines.size > 10
+      end
+      tokens = trace.tokens
+      prompt = tokens[:prompt] || "unknown"
+      completion = tokens[:completion] || "unknown"
+      cost = if trace.cost
+               "#{"~" if trace.cost_is_estimate}$#{format("%.4f", trace.cost)}"
+             else
+               "unknown"
+             end
+      output.puts "tokens: #{prompt} in / #{completion} out  cost #{cost}  exit #{trace.exit_code}" \
+                  "#{"  (#{trace.session_id})" if trace.session_id}"
+    end
+
+    def parse_try_timeout(value)
+      return 300 unless value
+
+      timeout = Float(value)
+      return timeout if timeout.positive? && timeout.finite?
+
+      @stderr.puts "chi bundle try: --timeout must be a positive number"
+      nil
+    rescue ArgumentError
+      @stderr.puts "chi bundle try: --timeout must be a positive number"
+      nil
+    end
+
     # --set KEY=VALUE values as typed (BundleSessionSettings.typed), or nil
     # after saying what's wrong.
-    def check_settings(pairs)
+    def check_settings(pairs, label:)
       require_relative "bundle_session_settings"
       pairs.each_with_object({}) do |pair, out|
         key, sep, value = pair.partition("=")
         unless !sep.empty? && key.match?(BundleSessionSettings::KEY)
-          @stderr.puts "chi bundle check: --set takes KEY=VALUE, not #{pair}"
+          @stderr.puts "chi bundle #{label}: --set takes KEY=VALUE, not #{pair}"
           return nil
         end
         out[key] = BundleSessionSettings.typed(value)

data/lib/samagotchi/bundle_session_settings.rb

@@ -176,6 +176,8 @@ module Samagotchi
       file = File.join(dir, name, "plugin", bundle.plugin.file.to_s)
       return "the file is missing" unless File.file?(file)
 
+      return nil if MemoryBundle::Provenance.unchecked?(bundle.plugin.sha256)
+
       expected = MemoryBundle::Provenance.recorded_sha(bundle.plugin.sha256)
       return "no sha256 recorded for it (reinstall the bundle)" if expected.empty?
 

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

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

data/lib/samagotchi/context_providers.rb

@@ -134,8 +134,7 @@ module Samagotchi
 
       record.scripts.each do |file, sha|
         path = File.join(provenance.scripts_dir, file)
-        recorded = MemoryBundle::Provenance.recorded_sha(sha)
-        next if File.file?(path) && MemoryBundle::Provenance.file_sha(path) == recorded
+        next if File.file?(path) && MemoryBundle::Provenance.sha_matches?(path, sha)
 
         raise Invalid, "bundle #{source.provider}'s scripts/#{file} differs from the installed one (reinstall the bundle)"
       end

data/lib/samagotchi/hooks/bundle_loader.rb

@@ -126,6 +126,8 @@ module Samagotchi
         # Why the file doesn't match the sha256 recorded at install, or nil.
         # With none recorded, only a required hook counts as a mismatch.
         def sha_mismatch(file, recorded, required:)
+          return nil if MemoryBundle::Provenance.unchecked?(recorded)
+
           expected = MemoryBundle::Provenance.recorded_sha(recorded)
           return (required ? "no sha256 recorded for it (reinstall the bundle)" : nil) if expected.empty?
 

data/lib/samagotchi/installed_gem.rb

@@ -29,6 +29,17 @@ module Samagotchi
       File.file?(path) ? path : nil
     end
 
+    # What Bundler changed in ENV, mapped back to the values from before it
+    # (nil: unset); {} outside Bundler. Child chi commands use this in gem
+    # mode so they load the same installed gem without inheriting this app's
+    # bundle.
+    def unbundled_env_changes(env = ENV.to_h)
+      return {} unless defined?(::Bundler) && ::Bundler.respond_to?(:unbundled_env)
+
+      clean = ::Bundler.unbundled_env
+      (env.keys | clean.keys).each_with_object({}) { |key, changes| changes[key] = clean[key] unless clean[key] == env[key] }
+    end
+
     def real_path(path)
       File.realpath(path)
     rescue SystemCallError

data/lib/samagotchi/memory_bundle/asset_installer.rb

@@ -17,6 +17,8 @@ module Samagotchi
     # scripts/*. Each replaces what an earlier version installed. Installer
     # runs it after the memories; it adds to the installer's results and
     # warnings, and #run returns what the record (Provenance#write) keeps.
+    # A dev install (+dev+, `chi bundle install --dev`) links each file to
+    # the source instead of copying it, and warns of no checksum mismatch.
     class AssetInstaller
       # What was installed: the paths Provenance#write records (each
       # empty / nil on a dry run).
@@ -32,7 +34,7 @@ module Samagotchi
       # @param results, warnings, conflicts the Installer's (results and
       #   warnings are added to)
       def initialize(name:, source_dir:, manifest:, provenance:, existing:, results:, warnings:, conflicts:,
-                     force: false, strict: true, upgrade: false, dry_run: false)
+                     force: false, strict: true, upgrade: false, dry_run: false, dev: false)
         @name = name
         @bundle_dir = source_dir
         @manifest = manifest
@@ -45,6 +47,7 @@ module Samagotchi
         @strict = strict
         @upgrade = upgrade
         @dry_run = dry_run
+        @dev = dev
       end
 
       # @return [Installed]
@@ -52,8 +55,8 @@ module Samagotchi
       #   script the bundle doesn't have
       def run
         install_hooks
-        prune_dropped_hooks if @upgrade && @existing && !@dry_run
-        verify_hook_checksums if @manifest && @strict
+        prune_dropped_hooks if (@upgrade || (@dev && @existing&.dev)) && @existing && !@dry_run
+        verify_hook_checksums if @manifest && @strict && !@dev
         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)
@@ -109,7 +112,7 @@ module Samagotchi
 
         FileUtils.mkdir_p(@provenance.hooks_dir)
         unchanged = File.exist?(dest) && FileUtils.identical?(src, dest)
-        FileUtils.cp(src, dest)
+        place(src, dest)
         @results[basename] = if unchanged
                                { status: "skipped", reason: "already up to date" }
                              elsif @upgrade && @existing
@@ -132,7 +135,7 @@ module Samagotchi
           else
             FileUtils.mkdir_p(@provenance.hooks_dir)
             dest = File.join(@provenance.hooks_dir, basename)
-            FileUtils.cp(src, dest)
+            place(src, dest)
             @results[basename] = { status: "installed" }
             @hook_files[basename] = dest
           end
@@ -140,13 +143,13 @@ module Samagotchi
       end
 
       # An upgrade removes the hooks the previous version shipped and this
-      # one doesn't (a local file too, with a warning).
+      # one doesn't (a local file too, with a warning; a dev link silently).
       def prune_dropped_hooks
         @existing.hooks.each_key do |old_key_str|
           next if @bundle_hooks.include?(old_key_str)
 
           old_dest = File.join(@provenance.hooks_dir, old_key_str)
-          if File.exist?(old_dest) && !@force
+          if File.exist?(old_dest) && !@force && !File.symlink?(old_dest)
             @warnings << "Bundle no longer includes hook #{old_key_str} but local file exists — removing"
           end
           FileUtils.rm_f(old_dest)
@@ -193,7 +196,7 @@ module Samagotchi
         FileUtils.mkdir_p(target)
         incoming_rules.to_h do |src|
           dest = File.join(target, File.basename(src))
-          FileUtils.cp(src, dest)
+          place(src, dest)
           @results["guardrails/#{File.basename(src)}"] =
             unchanged.include?(src) ? { status: "skipped", reason: "already up to date" } : { status: "installed" }
           [File.basename(src), dest]
@@ -227,7 +230,7 @@ module Samagotchi
         unchanged = File.file?(dest) && FileUtils.identical?(src, dest)
         FileUtils.rm_rf(@provenance.plugin_dir)
         FileUtils.mkdir_p(@provenance.plugin_dir)
-        FileUtils.cp(src, dest)
+        place(src, dest)
         @results[plugin[:file]] = if unchanged
                                     { status: "skipped", reason: "already up to date" }
                                   elsif @upgrade && @provenance.installed?
@@ -237,7 +240,7 @@ module Samagotchi
                                   end
         expected = @manifest.checksum_for_plugin
         actual = Digest::SHA256.hexdigest(File.binread(dest))
-        if @strict && expected && actual != expected
+        if @strict && !@dev && expected && actual != expected
           @warnings << "Checksum mismatch for plugin #{plugin[:file]}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
         end
         dest
@@ -253,6 +256,8 @@ module Samagotchi
           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)
+
+          @warnings << "scripts/#{file} is not executable; chmod +x #{src}" if @dev && !File.executable?(src)
         end
         return {} if @dry_run
 
@@ -266,21 +271,28 @@ module Samagotchi
         FileUtils.mkdir_p(@provenance.scripts_dir)
         scripts.to_h do |file, declared|
           dest = File.join(@provenance.scripts_dir, file)
-          FileUtils.cp(File.join(@bundle_dir, "scripts", file), dest)
+          place(File.join(@bundle_dir, "scripts", file), dest)
           @results["scripts/#{file}"] = if unchanged.include?(file) then { status: "skipped", reason: "already up to date" }
                                         elsif @upgrade && @provenance.installed? then { status: "updated" }
                                         else { status: "installed" }
                                         end
-          FileUtils.chmod(0o755, dest)
+          FileUtils.chmod(0o755, dest) unless @dev
           actual = Digest::SHA256.hexdigest(File.binread(dest))
           expected = declared.to_s.delete_prefix("sha256:")
-          if @strict && !expected.empty? && actual != expected
+          if @strict && !@dev && !expected.empty? && actual != expected
             @warnings << "Checksum mismatch for script #{file}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
           end
           [file, dest]
         end
       end
 
+      # Copies +src+ to +dest+, or (a dev install) links +dest+ to it. An
+      # existing link goes first: a copy over it would write into the source.
+      def place(src, dest)
+        FileUtils.rm_f(dest) if File.symlink?(dest)
+        @dev ? File.symlink(File.realpath(src), dest) : FileUtils.cp(src, dest)
+      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

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -22,13 +22,15 @@ module Samagotchi
     #   includes    a profile's recorded members, nil for a plain bundle
     #   session_settings
     #               the keys a session may set (chi --set), [] when none
+    #   dev         a dev install (`chi bundle install --dev`): its source is
+    #               the folder it links to and its files carry Provenance::DEV_SHA
     #   error       why manifest.json couldn't be read (the rest empty), else nil
     class InstalledBundle < Data.define(:name, :version, :scope, :source, :installed_at, :trust_level, :source_commit,
                                         :requires_chi, :files, :hooks, :guardrails, :scripts, :plugin, :needs,
-                                        :includes, :context_providers, :session_settings, :error)
+                                        :includes, :context_providers, :session_settings, :dev, :error)
       OPTIONAL = { version: nil, scope: nil, source: nil, installed_at: nil, trust_level: nil, source_commit: nil,
                    requires_chi: nil, files: {}, hooks: {}, guardrails: {}, scripts: {}, plugin: nil, needs: nil,
-                   includes: nil, context_providers: nil, session_settings: [], error: nil }.freeze
+                   includes: nil, context_providers: nil, session_settings: [], dev: false, error: nil }.freeze
 
       def initialize(name:, **fields)
         super(name: name, **OPTIONAL, **fields)
@@ -60,7 +62,8 @@ module Samagotchi
             scripts: mapping(h["scripts"]) { |meta| sha(meta) },
             plugin: PluginRef.parse(h["plugin"]), needs: h["needs"], context_providers: h["context_providers"],
             includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil,
-            session_settings: h["session_settings"].is_a?(Array) ? h["session_settings"].map(&:to_s) : [])
+            session_settings: h["session_settings"].is_a?(Array) ? h["session_settings"].map(&:to_s) : [],
+            dev: h["dev"] == true)
       end
 
       def self.string(value) = value&.to_s

data/lib/samagotchi/memory_bundle/installer.rb

@@ -40,7 +40,7 @@ module Samagotchi
       # installs from a dir in it only, unless force); ShippedUpdate,
       # Profile and SystemBundle pass the one they install from.
       def initialize(source:, name:, scope: nil, force: false, strict: true, upgrade: false, dry_run: false, prepared: nil,
-                     shipped_dir: SourceNormalizer::SHIPPED_DIR)
+                     shipped_dir: SourceNormalizer::SHIPPED_DIR, dev: false)
         @source = source
         @shipped_dir = shipped_dir
         @prepared = prepared
@@ -50,6 +50,7 @@ module Samagotchi
         @strict = strict
         @upgrade = upgrade
         @dry_run = dry_run
+        @dev = dev
         @results = {}
         @warnings = []
         @placeholder_warnings = []
@@ -98,7 +99,7 @@ module Samagotchi
         installed = AssetInstaller.new(
           name: @name, source_dir: @bundle_dir, manifest: @manifest, provenance: @provenance, existing: @existing,
           results: @results, warnings: @warnings, conflicts: @conflicts,
-          force: @force, strict: @strict, upgrade: @upgrade, dry_run: @dry_run
+          force: @force, strict: @strict, upgrade: @upgrade, dry_run: @dry_run, dev: @dev
         ).run
 
         # Files the previous version shipped and this one doesn't.
@@ -172,10 +173,14 @@ module Samagotchi
       def check_source
         refuse_case_twin
         refuse_shipped_name
+        refuse_dev_mismatch
         now = incoming_identity
         return if now.nil?
 
         was = @existing && SourceIdentity.of(@existing.source)
+        if @dev && @existing&.dev && was != now
+          raise InstallError, "#{@name} is a dev install of #{@existing.source}; uninstall it before installing from #{@source}"
+        end
         return if was.nil? || was == now
         return @source_change = [@existing.source, @source.to_s] if @upgrade
 
@@ -191,6 +196,19 @@ module Samagotchi
         raise InstallError, "#{@name} differs only in case from the installed #{twin}" if twin
       end
 
+      # A dev install (--dev, linked to its source) and a normal one don't
+      # replace each other: neither an upgrade nor a plain install over a
+      # dev bundle, nor --dev over a normal one.
+      def refuse_dev_mismatch
+        return if @existing.nil? || @existing.dev == @dev
+
+        if @existing.dev
+          raise InstallError, "#{@name} is a dev install of #{@existing.source}: it follows its source already " \
+                              "(to leave dev mode: chi bundle uninstall #{@name}, then chi bundle install without --dev)"
+        end
+        raise InstallError, "#{@name} is installed normally; `chi bundle uninstall #{@name}` first, then chi bundle install --dev"
+      end
+
       # A shipped name (in any case) from anything but this chi's own
       # shipped dir. A recorded source may be an older gem's (SourceIdentity
       # matches the path); an incoming one must be a dir in SHIPPED_DIR, so
@@ -421,7 +439,8 @@ module Samagotchi
           scripts_files: installed.script_files,
           context_providers: @manifest.context_providers,
           file_descriptions: @manifest.file_descriptions,
-          session_settings: @manifest.session_settings
+          session_settings: @manifest.session_settings,
+          dev: @dev
         )
       end