samagotchi 0.148.0 → 0.150.0

data/lib/samagotchi/plugin/context.rb

@@ -16,6 +16,8 @@ module Samagotchi
   # Context#saved_session reads it; Sessions and AttachedContext load it too.
   autoload :Session, File.expand_path("../session", __dir__)
   autoload :PluginSessionState, File.expand_path("../plugin_session_state", __dir__)
+  # Context#objectives reads it; the kit shouldn't carry its files.
+  autoload :Objectives, File.expand_path("../objectives", __dir__)
 
   module Plugin
     # Loaded on first ctx.sessions / ctx.context (or a bundle naming
@@ -73,7 +75,7 @@ module Samagotchi
                       :ask_model, :model_name, :model_key, :state_dir, :scratch, :setup, :prompt_files,
                       :steer, :stop_turn, :stop_generation, :frontend, :toolkit, :declared_tools, :use_toolkit, :load_tools,
                       :cancel_controller, :cost, :usage, :turn_author, :cache_confirm, :model_names,
-                      :candidate_proposed, :judgments, keyword_init: true)
+                      :candidate_proposed, :judgments, :turn_running, keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -321,6 +323,11 @@ module Samagotchi
         Array(@host.messages.call).map { |message| message.dup.freeze }.freeze
       end
 
+      # Whether a turn runs now. Its :after_turn hooks run inside it, so a thread
+      # one of them starts can use this to wait for the end: a card shown before
+      # then belongs to that turn's block.
+      def turn_running? = !!@host.turn_running&.call
+
       # Whether #messages leaves out a running turn (the REPL mid-turn), so
       # a plugin can say what its answer is about.
       def messages_partial? = !!@host.messages_partial&.call
@@ -380,6 +387,19 @@ module Samagotchi
         @host.card.call(source: @bundle, title: title, body: body, actions: actions, level: level, id: id)
       end
 
+      # The session's objectives (docs/internals/objectives.md), read now: the
+      # newest list the conversation holds, an edit not yet absorbed over it.
+      # Mid-turn a worker's conversation leaves the running turn's tool calls
+      # out, so a move shows at the turn's end.
+      # @return [Objectives::List] empty when the session has none (or there
+      #   is no session yet); use its methods, not its class
+      def objectives
+        id = session_id
+        return Objectives::List.new unless id
+
+        Objectives.current(id, messages, state_dir: @host.state_dir&.call || Session.default_state_dir)
+      end
+
       # A side answer (plan D7): one request to the session's current model
       # on its host, with no tools and thinking off. It writes nothing,
       # fires no hooks, and doesn't touch the conversation. It blocks until

data/lib/samagotchi/project_env.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "open3"
+require_relative "bundler_env"
 require_relative "chi_home"
 require_relative "chi_shim"
 require_relative "config"
@@ -57,14 +58,14 @@ module Samagotchi
     RESERVED_PREFIXES = %w[XDG_ SAMAGOTCHI_].freeze
     # Never set from an ORIG_ENV record (a tool can write it), only unset:
     # loader and Bundler variables.
-    RESTORE_NEVER = /\A(?:DYLD_|LD_|RUBYOPT\z|RUBYLIB\z|RUBYGEMS_|BUNDLE)/
+    RESTORE_NEVER = /\A(?:DYLD_|LD_|RUBYOPT\z|RUBYLIB\z|RUBYGEMS_|#{BundlerEnv::PREFIX})/
     # Never passed to `mise env`: MISE_YES answers its trust prompt (it
     # would trust, and remember, an untrusted repo's mise.toml); CI too.
     MISE_UNSET = %w[MISE_YES CI].freeze
     TIMEOUT = 5
     # What execute and tasks set themselves (Tools::TaskRuntime's
     # sanitized env): never taken from the project's.
-    TOOLS_DROP = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
+    TOOLS_DROP = BundlerEnv::CHILD_RUBY
 
     # What #compute found: +env+ the tools' overlay ({key => value, or nil
     # to unset}; frozen, with the marker and the ORIG_ENV record),

data/lib/samagotchi/self_report.rb

@@ -494,6 +494,8 @@ module Samagotchi
         version = bundle.version || "?"
         label = "#{name} #{version}"
         label += " (shipped #{shipped})" if name == MemoryBundle::SystemBundle::BUNDLE_NAME
+        behind = bundle.behind_files
+        label += " (#{MemoryBundle::FileStanding.behind_count(behind.size, unsure: behind.any?(&:unsure))})" if behind.any?
         label
       end
       installed.empty? ? "(none installed; shipped system bundle #{shipped || "?"})" : installed.join(", ")

data/lib/samagotchi/session_commands.rb

@@ -27,6 +27,10 @@ require_relative "system_one/approval_label"
 require_relative "system_one/record"
 
 module Samagotchi
+  # Loaded on first use (a /objectives line): keeps the bundle test kit's
+  # load budget (spec/samagotchi/testing/sandbox_spec.rb).
+  autoload :ObjectivesCommand, File.expand_path("objectives_command", __dir__)
+
   # The session commands a REPL and a session worker both run: /model,
   # /models, /llm-context, /guardrails, /context, !rollback, !cmd and the answer to a continue offer. They act on
   # the Engine and its TurnFlow; the host prints the result's output and
@@ -50,6 +54,8 @@ module Samagotchi
     REASONING_HISTORY_COMMAND = ReasoningHistoryCommand::NAME
     WORKING_SET_COMMAND = WorkingSetCommand::NAME
     RECAP_COMMAND = RecapCommand::NAME
+    # A literal: ObjectivesCommand loads on first use (the autoload above).
+    OBJECTIVES_COMMAND = "/objectives"
     # A remote catalog has hundreds of ids (OpenRouter ~380): plain /models
     # shows this many per host; /models <text> lists every match.
     MODELS_PER_HOST = 20
@@ -134,6 +140,9 @@ module Samagotchi
       # Only a name: renaming a running session doesn't wait for its turn.
       registry.register(TITLE_COMMAND, "show or set this session's title (--clear: back to its first message)",
                         id: :title, anytime: true, match: ->(text) { text.match?(%r{\A/title(?:\s+.*)?\z}) }) { |text| title(text) }
+      # An edit only writes a note file (it goes in between turns): mid-turn too.
+      registry.register(OBJECTIVES_COMMAND, "show or edit what this session is to achieve (set A | B, add TEXT, edit ID TEXT, done ID…, drop ID…, undo ID…, check ID)",
+                        id: :objectives, anytime: true) { |text| objectives(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       # /recap with words (on|off|default, or a slip: the usage) runs here:
@@ -703,6 +712,12 @@ module Samagotchi
       reply(output, status: status, changed: changed ? [:title] : [])
     end
 
+    # /objectives (ObjectivesCommand): nothing to save, an edit is a note file.
+    def objectives(text)
+      output, status = ObjectivesCommand.new(engine: @engine).run(text.delete_prefix(OBJECTIVES_COMMAND))
+      reply(output, status: status)
+    end
+
     # /recap on|off|default (RecapCommand); :recap in changed when this
     # session's own recap.enabled moved. It doesn't save: its host does on
     # a changed result (Worker#run_command, the REPL).

data/lib/samagotchi/session_continue.rb

@@ -5,6 +5,7 @@ require_relative "session"
 require_relative "session_setup"
 require_relative "session_inbox"
 require_relative "session_chain"
+require_relative "objectives"
 require_relative "child_move"
 require_relative "context_move"
 require_relative "archive_store"
@@ -209,6 +210,8 @@ module Samagotchi
         ChildMove.apply(move, from: previous.id, to: link.id, state_dir: state_dir)
         # Its movable context too, with a note saying what moved and stayed.
         moved_context = ContextMove.call(from: previous.id, to: link.id, mode: :continue, state_dir: state_dir)
+        # Its objectives last: the list reads as the latest word.
+        Objectives.carry(previous, to: link.id, state_dir: state_dir)
       end
       link = SessionManager.spawn_session(
         prompt: start, preview: preview, title: previous.title, working_directory: previous.working_directory,

data/lib/samagotchi/session_inbox.rb

@@ -5,6 +5,7 @@ require "json"
 require "time"
 require "securerandom"
 require_relative "atomic_file"
+require_relative "context_note"
 require_relative "delivery"
 require_relative "log"
 require_relative "session"
@@ -83,11 +84,13 @@ module Samagotchi
     # to the conversation between turns. It never starts a turn.
     # @param source [String] where it came from ("cli", "slack", "session")
     # @param from_session [String, nil] the sending session, for a peer's note
+    # @param objectives [Hash, nil] an objectives note's payload
+    #   (Objectives::List#to_payload)
     # @param now [Time] the time the file is named and stamped by (a spec's clock)
     # @return [String] the note file's path
     # @raise [NoteRejected] for an empty note or one over 16 KiB (never cut)
     def self.write_note(session_id, text:, source: "cli", from_session: nil, from_cwd: nil, state_dir: nil,
-                        now: Time.now)
+                        objectives: nil, now: Time.now)
       body = checked_text(text)
       sd = state_dir || Session.default_state_dir
       notes_dir = File.join(Session.session_dir(session_id, state_dir: sd), NOTES_DIR)
@@ -98,7 +101,7 @@ module Samagotchi
       name = "#{now.strftime("%Y%m%d%H%M%S%9N")}-#{SecureRandom.hex(3)}.json"
       path = File.join(notes_dir, name)
       record = { "text" => body, "source" => source.to_s, "from_session" => from_session,
-                 "from_cwd" => from_cwd, "created_at" => now.iso8601 }.compact
+                 "from_cwd" => from_cwd, "created_at" => now.iso8601, "objectives" => objectives }.compact
       AtomicFile.write(path, JSON.generate(record))
       path
     end
@@ -134,15 +137,20 @@ module Samagotchi
     end
 
     # @return [Hash, nil] {note_id:, text:, source:, from_session:, from_cwd:,
-    #   created_at:}, or nil for a file that holds no usable note
+    #   created_at:}, with an objectives note's objectives: and its header:
+    #   (ContextNote.message takes them), or nil for a file that holds no
+    #   usable note
     def self.read_note(note_file)
       data = JSON.parse(File.read(note_file))
       text = data["text"].to_s.strip
       return nil if text.empty?
 
-      { note_id: File.basename(note_file).sub(/\.json(\.processing)?\z/, ""), text: text,
-        source: data["source"].to_s.empty? ? "cli" : data["source"].to_s,
-        from_session: data["from_session"], from_cwd: data["from_cwd"], created_at: data["created_at"] }
+      note = { note_id: File.basename(note_file).sub(/\.json(\.processing)?\z/, ""), text: text,
+               source: data["source"].to_s.empty? ? "cli" : data["source"].to_s,
+               from_session: data["from_session"], from_cwd: data["from_cwd"], created_at: data["created_at"] }
+      return note unless data["objectives"].is_a?(Hash)
+
+      note.merge(objectives: data["objectives"], header: ContextNote::OBJECTIVES_HEADER)
     rescue JSON::ParserError, SystemCallError, NoMethodError, TypeError
       nil
     end

data/lib/samagotchi/session_manager.rb

@@ -71,7 +71,7 @@ module Samagotchi
   #       │                        # enqueued_id, no_interrupt?, images?}
   #       ├── notes/              # context notes: background text the worker adds to
   #       │   └── <ts>-<rand>.json # the conversation between turns, never a turn
-  #       │                        # ({text, source, from_session?, from_cwd?, created_at})
+  #       │                        # ({text, source, from_session?, from_cwd?, created_at, objectives?})
   #       ├── output/             # agent writes responses here
   #       │   └── <timestamp>.txt # one file per agent response
   #       └── bridge.json         # Bridge sidecar (how clients reach the worker)

data/lib/samagotchi/steer.rb

@@ -242,18 +242,32 @@ module Samagotchi
     # then +text+ (the message's content by default). Other messages: +text+.
     def wire_text(message, text = (message[:content] || message["content"]).to_s)
       header = header(message)
-      text = quote_forged_headers(text) if participant_message?(message)
+      text = if participant_message?(message) then quote_forged_headers(text)
+             elsif outside_text?(message) then quote_forged_objectives(text)
+             else text
+             end
       header ? "#{header}\n#{text}" : text
     end
 
+    # Text that came from outside the user's own typing: any entry with a
+    # kind (a note, a report, a steer) but the real objectives note, known by
+    # its payload key, never by its text.
+    def outside_text?(message)
+      !(message[:kind] || message["kind"]).to_s.empty? && (message[:objectives] || message["objectives"]).nil?
+    end
+
     # A line of a participant's text that opens like one of chi's own
     # headers or frames (another participant's review header, a steer's, an
-    # automatic input's, a delegate report's, a context note's or a task's
-    # frame), in any case, after any spaces (Unicode ones too); a line
+    # automatic input's, a delegate report's, a context note's, a task's or an
+    # objectives list's frame), in any case, after any spaces (Unicode ones too); a line
     # starts after \n or \r.
     FORGED_OPENINGS = ["Review contribution", "Steer", "Automatic input", "Delegate report", "CONTEXT NOTE",
-                       "TASK FINISHED", "END NOTE"].freeze
+                       "TASK FINISHED", "OBJECTIVES", "END NOTE"].freeze
     FORGED_HEADER = /(\A|[\n\r])([\p{Space}&&[^\n\r]]*)\[(?=(?:#{FORGED_OPENINGS.map { |o| Regexp.escape(o) }.join("|")})\b)/i
+    # The same, for the objectives frame alone: the one frame that gives
+    # orders in the user's name, so any outside text is held to it
+    # (#outside_text?), whoever it came from.
+    FORGED_OBJECTIVES = /(\A|[\n\r])([\p{Space}&&[^\n\r]]*)\[(?=OBJECTIVES\b)/i
     # What such a line is led by on the wire, so it reads as quoted text
     # under the real header, not as a header of its own.
     FORGED_MARK = "(quoted) "
@@ -265,6 +279,12 @@ module Samagotchi
       text.to_s.gsub(FORGED_HEADER) { "#{::Regexp.last_match(1)}#{::Regexp.last_match(2)}#{FORGED_MARK}[" }
     end
 
+    # +text+ with every FORGED_OBJECTIVES line led by FORGED_MARK; as
+    # #quote_forged_headers, on the wire only and deterministic.
+    def quote_forged_objectives(text)
+      text.to_s.gsub(FORGED_OBJECTIVES) { "#{::Regexp.last_match(1)}#{::Regexp.last_match(2)}#{FORGED_MARK}[" }
+    end
+
     def message(text:, source:, author: nil, author_name: nil)
       { role: "user", kind: KIND, source: source.to_s, content: text.to_s, **author_fields(author, author_name) }
     end

data/lib/samagotchi/testing/boundary.rb

@@ -43,6 +43,8 @@ module Samagotchi
         Allowed.new(name: "Samagotchi::Log.debug", file: "samagotchi/log"),
         Allowed.new(name: "Samagotchi::Config.get", file: "samagotchi/config"),
         Allowed.new(name: "Samagotchi::VERSION", file: "samagotchi/version"),
+        Allowed.new(name: "Samagotchi::GitEnv::UNSET", file: "samagotchi/git_env"),
+        Allowed.new(name: "Samagotchi::CancellationController", file: "samagotchi/cancellation_controller"),
         # The kit itself, for a bundle's own specs.
         Allowed.new(name: "Samagotchi::Testing", file: "samagotchi/testing")
       ].freeze

data/lib/samagotchi/testing/host.rb

@@ -39,6 +39,7 @@ module Samagotchi
           notify: ->(text, level, label, fallback_for: nil) { recorder.notify(text, level, label, fallback_for) },
           ask_user: ->(question) { recorder.ask_user(question) },
           cancelled: -> { recorder[:cancelled] },
+          turn_running: -> { recorder[:running] },
           card: ->(**card) { recorder.card(**card) },
           ask_model: lambda { |request, timeout:, max_tokens:, cancel_controller:, model: nil, source: nil|
             recorder.ask_model(request, timeout: timeout, max_tokens: max_tokens, cancel_controller: cancel_controller,

data/lib/samagotchi/testing/minitest.rb

@@ -3,6 +3,9 @@
 require "minitest"
 require_relative "../testing"
 
+# Not in testing.rb: `chi bundle check` loads that into a real chi.
+Samagotchi::GitEnv.scrub!
+
 module Samagotchi
   module Testing
     # The bundle test kit in Minitest (EXPERIMENTAL, docs/plugins.md): a

data/lib/samagotchi/testing/rspec.rb

@@ -3,6 +3,9 @@
 require "rspec/core"
 require_relative "../testing"
 
+# Not in testing.rb: `chi bundle check` loads that into a real chi.
+Samagotchi::GitEnv.scrub!
+
 # The bundle test kit in RSpec (EXPERIMENTAL, docs/plugins.md): example groups
 # tagged :bundle get Samagotchi::Testing::Helpers (load_bundle,
 # shipped_bundle, sandbox), and each of their examples runs in its own

data/lib/samagotchi/testing/sandbox.rb

@@ -7,12 +7,13 @@ require_relative "../log"
 require_relative "../paths"
 require_relative "../sandbox_layout"
 require_relative "fake_executable"
+require_relative "../git_env"
 
 module Samagotchi
   module Testing
     # The environment a bundle test runs in: temp config, state, data and cache
     # homes (config.yml, memories, ctx.data_dir, the debug log), HOME and the peer
-    # CLIs' folders, git without the user's config, no Keychain, none of
+    # CLIs' folders, git without the user's config or an inherited repo (GitEnv), no Keychain, none of
     # the user's SAMAGOTCHI_* settings, a bin/ first on PATH for fake
     # commands. ENV is put back on #leave.
     #
@@ -166,6 +167,7 @@ module Samagotchi
       # ENV at +layout+'s folders, none of the SAMAGOTCHI_* settings but KEPT.
       def point_env(layout)
         ENV.each_key.select { |key| key.start_with?("SAMAGOTCHI_") && !KEPT.include?(key) }.each { |key| ENV.delete(key) }
+        GitEnv.clear(ENV)
         File.write(File.join(@root, "gitconfig"), "")
         ENV.update(
           **layout.env,

data/lib/samagotchi/tool_activity.rb

@@ -23,6 +23,7 @@ require_relative "tools/context_read"
 require_relative "tools/delegate"
 require_relative "tools/delegate_result"
 require_relative "tools/forget_outputs"
+require_relative "tools/objectives_tool"
 
 module Samagotchi
   # The one-line summary of a tool call that the UIs show ("reading file",
@@ -85,6 +86,15 @@ module Samagotchi
       event
     end
 
+    def objectives_proposal?(call) = call[:action].to_s.strip.downcase == Tools::ObjectivesTool::PROPOSE
+
+    # An objectives row's words: "O2 note · evidence", or "propose done O2 note".
+    def objectives_title(call)
+      return "#{Tools::ObjectivesTool::PROPOSE} #{call[:change]} #{call[:id]} #{call[:text]} · #{call[:note]}".squeeze(" ") if objectives_proposal?(call)
+
+      "#{call[:id]} #{call[:note]}#{" · #{call[:evidence]}" unless call[:evidence].to_s.strip.empty?}"
+    end
+
     # An execute's description, cut as a row's title; nil for the rest.
     def command_description(tool_name, call)
       return nil unless call.is_a?(Hash) && ToolView::TOOLS.include?(tool_name)
@@ -112,6 +122,7 @@ module Samagotchi
              when Tools::Read::NAME, Tools::MemoryRead::NAME then call[:content]
              when Tools::Write::NAME, Tools::Edit::NAME, Tools::MemoryWrite::NAME then call[:path]
              when Tools::Execute::NAME, Tools::TaskCreate::NAME then command_title(call[:content])
+             when Tools::ObjectivesTool::NAME then objectives_title(call)
              end
       text = text.to_s.strip
       return nil if text.empty?
@@ -205,6 +216,7 @@ module Samagotchi
       when Tools::Delegate::NAME then "delegating"
       when Tools::DelegateResult::NAME then "waiting for a delegate"
       when Tools::ForgetOutputs::NAME then forget_outputs_action(call)
+      when Tools::ObjectivesTool::NAME then objectives_proposal?(call) ? "proposing a change" : "recording a move"
       else registry_entry(registry, tool_name)&.label || "calling tool"
       end
     end
@@ -430,6 +442,11 @@ module Samagotchi
         parts << "restore=#{preview_tool_param(request.restore.join(","))}" if request.restore?
         parts << "note=#{preview_tool_param(request.note)}" unless request.note.empty?
         parts.empty? ? nil : parts.join(" ")
+      when Tools::ObjectivesTool::NAME
+        parts = ["id=#{preview_tool_param(call[:id])}", "note=#{preview_tool_param(call[:note])}"]
+        parts.unshift("change=#{preview_tool_param(call[:change])}") if objectives_proposal?(call)
+        parts << "evidence=#{preview_tool_param(call[:evidence])}" unless call[:evidence].to_s.strip.empty?
+        parts.join(" ")
       when Tools::AskUserQuestion::NAME
         parts = ["question=#{preview_tool_param(call[:question] || call[:content])}"]
         opts = call[:options]

data/lib/samagotchi/tool_declarations.rb

@@ -440,6 +440,40 @@ module Samagotchi
           },
           required: %w[question options]
         }
+      },
+      {
+        name: "objectives",
+        description: "Record a move on one of the objectives in the OBJECTIVES note: in a line, what you did or found that moves it, so the user can follow. One when an objective really moved, not per step. Or propose a change to the list (action propose): the user sees a card and applies it or not. This tool doesn't edit the list, change a status or mark anything done, and it approves nothing; the user edits the list with /objectives. Asked to change it, propose it or say so, instead of saying you changed it.",
+        parameters: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              description: "move or propose"
+            },
+            id: {
+              type: "string",
+              description: "The objective's id, e.g. O2 (not for a proposed add)"
+            },
+            note: {
+              type: "string",
+              description: "A move: what moved, in a line. A proposal: why, in a line"
+            },
+            evidence: {
+              type: "string",
+              description: "Optional, a move's: what shows it (a commit, a test count, a file)"
+            },
+            change: {
+              type: "string",
+              description: "A proposal's: add, reword, done or drop"
+            },
+            text: {
+              type: "string",
+              description: "A proposed add's or reword's new text"
+            }
+          },
+          required: %w[action note]
+        }
       }
     ].freeze
 

data/lib/samagotchi/tools/builtin_calls.rb

@@ -53,7 +53,8 @@ module Samagotchi
         "delegate" => { content: "task", fallback: :prefix_or_raw },
         "ask_user_question" => { content: "question", also: %w[question], verbatim: %w[options], options: true,
                                  fallback: :raw },
-        "forget_outputs" => { content: "note", also: %w[note], verbatim: %w[ids keep restore] }
+        "forget_outputs" => { content: "note", also: %w[note], verbatim: %w[ids keep restore] },
+        "objectives" => { content: "note", also: %w[note] }
       }.freeze
 
       # A name the model uses for a built-in, mapped to that built-in (a model

data/lib/samagotchi/tools/builtins.rb

@@ -25,6 +25,7 @@ require_relative "delegate"
 require_relative "delegate_result"
 require_relative "ask_user_question"
 require_relative "forget_outputs"
+require_relative "objectives_tool"
 require_relative "../guardrails/parent_approvals"
 require_relative "../guardrails/pair_boundary"
 require_relative "../model_profile"
@@ -58,7 +59,8 @@ module Samagotchi
         ContextRead,
         Delegate,
         DelegateResult,
-        AskUserQuestion
+        AskUserQuestion,
+        ObjectivesTool
       ].freeze
       # The built-ins an LLM context layer adds (offered only under it).
       LAYER_CLASSES = [ForgetOutputs].freeze
@@ -115,6 +117,7 @@ module Samagotchi
           DelegateResult.call(call[:content], session: call[:session], timeout: call[:timeout], peers: kctx.peers)
         end,
         AskUserQuestion::NAME => ->(call, kctx) { kctx.ask_user_question(call) },
+        ObjectivesTool::NAME => ->(call, kctx) { ObjectivesTool.call(call, peers: kctx.peers) },
         ForgetOutputs::NAME => ->(call, kctx) { kctx.forget_outputs(call) }
       }.freeze
 

data/lib/samagotchi/tools/delegate.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../client_id"
+require_relative "../git_env"
 require_relative "../session"
 require_relative "../config"
 require_relative "../model_profile"
@@ -272,7 +273,7 @@ module Samagotchi
         git_dir = MemoryPaths.git_dir(folder)
         return false if git_dir && within?(folder, File.realpath(git_dir))
 
-        out = IO.popen(["git", "-C", folder, "rev-parse", "--is-inside-work-tree"], err: File::NULL, &:read)
+        out = IO.popen(GitEnv::UNSET, ["git", "-C", folder, "rev-parse", "--is-inside-work-tree"], err: File::NULL, &:read)
         out.strip == "true"
       rescue SystemCallError
         false

data/lib/samagotchi/tools/objectives_tool.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../tool_response"
+
+module Samagotchi
+  # Read at a call only: the builtins' file list loads this, Session not with it.
+  autoload :Objectives, File.expand_path("../objectives", __dir__)
+
+  module Tools
+    # The objectives tool's two actions. A move: what the model did or found for
+    # an objective. Information only: it never changes a status or the list
+    # (the user does, /objectives), and nothing is written here: the call in
+    # history is the record, which Objectives.build reads back. A proposal: a
+    # change to the list the user applies from a card with one tap, the card's
+    # action being the /objectives line; the model never changes the list by
+    # itself. See docs/internals/objectives.md.
+    class ObjectivesTool
+      NAME = "objectives"
+      MOVE = "move"
+      PROPOSE = "propose"
+      PROPOSED = "Proposed %s. The list is unchanged: the user sees a card and applies it or not."
+      RECORDED = "Recorded a move on %s."
+      EDITED_BY_USER = "The user edits the list with /objectives."
+      NONE = "There are no objectives here, so nothing was recorded. #{EDITED_BY_USER}".freeze
+
+      def self.name = NAME
+
+      # Whether +output+, a saved run, is this tool's answer that it recorded a
+      # move on +id+ (Objectives.moves_in). Positive: a run that recorded
+      # nothing (no list, a refusal, a denial, an interrupt) has no such answer.
+      def self.recorded?(output, id)
+        output.to_s.sub(ToolResponse::LEAD, "").start_with?(RECORDED % id)
+      end
+
+      # @param call [Hash] the internal call (BuiltinCalls: action:, id:,
+      #   note:, evidence:)
+      # @param peers [#objectives, nil] the session's list
+      # @return [String] the tool result
+      def self.call(call, peers:)
+        action = call[:action].to_s.strip.downcase
+        unless action.empty? || [MOVE, PROPOSE].include?(action)
+          return "Error: this tool records a move (action: move) or proposes a change (action: propose); it edits nothing. #{EDITED_BY_USER}"
+        end
+
+        list = peers&.objectives
+        return NONE if list.nil? || list.empty?
+        return propose(list, call, peers) if action == PROPOSE
+
+        id = Objectives.move_id(call)
+        refusal(list, id, call) || "#{RECORDED % id} The list is unchanged: this tool doesn't edit it. #{EDITED_BY_USER}"
+      end
+
+      def self.propose(list, call, peers)
+        proposal = Objectives::Proposal.against(list, change: call[:change].to_s.strip.downcase, id: Objectives.move_id(call),
+                                                      text: Objectives.clean(call[:text]), note: Objectives.clean(call[:note]))
+        refused = proposal.refusal(list)
+        return "Error: #{refused}. Nothing was proposed." if refused
+
+        return "Error: at most #{Objectives::PROPOSALS_PER_TURN} proposals a turn. Nothing more was proposed." unless peers.propose_objective(proposal)
+
+        format(PROPOSED, proposal.line.delete_prefix("/objectives "))
+      end
+      private_class_method :propose
+
+      def self.refusal(list, id, call)
+        item = list.find(id)
+        return "Error: no objective #{id} (this session's: #{list.items.map(&:id).join(", ")}). Nothing was recorded." unless item
+        return "Error: #{id} was dropped, so nothing was recorded." if item.status == Objectives::DROPPED
+
+        "Error: a move needs a note: what moved, in a line." if Objectives.clean(call[:note]).empty?
+      end
+      private_class_method :refusal
+    end
+  end
+end

data/lib/samagotchi/tools/peers.rb

@@ -27,6 +27,9 @@ module Samagotchi
       # A person's message waits for the turn's next boundary: never here
       # (Engine::PeerView asks the running turn).
       def input_waiting? = false
+
+      # The session's objectives: none here (Engine::PeerView reads them).
+      def objectives = nil
     end
   end
 end

data/lib/samagotchi/tools/task_runtime.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "shellwords"
 require "time"
 require_relative "../atomic_file"
+require_relative "../bundler_env"
 require_relative "../child_env"
 require_relative "../log"
 require_relative "../process_group"
@@ -28,7 +29,7 @@ module Samagotchi
       STOP_POLL_INTERVAL_SEC = 0.1
       METADATA_VERSION = TaskRecord::METADATA_VERSION
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
-      SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
+      SANITIZED_ENV_KEYS = BundlerEnv::CHILD_RUBY
       # Set by chi (Builtins.parent_env); the model's env can't change it.
       MARKER_ENV_KEYS = ChildEnv::SESSION_MARKERS
       # task_wait and task_get add it to a task the user stopped (the web's
@@ -448,15 +449,16 @@ module Samagotchi
       # chi's own Ruby/Bundler setup, kept out of a command's environment
       # (execute and task_create both spawn with it): run under `bundle
       # exec`, chi would otherwise hand a project's `ruby -e` or
-      # `bundle exec` its Gemfile (RUBYOPT=-rbundler/setup, BUNDLE_GEMFILE).
+      # `bundle exec` its Gemfile (RUBYOPT=-rbundler/setup, BUNDLE_GEMFILE,
+      # BUNDLER_SETUP) and lockfile.
       def sanitized_spawn_env
-        {
-          "RUBYOPT" => sanitized_rubyopt,
-          "RUBYLIB" => nil,
-          "BUNDLE_GEMFILE" => nil,
-          "BUNDLE_BIN_PATH" => nil,
-          "BUNDLER_VERSION" => nil
-        }
+        SANITIZED_ENV_KEYS.to_h { |key| [key, nil] }.merge("RUBYOPT" => sanitized_rubyopt)
+      end
+
+      # The model's way out: a Ruby or Bundler variable it does want, for one command.
+      def sanitized_key_error(key)
+        "Error: env key is reserved: #{key} (chi clears it for every command; to set it for this one, " \
+          "put it in the command: #{key}=value cmd)"
       end
 
       def spawn_env_for(overrides)
@@ -469,7 +471,8 @@ module Samagotchi
         overrides.each do |key, value|
           return [nil, "Error: env keys and values must be strings"] unless key.is_a?(String) && value.is_a?(String)
           return [nil, "Error: env keys and values cannot contain NUL bytes"] if key.include?("\0") || value.include?("\0")
-          return [nil, "Error: env key is reserved: #{key}"] if SANITIZED_ENV_KEYS.include?(key) || MARKER_ENV_KEYS.include?(key)
+          return [nil, "Error: env key is reserved: #{key}"] if MARKER_ENV_KEYS.include?(key)
+          return [nil, sanitized_key_error(key)] if SANITIZED_ENV_KEYS.include?(key)
 
           normalized[key] = value
         end

data/lib/samagotchi/turn_flow.rb

@@ -191,7 +191,8 @@ module Samagotchi
     # Restore the pre-turn checkpoint (!rollback after a Ctrl-C). A pending
     # offer goes too: the turn it offered to continue is gone. (The REPL
     # reads every line as an answer while an offer is pending; a worker
-    # also takes !rollback then.)
+    # also takes !rollback then.) :turn_rolled_back tells the cards' count
+    # (Bridge::CardStore) that the turn's prompt is gone.
     # @return [Boolean] false when there is none
     def rollback!
       return false unless @checkpoint
@@ -199,6 +200,7 @@ module Samagotchi
       restore(@checkpoint)
       @checkpoint = nil
       @offer = nil
+      @engine.announce({ type: :turn_rolled_back })
       true
     end