samagotchi 0.148.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/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/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)