samagotchi 0.134.0 → 0.136.0

data/lib/samagotchi/bridge_client.rb

@@ -14,8 +14,10 @@ require_relative "bridge_client/event_stream"
 require_relative "bridge_client/stream_request"
 
 module Samagotchi
-  # Loaded on first use (a Verify turn): keeps the bundle test kit's load
-  # budget (spec/samagotchi/testing/sandbox_spec.rb).
+  # Loaded on first use (any turn's input, a Verify or a Revise turn's
+  # anchor): keeps the bundle test kit's load budget
+  # (spec/samagotchi/testing/sandbox_spec.rb).
+  autoload :TurnAnchors, File.expand_path("turn_anchors", __dir__)
   autoload :VerifyAnchor, File.expand_path("verify_anchor", __dir__)
 
   # Client side of a session worker's Bridge: the 127.0.0.1 HTTP + SSE server
@@ -192,16 +194,17 @@ module Samagotchi
     #   owner; sent only when given (SessionManager.deliver_turn)
     # @param pending_limit [Integer, nil] with a participant's +author+: how
     #   many of their turns may be running or waiting (429 too_many_turns past it)
+    # @param anchors [TurnAnchors, Hash, nil] a Verify turn's claim, a Revise
+    #   turn's draft: their own body keys ("verify", "revises")
     def post_turn(prompt:, client_id: nil, no_interrupt: false, images: nil, delivery: nil, author: nil, pending_limit: nil,
-                  verify: nil)
+                  anchors: nil)
       body = { session_id: @session_id, prompt: prompt, client_id: client_id }
       body[:no_interrupt] = true if no_interrupt
       body[:author] = author if author
       body[:pending_limit] = pending_limit if author && pending_limit
       body[:images] = images if images && !images.empty?
       body[:delivery] = delivery unless delivery.nil? || Delivery.next_step?(delivery)
-      anchor = VerifyAnchor.from(verify)
-      body[:verify] = anchor.to_file if anchor
+      body.merge!(TurnAnchors.from(anchors).to_file) if anchors
       body[:deadline] = deadline
       post("turn", body, read_body: true)
     end

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

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

data/lib/samagotchi/config.rb

@@ -330,8 +330,6 @@ module Samagotchi
       Entry.new(key: "web.port",                 yaml_path: %w[web port],                 type: :integer, default: 4567,            expose: %i[env config cli], lifecycle: :web_start),
       Entry.new(key: "web.host",                 yaml_path: %w[web host],                 type: :string, default: "127.0.0.1",     expose: %i[env config cli], lifecycle: :web_start),
       Entry.new(key: "web.markdown",             yaml_path: %w[web markdown],             type: :bool,    default: false,           expose: %i[env config cli], lifecycle: :web_start),
-      # The page's view of a turn: stage (the running turn pinned above the composer) or turn (one block of generations, the live one at the bottom); ?view= overrides it per page load.
-      Entry.new(key: "web.view",                 yaml_path: %w[web view],                 type: :enum,    default: "stage",        expose: %i[env config cli], enum_values: %w[stage turn], lifecycle: :web_start),
       # The stage view's working set (files, memories and URLs the turn brought into context): a rail in the stage, a
       # footprint under each finished turn and a "set N" chip in place of the mem chip; ?working_set=1|0 overrides it per page load.
       Entry.new(key: "web.working_set",          yaml_path: %w[web working_set],          type: :bool,    default: true,            expose: %i[env config cli], lifecycle: :web_start),

data/lib/samagotchi/engine.rb

@@ -15,6 +15,7 @@ require_relative "steer"
 require_relative "turn_note"
 require_relative "turn_endings"
 require_relative "turn_origin"
+require_relative "revise_anchor"
 require_relative "verify_anchor"
 require_relative "web/participant_view"
 require_relative "verdict"
@@ -1631,10 +1632,11 @@ module Samagotchi
       seconds = turn.elapsed
       synchronize_events do
         kept, event = yield(seconds)
-        stamp_verify_anchor(kept, turn)
+        revises = stamp_opening(kept, turn, outcome)
         replace_session_messages(turn.session, kept) if kept
         verdict = record_verdict(turn, outcome)
         event[:verdict] = verdict if verdict
+        event[:revises] = revises.to_h if revises
         emit_working_set(turn.on_event, turn.session, turn.session.messages)
         turn.session.status = Session::STATUS_IDLE
         record_last_turn(turn.session, outcome, seconds, turn.origin, event, limit: exhausted ? turn.limit : nil)
@@ -1647,16 +1649,63 @@ module Samagotchi
     end
     private :end_turn
 
-    def stamp_verify_anchor(messages, turn)
-      return unless turn.verify && messages.is_a?(Array)
+    # The turn's anchors, stamped on its opening message (the prompt, or a
+    # wake turn's note) in the messages it keeps: display metadata, never
+    # in the prompt (LLM::ChatLoop#plain keeps them, no wire sends them).
+    # A Verify turn's claim however it ended; a Revise turn's draft only
+    # once it completed with an answer (#revision_target). Returns the
+    # stamped ReviseAnchor (the end event's revises), or nil.
+    def stamp_opening(messages, turn, outcome)
+      return unless messages.is_a?(Array)
+
+      revises = revision_target(messages, turn, outcome)
+      fields = { verify: turn.verify&.to_h, revises: revises&.to_h }.compact
+      return if fields.empty?
 
       opening = messages.reverse.find do |message|
-        (message[:role] || message["role"]).to_s == "user" &&
-          (message[:turn_id] || message["turn_id"]).to_s == turn.id
+        Steer.turn_prompt?(message) && (message[:turn_id] || message["turn_id"]).to_s == turn.id
       end
-      opening[:verify] = turn.verify.to_h if opening
+      return unless opening
+
+      opening.merge!(fields)
+      revises
+    end
+    private :stamp_opening
+
+    # The turn a Revise turn revised (D6: "this turn revised that one"):
+    # only a completed turn with an answer (AnswerTail) has revised
+    # anything. A draft no prompt in the messages carries is no target (a
+    # stale page, a rolled-back turn); one a stamped turn already revised
+    # is re-targeted to its stack's top, the newest version, which the
+    # person meant ("this draft").
+    def revision_target(messages, turn, outcome)
+      return unless turn.revises && outcome == "completed"
+
+      slice = AnswerTail.turn_slice(messages, turn.id)
+      return unless slice&.any? { |message| AnswerTail.answer?(message) }
+
+      target = turn.revises.turn_id
+      seen = [turn.id]
+      until seen.include?(target)
+        return reject_revise_anchor(turn.revises, :turn_missing) unless AnswerTail.turn_slice(messages, target)
+
+        seen << target
+        newer = messages.reverse.find do |message|
+          Steer.turn_prompt?(message) && ReviseAnchor.from(message[:revises] || message["revises"])&.turn_id == target
+        end
+        return ReviseAnchor.new(turn_id: target) unless newer
+
+        target = (newer[:turn_id] || newer["turn_id"]).to_s
+      end
+      reject_revise_anchor(turn.revises, :cycle)
+    end
+    private :revision_target
+
+    def reject_revise_anchor(anchor, reason)
+      Log.warn(:turn, "revise_anchor_rejected", turn_id: anchor.turn_id, reason:)
+      nil
     end
-    private :stamp_verify_anchor
+    private :reject_revise_anchor
 
     def verified_anchor(session, anchor)
       return unless anchor
@@ -2150,8 +2199,9 @@ module Samagotchi
     # Continue that starts cold (after a model change).
     # +wall+: the wall time it started (MessageTime.now, once): the
     # :turn_started event's at and its user message's (and reminders') stamp.
+    # +verify+, +revises+: a Verify turn's claim, a Revise turn's draft.
     Turn = Struct.new(:session, :prompt, :continue, :on_event, :controller, :origin, :started_at, :messages, :ended,
-                      :settings, :id, :limit, :resumed, :resume_from, :wall, :verify) do
+                      :settings, :id, :limit, :resumed, :resume_from, :wall, :verify, :revises) do
       def resumed? = resumed ? true : false
 
       # The turn's boundary events carry the origin only when it names a
@@ -2215,6 +2265,9 @@ module Samagotchi
     # @param id [String, nil] the turn's id (a new uuid when nil): a caller
     #   that put the turn's first message in the session already (a context
     #   wake's note) names it with this id
+    # @param verify [VerifyAnchor, nil] a Verify turn's claim (its verdict)
+    # @param revises [ReviseAnchor, nil] a Revise turn's draft: stamped on
+    #   the prompt at the turn's end, metadata only (#stamp_opening)
     #
     # An Interrupt (SIGINT) cancels the turn: what it got to is kept in the
     # session as after a Stop (the prompt, the loop's finished tool
@@ -2226,9 +2279,11 @@ module Samagotchi
     # re-raises; a provider error adds error_kind:, retryable:, host: and a
     # one-line summary:.
     def run_turn(session, prompt, on_event: nil, max_iterations: nil, cancel_controller: nil, max_tool_output_chars: nil, pending_input: nil, continue: false,
-                 origin: TurnOrigin::NONE, images: [], id: nil, resumed: false, resume_from: nil, verify: nil, input_waiting: nil)
+                 origin: TurnOrigin::NONE, images: [], id: nil, resumed: false, resume_from: nil, verify: nil, revises: nil,
+                 input_waiting: nil)
       turn = begin_turn(session, prompt, on_event: on_event, cancel_controller: cancel_controller, origin: origin,
-                                         continue: continue, id: id, verify: verify, input_waiting: input_waiting)
+                                         continue: continue, id: id, verify: verify, revises: revises,
+                                         input_waiting: input_waiting)
       if continue
         turn.resumed = resumed
         turn.resume_from = resume_from
@@ -2276,7 +2331,8 @@ module Samagotchi
     # The turn's state before anything can fail it: the session running,
     # the turn flag, its cancel controller and sink. The cross-thread state
     # is set here and cleared in #release_turn only.
-    def begin_turn(session, prompt, on_event:, cancel_controller:, origin:, continue:, id: nil, verify: nil, input_waiting: nil)
+    def begin_turn(session, prompt, on_event:, cancel_controller:, origin:, continue:, id: nil, verify: nil, revises: nil,
+                   input_waiting: nil)
       origin = TurnOrigin.of(origin)
       # A participant's Verify fresh child: every turn is theirs (their
       # author, boundary and cap), whoever started it.
@@ -2304,7 +2360,8 @@ module Samagotchi
 
       Turn.new(session: session, prompt: continue ? nil : prompt, continue: continue, on_event: on_event,
                controller: effective_controller, origin: origin, started_at: Process.clock_gettime(Process::CLOCK_MONOTONIC),
-               id: id || SecureRandom.uuid, wall: MessageTime.now, verify: VerifyAnchor.from(verify))
+               id: id || SecureRandom.uuid, wall: MessageTime.now, verify: VerifyAnchor.from(verify),
+               revises: ReviseAnchor.from(revises))
     end
     private :begin_turn
 

data/lib/samagotchi/guardrail_wiring.rb

@@ -330,9 +330,10 @@ module Samagotchi
         return verdict
       end
 
-      answer = @ask.call(payload)
+      # The card and the session file carry the facts as the hash they were.
+      answer = @ask.call(payload.merge(approval: payload[:approval].to_h))
       system_one_label(judgment, answer, payload)
-      Guardrails::Approval.settle(verdict, answer, payload[:approval][:scopes])
+      Guardrails::Approval.settle(verdict, answer, payload[:approval].scopes)
     end
 
     private
@@ -391,9 +392,9 @@ module Samagotchi
       decision = system_one_decision(client, auto)
 
       id = log.judgment(session_id: @session_lookup.call&.id,
-                        rule: approval[:rule], source: approval[:source], tool: approval[:tool],
+                        rule: approval.rule, source: approval.source, tool: approval.tool,
                         **SystemOne::ApprovalQuestion.call_fields(approval),
-                        repo_name: approval[:repo_name],
+                        repo_name: approval.repo_name,
                         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.
@@ -418,12 +419,13 @@ module Samagotchi
     # 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
     # 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
     # @param targets [Guardrails::Targets, nil] the call's, for its env:
     def system_one_auto_allow?(client, approval, p, entries, targets: nil)
       return false unless client.mode == "on"
 
-      rule = approval[:rule].to_s
+      rule = approval.rule.to_s
       return false if rule.empty?
       return false unless system_one_rules.include?(rule)
       return false if SystemOne::SelfProtect.refuse?(approval, targets: targets)
@@ -456,7 +458,7 @@ module Samagotchi
       id = judgment && judgment[:id]
       return nil if id.nil?
 
-      scopes = Array(payload[:approval][:scopes])
+      scopes = Array(payload[:approval].scopes)
       if !answer.is_a?(Samagotchi::QuestionAnswer)
         label = "none"
       elsif answer.parent_agent?

data/lib/samagotchi/guardrails/approval.rb

@@ -6,6 +6,41 @@ require_relative "../question_answer"
 
 module Samagotchi
   module Guardrails
+    # An ask's facts, as Approval.payload builds them (its approval:) and
+    # the question card shows them: the tool (tool, acts_as, label), what
+    # it acts on (command, paths, args, memory), where (cwd, repo_root,
+    # repo_name, branch), who asked and why (rule, source, reason), the
+    # offered scopes, an edit's preview (EditPreview.for) and, for a
+    # participant's turn, who asks (author, author_name, asked_by).
+    #
+    # In this process it is passed as this value; it crosses to the UIs and
+    # the session file (PendingQuestion's approval) as #to_h, the hash it
+    # always was: symbol keys, in member order, unset fields left out. A
+    # saved or sent one (string or symbol keys, missing fields, a key we
+    # don't know dropped) comes back through .from_h. memory and preview
+    # stay as given (string keys inside after a load).
+    ApprovalFacts = Data.define(:tool, :acts_as, :label, :command, :paths, :args, :memory, :cwd, :repo_root,
+                                :repo_name, :branch, :rule, :source, :reason, :scopes, :preview, :author,
+                                :author_name, :asked_by) do
+      def initialize(**fields)
+        super(**members.to_h { |m| [m, nil] }, **fields)
+      end
+
+      # @param raw [ApprovalFacts, Hash, nil] facts as built, saved or sent
+      # @return [ApprovalFacts, nil] nil for anything that is not facts
+      def self.from_h(raw)
+        return raw if raw.is_a?(ApprovalFacts)
+        return nil unless raw.is_a?(Hash)
+
+        new(**members.to_h { |m| [m, raw.key?(m) ? raw[m] : raw[m.to_s]] })
+      end
+
+      # The card's and the session file's shape: symbol keys, in member
+      # order, unset fields left out.
+      # @return [Hash{Symbol => Object}]
+      def to_h = super.compact
+    end
+
     # An ask as a question for the user (Engine#open_question), and the
     # answer back as a verdict. The question text is plain and complete, so
     # a UI that doesn't know approvals still shows everything; `approval:`
@@ -42,9 +77,10 @@ module Samagotchi
       #   their turn asks: it offers once only (PARTICIPANT_SCOPES), and the
       #   card names them (approval author:, author_name:, the header)
       # @param author_name [String, nil] their name (participants.json)
-      # @return [Hash] open_question fields; its caller adds user_only:
-      #   (ParentApprovals.protected_facts? on approval:, a file that
-      #   requires this one)
+      # @return [Hash] open_question fields, with approval: an ApprovalFacts
+      #   (its caller hands open_question approval.to_h); the caller adds
+      #   user_only: (ParentApprovals.protected_facts? on approval:, a file
+      #   that requires this one)
       def payload(verdict, label: nil, preview: nil, only: nil, author: nil, author_name: nil)
         asker = asker(author, author_name)
         only = PARTICIPANT_SCOPES if asker
@@ -60,7 +96,7 @@ module Samagotchi
           allow_freeform: true,
           effects: effects(scopes),
           kind: KIND,
-          approval: {
+          approval: ApprovalFacts.new(
             tool: targets&.tool || verdict.call[:name].to_s,
             # The tool the call acts as (an MCP tool behind call_tool).
             acts_as: targets&.acts_as,
@@ -86,7 +122,7 @@ module Samagotchi
             author: (author.to_s if asker),
             author_name: (author_name_for(author_name) if asker),
             asked_by: (format(ASKED_BY, asker) if asker)
-          }.compact
+          )
         }
       end
 

data/lib/samagotchi/guardrails/implicit_writers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "shell_lex"
+
 module Samagotchi
   module Guardrails
     # Programs that write outside the folder they run in with no word of
@@ -61,9 +63,10 @@ module Samagotchi
         "gh" => [[%w[auth], %w[login logout refresh setup-git switch]], [%w[config], %w[set]],
                  [%w[extension extensions ext], %w[install upgrade remove]], [%w[alias], %w[set delete import]]],
         # the global config and a launchd/cron schedule; git lfs's global filters
-        "git" => [[%w[maintenance], %w[register start unregister stop]], [%w[lfs], %w[install uninstall]]],
+        # (git's first group is its subcommand: .git_outside?)
+        "git" => [[%w[maintenance], %w[register start unregister stop]], [%w[lfs], %w[install uninstall update]]],
         "git-maintenance" => [[%w[register start unregister stop]]],
-        "git-lfs" => [[%w[install uninstall]]],
+        "git-lfs" => [[%w[install uninstall update]]],
         "scalar" => [[%w[register unregister clone reconfigure delete]]]
       }.freeze
       # program => the verbs (its first argument) that only read: every
@@ -89,9 +92,9 @@ module Samagotchi
 
       module_function
 
-      # The table's name for +program+ (a word's basename).
+      # The table's name for +program+ (its word's ShellLex.program_name).
       def name(program)
-        base = File.basename(program.to_s)
+        base = ShellLex.program_name(program)
         ALIASES.each { |pattern, to| return to if base.match?(pattern) }
         base
       end
@@ -108,6 +111,7 @@ module Samagotchi
         return bundle_config_outside?(args) if program == "bundle" && args.first == "config"
 
         entries = BY_VERB[program] or return false
+        return git_outside?(entries, args, assigned) if program == "git"
         return false unless entries.any? { |groups| groups.all? { |group| group?(group, args, assigned) } }
         return true unless LOCAL_INSTALLERS.include?(program)
         return true if args.include?("--user")
@@ -115,6 +119,17 @@ module Samagotchi
         !(local || args.any? { |arg| arg.match?(PLACE_OPTIONS) })
       end
 
+      # git's entries match from its subcommand on (PairCommand.git_command_starts:
+      # git -C . maintenance start), the first group holding the subcommand,
+      # not its words anywhere (git add maintenance start, git commit -m lfs -m install).
+      def git_outside?(entries, args, assigned)
+        PairCommand.git_command_starts(args).grep(Integer).any? do |i|
+          entries.any? do |first, *rest|
+            first.include?(args[i]) && rest.all? { |group| group?(group, args[(i + 1)..], assigned) }
+          end
+        end
+      end
+
       def group?(group, args, assigned)
         group == :global ? global?(args, assigned) : args.intersect?(group)
       end

data/lib/samagotchi/guardrails/pair_boundary.rb

@@ -97,6 +97,8 @@ module Samagotchi
                "owner's cookies"
       LISTENER = "a participant's turn can't listen on a port: what it serves on this machine could catch the " \
                  "owner's browser cookies"
+      NET = "a participant's turn runs a command chi can't read for sure (git or chi behind a program it doesn't " \
+            "know, or a $(…) kept in a value the shell expands later), so the owner approves it"
       VERB = "a participant's turn runs only a program named plainly: no $, $(…) or glob in a command's name"
       UNREADABLE = "a participant's turn runs only commands chi can read: split this command, or write the file " \
                    "with the write tool"
@@ -195,13 +197,15 @@ module Samagotchi
 
       # Why the owner is asked (fresh, once): a command that makes a link
       # (LINK), one that runs mise or direnv (ENV_LOADER), a write to mise's
-      # config (MISE_CONFIG), a write that may land outside the project (OUTSIDE_WRITE, or
+      # config (MISE_CONFIG), a command chi can't read for sure (NET:
+      # PairCommand#net_ask?), a write that may land outside the project (OUTSIDE_WRITE, or
       # NO_PROJECT without one); nil when nothing asks.
       def ask_reason(verdict)
         targets = verdict.targets
         return LINK if targets&.command && command(targets, nil).links?
         return ENV_LOADER if targets&.command && command(targets, nil).loads_env?
         return MISE_CONFIG if mise_config_write?(verdict)
+        return NET if targets&.command && command(targets, nil).net_ask?
         return nil unless outside_write?(verdict)
 
         project_root ? OUTSIDE_WRITE : NO_PROJECT