samagotchi 0.147.0 → 0.149.0

data/lib/samagotchi/engine.rb

@@ -51,6 +51,7 @@ require_relative "context_candidates"
 require_relative "context_candidates_log"
 require_relative "context_candidate_choice"
 require_relative "context_judge"
+require_relative "objectives_audit"
 require_relative "owner_prompt"
 require_relative "side_judgments"
 require_relative "toolkit_suggest"
@@ -156,6 +157,8 @@ module Samagotchi
       # steers) and the idle layer's activity clock. Built first: a plugin
       # may steer or ask whether a turn runs while it loads.
       @turn_state = TurnState.new(clock: -> { monotonic_now })
+      @objective_proposals = []
+      @objective_proposals_mutex = Mutex.new
       # A message for the running turn cutting its generation.
       @steer_cut = SteerCut.new(clock: -> { monotonic_now }, controller: -> { active_cancel_controller },
                                 cut_after: -> { steer_cut_after })
@@ -767,6 +770,8 @@ module Samagotchi
     # command's ask_model between turns).
     # @return [String, nil]
     def side_author(kind)
+      # Check this is only ever the owner's, whichever turn runs as it ends.
+      return nil if kind.to_s == ObjectivesCheck::SOURCE
       return nil unless turn_running? || kind.to_s == RECAP_SIDE_KIND
 
       @guardrail_wiring.turn_author
@@ -956,7 +961,7 @@ module Samagotchi
     ANNOUNCEABLE_EVENTS = %i[turn_enqueued turn_dequeued input_merged prompt_restored continue_offered continue_resolved
                              command_queued command_ran context_added card hook_notice guardrail_warning
                              plugin_init_started plugin_init_finished working_set_updated participants_changed
-                             verdict_recorded].freeze
+                             verdict_recorded objectives_updated].freeze
 
     # Put a transport-level event into the ordered event log. Unlike turn
     # events it reaches only persistent observers (no turn sink, no memory
@@ -987,6 +992,63 @@ module Samagotchi
       synchronize_events { emit_working_set(nil, session, session.messages) }
     end
 
+    # The session's objectives as the page draws them (Objectives.view), when
+    # that differs from the last announced: after an edit (its file written,
+    # pending), once a list note is in, at a turn's end (its moves) and after
+    # a rollback. A session with no list announces nothing. It only informs:
+    # a failure is logged, never the turn's.
+    def announce_objectives(session = @session)
+      return unless session
+
+      synchronize_events do
+        view = Objectives.view(session.id, session.messages, state_dir: session_state_dir, running: live_conversation&.dup)
+        next if view.nil? || view == @objectives_announced
+
+        @objectives_announced = view
+        announce({ type: :objectives_updated, session_id: session.id, **view })
+      end
+    rescue StandardError => e
+      Log.warn(:turn, "objectives_announce_failed", error: e.class.name, msg: e.message)
+    end
+
+    # Check this (ObjectivesCheck)'s one side request. Its usage is in the
+    # session's side line. Raises as ctx.ask_model's request does.
+    # @param request [Array<Hash>] chat messages
+    # @param model [String, nil] a configured model; nil: the session's
+    # @return [String] the answer
+    def ask_objective_check(request, model:)
+      ask_side_model(request, timeout: ObjectivesCheck::TIMEOUT_SECONDS, max_tokens: ObjectivesCheck::MAX_TOKENS,
+                              cancel_controller: nil, model: model, source: ObjectivesCheck::SOURCE)
+    end
+
+    # A change the model proposes (the objectives tool), kept until the turn
+    # is over, as #context_choice's cards are: a card shown then is a quiet one, between turns, with its Apply kept
+    # over a restart (CardStore), not a running turn's that says it waits on the
+    # user. The same change twice in a turn is one card.
+    # @return [Boolean] false past Objectives::PROPOSALS_PER_TURN
+    def propose_objective(proposal)
+      @objective_proposals_mutex.synchronize do
+        next true if @objective_proposals.any? { |p| p.line == proposal.line }
+        next false if @objective_proposals.size >= Objectives::PROPOSALS_PER_TURN
+
+        @objective_proposals << proposal
+        true
+      end
+    end
+
+    def show_objective_proposals
+      proposals = @objective_proposals_mutex.synchronize { @objective_proposals.slice!(0..) }
+      proposals.each do |proposal|
+        id = "objectives-#{SecureRandom.hex(4)}"
+        show_card(source: Objectives::SOURCE, id: id, title: proposal.title, body: proposal.body,
+                  actions: [{ label: "Apply", command: proposal.action_line(id) },
+                            { label: "Dismiss", command: "/objectives --card #{id} dismiss" }])
+      end
+    rescue StandardError => e
+      Log.warn(:turn, "objectives_proposal_failed", error: e.class.name, msg: e.message)
+    end
+    private :show_objective_proposals
+
     # The strategy the working set is built under now, as LLMContextView
     # takes it: the running turn's, else the next turn's (#emit_working_set).
     # /working-set's ops act under it.
@@ -1018,11 +1080,14 @@ module Samagotchi
         next nil if Array(session.messages).any? { |m| m[:note_id] == note[:note_id] }
 
         message = ContextNote.message(**note)
+        entry = note[:objectives] && Objectives.entry(note[:objectives], before: Objectives.build(session.messages))
         replace_session_messages(session, Array(session.messages) + [message])
         announce({ type: :context_added, session_id: session.id, note_id: note[:note_id], source: note[:source],
                    label: ContextNote.label_of(message), from_session: note[:from_session],
                    from_cwd: note[:from_cwd], text: note[:text], context_source: note[:context_source],
-                   created_at: note[:created_at] }.compact)
+                   created_at: note[:created_at], objectives: entry }.compact)
+        announce_objectives(session) if entry
+        objectives_audit.note(session, note)
         message
       end
     end
@@ -1677,6 +1742,7 @@ module Samagotchi
         event[:verdict] = verdict if verdict
         event[:revises] = revises.to_h if revises
         emit_working_set(turn.on_event, turn.session, turn.session.messages)
+        announce_objectives(turn.session)
         turn.session.status = Session::STATUS_IDLE
         record_last_turn(turn.session, outcome, seconds, turn.origin, event, limit: exhausted ? turn.limit : nil)
         emit_event(turn.on_event, turn.tag(event))
@@ -2366,6 +2432,7 @@ module Samagotchi
       ensure
         release_turn(probe_cancel_before)
         show_context_cards_after_turn
+        show_objective_proposals
       end
     end
 
@@ -2469,6 +2536,7 @@ module Samagotchi
       # The candidate judge: its asks run beside the turn; on mode's
       # attaches reach the model at the next between-turn delivery.
       start_context_judge(turn)
+      audit_objectives_incoming(turn)
       apply_toolkit!(session, turn.on_event)
       refresh_participants!(session)
       # A Stop during the waits above: the turn ends here,
@@ -2740,14 +2808,18 @@ module Samagotchi
 
       # Fire :after_turn hook (an answer or a Stop; an Interrupt or a failure
       # ends the turn in #run_turn without it), with a read-only
-      # copy of the conversation the turn stored, event[:present] for
+      # copy of the conversation the turn stored, event[:answer] (the answer's
+      # text: the native loop's stored message still holds its thought),
+      # event[:present] for
       # a display version of the answer (AnswerDisplay) and event[:refs]
       # for refs on it (AnswerRefs).
       session = turn.session
+      audit_objectives_outgoing(turn, result) unless canceled || result.exhausted?
       display = AnswerDisplay.new(session.messages)
       refs = AnswerRefs.new(session.messages, cwd: session.working_directory)
       after_turn = { type: :after_turn, status: canceled ? "canceled" : "completed",
-                     messages: hook_messages(session.messages) }
+                     messages: hook_messages(session.messages),
+                     answer: (result.text unless canceled || result.exhausted?) }
       after_turn[:present] = display.presenter(after_turn)
       after_turn[:refs] = refs.adder(after_turn)
       @hooks.fire(:after_turn, after_turn)
@@ -2855,7 +2927,8 @@ module Samagotchi
     # The running turn's conversation as its loop builds it (both loops
     # register it on the kernel's llm_context_turn): the same array the loop
     # appends to, not a copy, so read it on the turn's thread (the pending
-    # input drain, at an iteration boundary: TurnCheckpoint). nil when no
+    # input drain, at an iteration boundary: TurnCheckpoint), or from another
+    # only as a dup, read only (/objectives). nil when no
     # turn runs (llm_context_turn is never cleared, and still holds the
     # last turn's then).
     # @return [Array<Hash>, nil]
@@ -2885,7 +2958,10 @@ module Samagotchi
       raise ArgumentError, "no current session" unless @session
 
       messages = replace_session_messages(@session, clone_messages(checkpoint))
-      announce_working_set unless turn_running?
+      unless turn_running?
+        announce_working_set
+        announce_objectives
+      end
       messages
     end
 
@@ -3296,6 +3372,36 @@ module Samagotchi
     end
     private :start_context_judge
 
+    # System 1 on the objectives, in audit (ObjectivesAudit): the owner's turns
+    # only, and for a message a person's: a reminder's or a delegate's prompt isn't one.
+    def audit_objectives_incoming(turn)
+      return unless turn.prompt.is_a?(String) && turn.origin.human? && OwnerPrompt.turn?(session: turn.session, author: turn.origin.author)
+
+      objectives_audit.incoming(turn.session, turn.prompt)
+    end
+    private :audit_objectives_incoming
+
+    def audit_objectives_outgoing(turn, result)
+      return unless OwnerPrompt.turn?(session: turn.session, author: turn.origin.author)
+
+      objectives_audit.outgoing(turn.session, result.text)
+    end
+    private :audit_objectives_outgoing
+
+    # With saving off nothing would come of an ask, so none is made.
+    def objectives_audit
+      @objectives_audit ||= ObjectivesAudit.new(
+        side: @side_judgments, state_dir: -> { session_state_dir },
+        client_for: lambda do |judgment, session|
+          next nil unless system_one_runs.on?
+
+          system_one_recording(SystemOne::Client.from_config(host_registry: @host_registry, mode: ObjectivesAudit::MODE, tag: :system_one),
+                               judgment, session)
+        end
+      )
+    end
+    private :objectives_audit
+
     # A late proposal no owner prompt mentions (Plugin::Host
     # #candidate_proposed: github-pr's init task runs beside the first
     # turn): judged on the owner's prompts so far, the running turn's too.
@@ -3446,6 +3552,7 @@ module Samagotchi
         cwd: -> { @session&.working_directory },
         messages: -> { plugin_messages },
         messages_partial: -> { turn_running? && @running_turn_messages.nil? },
+        turn_running: -> { turn_running? },
         notify: ->(text, level, label, fallback_for: nil) { hook_notify(text, level, label, fallback_for: fallback_for) },
         ask_user: ->(question) { hook_ask_user(question) },
         # An init task's is its own (a Ctrl-C ends a turn, not the task).

data/lib/samagotchi/engine_peers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "objectives"
+
 module Samagotchi
   # The views of an Engine its peers get: the kernel's tools
   # (Engine#initialize sets @kernel.peers) and a delegate's approval relay
@@ -28,6 +30,15 @@ module Samagotchi
       # The peer's name when +name+ is a source a peer bundle declared
       # (PeerSources), for context_read's header.
       def peer_label(name) = engine.peer_sources&.label_for(name)
+
+      # The session's objectives now (the objectives tool), nil outside one.
+      def objectives
+        session = engine.session
+        session && Objectives.current(session.id, session.messages, state_dir: engine.peer_state_dir)
+      end
+
+      # A proposed change: its card shows at the turn's end (Engine#propose_objective).
+      def propose_objective(proposal) = engine.propose_objective(proposal)
     end
 
     # What the approval relay needs from the parent's Engine (Peers#relay):

data/lib/samagotchi/guardrail_wiring.rb

@@ -323,7 +323,7 @@ module Samagotchi
       # one that passes every gate is allowed once without reaching them
       # (docs/guardrails.md, "System 1").
       judgment = begin
-        system_one_judge(payload, targets: verdict.targets)
+        system_one_judge(payload, targets: verdict.targets, ask_user: verdict.fresh_ask? || verdict.second_rule_ask?)
       rescue LLM::RequestCancelled
         return turn_stopped(verdict)
       end
@@ -366,8 +366,9 @@ module Samagotchi
     # auto-allowed: its asks go to the owner. No client (mode off, no
     # host) means no line at all. A judgment that fails is logged with p nil,
     # so the failures are in the log too.
+    # With +ask_user+ (a fresh ask, a second rule's) it is judged and logged, never answered.
     # @return [Hash, nil] {id:, p:, auto:}, nil when nothing was written
-    def system_one_judge(payload, targets: nil)
+    def system_one_judge(payload, targets: nil, ask_user: false)
       return nil if Steer.participant_author?(turn_author)
 
       client = @system_one.call
@@ -397,13 +398,13 @@ module Samagotchi
       end
       latency_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round
       p = answers && answers[SystemOne::ApprovalQuestion::ID]&.noul
-      auto = system_one_auto_allow?(client, approval, p, entries, targets: targets)
+      auto = !ask_user && system_one_auto_allow?(client, approval, p, entries, targets: targets)
       decision = system_one_decision(client, auto)
 
       id = log.judgment(id: run_id, session_id: @session_lookup.call&.id,
                         rule: approval.rule, source: approval.source, tool: approval.tool,
                         **SystemOne::ApprovalQuestion.call_fields(approval),
-                        repo_name: approval.repo_name,
+                        repo_name: approval.repo_name, repo: targets&.repo,
                         p: p, threshold: Config.get("guardrails.system_one.threshold"), model: client.model,
                         latency_ms: latency_ms, decision: decision, origin: "live")
       # A judgment the log cannot hold is no judgment: the user is asked.
@@ -443,7 +444,8 @@ module Samagotchi
 
     # Every gate an auto-allow must pass, in order: the mode, the rule the
     # user opted in, the never-list and chi's own files, the probability, and
-    # the rule's record. Any one that fails leaves the ask to the user. The
+    # the rule's record (this repo's for a rule that goes by repo; with no repo
+    # that is none). Any one that fails leaves the ask to the user. The
     # entries are the judgment log read once for this ask.
     # @param approval [Guardrails::ApprovalFacts] the ask's facts
     # @param entries [Array<Hash>] SystemOne::Log#entries
@@ -460,7 +462,10 @@ module Samagotchi
       return false if p.nil? || p.to_f < threshold
 
       min_record = Config.get("guardrails.system_one.min_record").to_i
-      SystemOne::Record.new(entries, rule: rule).qualifies?(threshold: threshold, min_record: min_record)
+      per_repo = SystemOne::Record.per_repo?(rule)
+      return false if per_repo && targets&.repo.nil?
+
+      SystemOne::Record.new(entries, rule: rule, repo: (targets.repo if per_repo)).qualifies?(threshold: threshold, min_record: min_record)
     rescue StandardError => e
       Samagotchi::Log.warn(:guardrails, "system_one_gate_failed", error: "#{e.class}: #{e.message}")
       false

data/lib/samagotchi/guardrails/approvals.rb

@@ -80,7 +80,9 @@ module Samagotchi
           case e["scope"]
           when "session" then session_id && e["session_id"] == session_id && e["key"] == key
           when "repo" then here.call(e) && e["key"] == key
-          when "rule" then verdict.rule && e["rule"] == verdict.rule && e["source"] == verdict.source && here.call(e)
+          when "rule"
+            # One rule's grant can't answer for a second rule's ask on the call.
+            !verdict.second_rule_ask? && verdict.rule && e["rule"] == verdict.rule && e["source"] == verdict.source && here.call(e)
           end
         end
       end

data/lib/samagotchi/guardrails/pair_boundary.rb

@@ -34,7 +34,8 @@ module Samagotchi
     #   - owner-voiced tools (OWNER_VOICED, and any delegate_* tool): what
     #     speaks or acts in the owner's name beyond this turn (a delegate, a
     #     reminder, a note to another session, a background task, a
-    #     forgotten output, the session's loaded tools); the tools that read
+    #     forgotten output, the session's loaded tools, a move on the owner's
+    #     objectives); the tools that read
     #     the owner's background tasks (OWNER_TASK_READERS); and memory_write:
     #     a memory reaches the owner's later sessions;
     #   - ask_user_question: there is no one on the participant's side to
@@ -51,7 +52,7 @@ module Samagotchi
       RULE = "pair-boundary"
       SOURCE = "core"
       OWNER_VOICED = %w[delegate register_reminder cancel_reminder send_note forget_outputs task_create task_stop
-                        find_tools].freeze
+                        find_tools objectives].freeze
       OWNER_VOICED_PREFIX = "delegate_"
       # The background task tools that read the owner's tasks (a pair turn
       # starts none: task_create is owner-voiced, and its execute is never

data/lib/samagotchi/guardrails/rules.rb

@@ -310,10 +310,13 @@ module Samagotchi
         @disable.reject { |entry| @rules.any? { |rule| disables?(entry, rule) } }
       end
 
-      # A core check: every matching rule votes (strictest wins).
+      # A core check: every matching rule votes (strictest wins). A second
+      # rule id that asks takes rule grants out (Verdict#second_rule_asks!);
+      # asks from before the rules (the child boundary's) stay as they are.
       def check(verdict)
         return verdict unless @enabled
 
+        asking = nil
         @rules.each do |rule|
           next if disabled?(rule)
           next unless rule.for_mode?(@mode)
@@ -323,6 +326,8 @@ module Samagotchi
             verdict.deny!(rule.reason, rule: rule.id, source: rule.source, decided_by: "rule")
           else
             verdict.ask!(rule.reason, scopes: rule.scopes, rule: rule.id, source: rule.source, decided_by: "rule")
+            verdict.second_rule_asks!(rule.scopes) if asking && asking != rule.id
+            asking ||= rule.id
           end
         end
         verdict

data/lib/samagotchi/guardrails/verdict.rb

@@ -8,7 +8,8 @@ module Samagotchi
     # first one stays, except that a protected rule's ask (PROTECTED_RULES)
     # takes over an unprotected ask: its rule id is what a parent's answer
     # and a stored approval are checked against, and the offered scopes
-    # narrow to both asks' common ones.
+    # narrow to both asks' common ones. A second rule's ask takes rule grants
+    # out (#second_rule_asks!): the one id it keeps can't answer for both.
     class Verdict
       STRICTNESS = { allow: 0, ask: 1, deny: 2 }.freeze
       # Rules that ask about chi's own config and hooks: the core
@@ -47,6 +48,9 @@ module Samagotchi
 
       def fresh_ask? = @fresh_ask == true
 
+      # Whether a second distinct rule asks about this call (#second_rule_asks!).
+      def second_rule_ask? = @second_rule_ask == true
+
       def initialize(call:)
         @call = call
         @decision = :allow
@@ -84,6 +88,22 @@ module Samagotchi
         self
       end
 
+      # A second distinct rule asks about this call (Rules#check). The ask
+      # names one rule, and a rule grant or System 1's record is about that
+      # rule alone, so neither answers for the other's: no rule-scope entry
+      # matches it (Approvals.find_in), System 1 doesn't auto-allow it, and it
+      # offers what both rules allow, minus the rule. An exact-call entry
+      # (session, repo) still answers: it is keyed on the whole command.
+      # @param scopes [Array<String>, nil] the second rule's scopes (default all)
+      def second_rule_asks!(scopes = nil)
+        @second_rule_ask = true
+        allowed = Array(scopes).map(&:to_s) & SCOPES
+        allowed = SCOPES if allowed.empty?
+        left = (@scopes & allowed) - %w[rule]
+        @scopes = left.empty? ? %w[once] : left
+        self
+      end
+
       def self.protected_rule?(rule) = PROTECTED_RULES.include?(rule.to_s)
 
       # A before_tool_call hook set the old event[:blocked] flag. Its model

data/lib/samagotchi/guardrails_command.rb

@@ -8,6 +8,7 @@ require_relative "cli/flags"
 require_relative "config"
 require_relative "bridge/card_store"
 require_relative "guardrails/approval"
+require_relative "guardrail_wiring"
 require_relative "guardrails/approvals"
 require_relative "guardrails/parent_policy"
 require_relative "host_registry"
@@ -20,7 +21,10 @@ module Samagotchi
   # seed: System 1 judges every approval this machine's sessions already
   # answered, and the judgment and the user's answer go to the log as they
   # would live. A rule's record then starts with the asks the user really
-  # decided on, instead of waiting for a few days of live ones.
+  # decided on, instead of waiting for a few days of live ones. `rule` says
+  # whether one rule votes `ask` on this machine now, read from the config and
+  # the installed bundles as a worker reads them (GuardrailWiring#rules), by
+  # its id: the text of a command never comes near it.
   class GuardrailsCommand
     include CLI::Command
 
@@ -41,16 +45,24 @@ module Samagotchi
           --dry-run judges and prints the table without writing a line. Needs
           guardrails.system_one.mode audit or on and a system_one.host
           (exit 2 without one).
+        rule <id>
+          Print exactly "asks" when the rule is loaded, not disabled and votes
+          ask in this guardrails.mode for every model; another line says why not
+          when it isn't (exit 0 either way). Reads config.yml and the installed
+          bundles, as a worker does: no session, no model, nothing written.
     TEXT
 
-    SUBCOMMANDS = %w[replay].freeze
+    SUBCOMMANDS = %w[replay rule].freeze
     FLAGS = {
       "replay" => CLI::Flags.new(help: HELP_WORDS, args: false) do |f|
         f.switch "--dry-run"
         f.value "--threshold"
         f.value "--model"
-      end
+      end,
+      "rule" => CLI::Flags.new(help: HELP_WORDS)
     }.freeze
+    # What `rule` prints when a rule asks. An agent compares the line to it.
+    ASKS = "asks"
     # The labels that mean the user let the call through.
     ALLOW_LABELS = %w[allow_once allow_wide].freeze
     # replay's table, in column order: the rule, how many asks it had, how
@@ -135,6 +147,8 @@ module Samagotchi
       parsed = parse_flags(FLAGS.fetch(@sub), @argv[1..])
       return parsed if parsed.is_a?(Integer)
 
+      return rule(parsed.args) if @sub == "rule"
+
       replay(parsed.options)
     end
 
@@ -142,6 +156,36 @@ module Samagotchi
 
     def command_name = @sub ? "chi guardrails #{@sub}" : "chi guardrails"
 
+    def rule(args)
+      return usage_error("give one rule id") unless args.size == 1
+
+      @stdout.puts(rule_status(args.first))
+      CLI::Exit::OK
+    end
+
+    # The rule set as a worker would load it now, the rule's id looked up in
+    # it. Every other answer than ASKS names what stands in the way.
+    def rule_status(id)
+      wiring = GuardrailWiring.new(scratch: false, hooks: -> {}, tools: -> {}, session: -> {}, model_key: -> {},
+                                   cancelled: -> { false }, ask: ->(_fields) {})
+      rules = wiring.rules
+      failed = wiring.failures.required
+      return "rules failed to load: #{failed.map(&:what).join(", ")}" unless failed.empty?
+      return "guardrails are off (guardrails.enabled: false)" unless rules.enabled?
+
+      named = rules.rules.select { |r| r.id == id }
+      return "no rule #{id} is loaded" if named.empty?
+
+      enabled = named.reject { |r| rules.disabled?(r) }
+      return "rule #{id} is disabled (guardrails.disable)" if enabled.empty?
+
+      voting = enabled.select { |r| r.for_mode?(rules.mode) }
+      return "rule #{id} doesn't vote in guardrails.mode #{rules.mode}" if voting.empty?
+      return "rule #{id} denies" if voting.any? { |r| r.verdict == :deny }
+
+      voting.any? { |r| r.models.nil? } ? ASKS : "rule #{id} asks for some models only"
+    end
+
     def replay(options)
       threshold = threshold(options[:threshold])
       return usage_error(threshold) if threshold.is_a?(String)

data/lib/samagotchi/llm/chat_loop.rb

@@ -259,7 +259,7 @@ module Samagotchi
       # Claude model's cache breakpoint there (PromptCache) and drops it
       # for every other request.
       def system_message(entry, index)
-        text = entry[:content].to_s
+        text = Steer.wire_text(entry, entry[:content].to_s)
         split = index.zero? && @stable_length&.call(text)
         split ? { role: "system", content: text, cache_split: split } : { role: "system", content: text }
       end

data/lib/samagotchi/note_command.rb

@@ -123,7 +123,7 @@ module Samagotchi
 
     def outcome(result)
       case result.status
-      when :refused then "refused: it is open in a chi REPL; notes need attached mode"
+      when :refused then "refused: #{NoteDelivery::REPL_REFUSAL}"
       when :queued then "queued: its worker adds it within a few seconds"
       else "waits for the session's next start (#{result.queued} #{result.queued == 1 ? "note" : "notes"} queued)"
       end

data/lib/samagotchi/note_delivery.rb

@@ -14,6 +14,9 @@ module Samagotchi
   # note in its notes/ folder, which a live worker adds within seconds and
   # a session with no worker at its next start. Callers word the outcome.
   module NoteDelivery
+    # Why a chi REPL's session takes no note.
+    REPL_REFUSAL = "it is open in a chi REPL; notes need attached mode"
+
     # The outcome for one session.
     # @!attribute status [Symbol] :queued (a worker runs it), :waits (no
     #   worker: it waits for the next start) or :refused (a chi REPL owns it)
@@ -26,14 +29,15 @@ module Samagotchi
     module_function
 
     # @param id [String] a full session id (resolved by the caller)
+    # @param objectives [Hash, nil] an objectives note's payload
     # @return [Result]
     # @raise [SessionInbox::NoteRejected] an empty note or one over 16 KiB
-    def deliver(id, text:, source:, state_dir:, from_session: nil, from_cwd: nil)
+    def deliver(id, text:, source:, state_dir:, from_session: nil, from_cwd: nil, objectives: nil)
       owner = SessionManager.session_owner(id, state_dir: state_dir)
       return Result.new(id: id, status: :refused, queued: 0) if owner&.tui?
 
       path = SessionInbox.write_note(id, text: text, source: source, from_session: from_session, from_cwd: from_cwd,
-                                         state_dir: state_dir)
+                                         objectives: objectives, state_dir: state_dir)
       return Result.new(id: id, status: :queued, queued: 0) if owner
 
       Result.new(id: id, status: :waits, queued: SessionInbox.find_new_note_files(File.dirname(path, 2)).size)