samagotchi 0.170.0 → 0.171.0

data/lib/samagotchi/web/session_show.rb

@@ -17,9 +17,26 @@ require_relative "../session_metrics"
 require_relative "../session_setting"
 require_relative "../system_one/log"
 require_relative "../toolkit"
+require_relative "viewer"
 
 module Samagotchi
   module Web
+    # What a session's show is read from, the same for the owner's and a
+    # participant's (SessionShow#show_reads): the session file, a live
+    # worker's turn snapshot and state snapshot (both nil without one), the
+    # messages shown (the snapshot's, else the file's) and the stream cursor
+    # the page goes on from (+event_seq+, and the snapshot's +event_id+
+    # `<seq>-<epoch>`). Each assembler makes its own payload from it.
+    ShowReads = Data.define(:id, :session, :turn_snapshot, :state, :event_seq, :event_id, :raw_messages) do
+      # The turn in progress, as the worker's snapshot has it (nil: none).
+      def current_turn = turn_snapshot && turn_snapshot["current_turn"]
+
+      def current_turn_id
+        turn = current_turn
+        turn.is_a?(Hash) ? turn["turn_id"] : nil
+      end
+    end
+
     # GET /api/sessions/:id, the page's session read, and its light re-reads
     # (?cards=1, ?tail=1, ?timing=1; ?brief=1 is SessionAccessRoutes'
     # handle_brief_read), GET /api/sessions/:id/output, and the timing
@@ -33,7 +50,7 @@ module Samagotchi
       private
 
       def handle_show(req, id)
-        return participant_show(id) unless principal(req).owner?
+        return participant_show_read(req, id) unless principal(req).owner?
 
         # The page's light re-reads: never the whole conversation.
         return handle_cards_read(id) if req.params["cards"] == "1"
@@ -46,35 +63,59 @@ module Samagotchi
         # (The light re-reads come after a full read only.)
         return scratch_refused(id) if session.scratch
 
-        # Read-only preview: selecting a session never spawns a worker.
-        # The worker is woken only on POST /turn (handle_turn) via
-        # SessionManager.resume_session + write_turn_input. This avoids
-        # replaying last_prompt and spamming workers on preview scrub.
-        # last_event_seq is nil when no live bridge, so the frontend stays
-        # silent until the first Send.
-        #
-        # A live worker's snapshot is the truth (the session file lags its
-        # Engine): the messages, the turn in progress and the prompts queued
-        # behind it, all at one event_seq the client streams on from.
+        owner_show(req, show_reads(id, session))
+      end
+
+      # The reads a session's show is made of, whoever it is for (ShowReads).
+      # Read-only preview: selecting a session never spawns a worker.
+      # The worker is woken only on POST /turn (handle_turn) via
+      # SessionManager.resume_session + write_turn_input. This avoids
+      # replaying last_prompt and spamming workers on preview scrub.
+      # event_seq is nil when no live bridge, so the frontend stays
+      # silent until the first Send.
+      #
+      # A live worker's snapshot is the truth (the session file lags its
+      # Engine): the messages, the turn in progress and the prompts queued
+      # behind it, all at one event_seq the client streams on from.
+      # @return [ShowReads]
+      def show_reads(id, session)
         live = bridge_get_json(id, "snapshot")
         turn_snapshot = live && live["snapshot"]
-        snapshot = live && live["session_state_snapshot"]
-        last_event_seq = live_or_saved(snapshot, "event_seq") { bridge_event_seq(id) }
-        current_turn = turn_snapshot && turn_snapshot["current_turn"]
+        state = live && live["session_state_snapshot"]
+        ShowReads.new(
+          id: id, session: session, turn_snapshot: turn_snapshot, state: state,
+          event_seq: live_or_saved(state, "event_seq") { bridge_event_seq(id) },
+          # The stream cursor `<seq>-<epoch>`: a later worker resets it
+          # instead of taking the seq as its own. Only the snapshot has it.
+          event_id: turn_snapshot && turn_snapshot["event_id"],
+          raw_messages: live_or_saved(turn_snapshot, "messages") { session.messages }
+        )
+      end
+
+      # Every finished turn of +reads+ drawn from a line (a real one, else
+      # one made from its messages, #drawn_lines): its items are stamped,
+      # and its drawing goes in turn_drawings. The running turn has none yet.
+      def show_drawn_lines(reads, timing:, entries:)
+        drawn_lines(reads.id, reads.raw_messages, timing: timing, entries: entries, cwd: reads.session.working_directory,
+                                                  skip_turn_id: reads.current_turn_id)
+      end
+
+      # The owner's show of +reads+: the whole page's read (its cards,
+      # history, commands, recap, timing and question too).
+      def owner_show(req, reads)
+        id = reads.id
+        session = reads.session
+        turn_snapshot = reads.turn_snapshot
+        raw_messages = reads.raw_messages
         owner = session_owner(id)
         pending = shown_pending_question(session, turn_snapshot, owner)
         # What the worker's server said it served for that model (after a turn);
         # without a worker, what the session's analytics.json last saved.
-        persisted = snapshot ? nil : read_analytics(id)
-        session_json = shown_session_json(session, snapshot, owner, persisted)
-        raw_messages = live_or_saved(turn_snapshot, "messages") { session.messages }
-        timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"], persisted: persisted)
-        # Every finished turn is drawn from a line (a real one, else one
-        # made from its messages): its items are stamped, and its drawing
-        # goes in turn_drawings. The running turn has none yet.
+        persisted = reads.state ? nil : read_analytics(id)
+        session_json = shown_session_json(session, reads.state, owner, persisted)
+        timing = timing_payload(id, live_metrics: reads.state && reads.state["metrics"], persisted: persisted)
         raw_cards = live_or_saved(turn_snapshot, "cards") { saved_cards(id, messages: raw_messages) }
-        drawn = drawn_lines(id, raw_messages, timing: timing, entries: raw_cards, cwd: session.working_directory,
-                                              skip_turn_id: current_turn.is_a?(Hash) ? current_turn["turn_id"] : nil)
+        drawn = show_drawn_lines(reads, timing: timing, entries: raw_cards)
         messages = messages_for_display(raw_messages, cwd: session.working_directory, drawings: drawn)
         json_response(200, {
           session: session_json,
@@ -82,7 +123,7 @@ module Samagotchi
           messages: messages,
           **turn_drawings_field(drawn, messages),
           failed_turn: failed_turn_for(session, raw_messages),
-          current_turn: current_turn,
+          current_turn: reads.current_turn,
           # The page's join: the turn in progress and the queue behind it as
           # the live events that draw them (TurnAccumulator.join_events, one
           # unfold, here: any worker's snapshot works).
@@ -104,11 +145,11 @@ module Samagotchi
           markdown_warning: @markdown_renderer.warning,
           markdown_tip: @markdown_renderer.tip,
           **viewer_capabilities(req),
+          # Who looks and what they may do (Viewer), as <body> says it at boot.
+          viewer: Viewer.for(principal(req)).to_h,
           pending_question: pending,
-          last_event_seq: last_event_seq,
-          # The stream cursor `<seq>-<epoch>`: a later worker resets it
-          # instead of taking the seq as its own. Only the snapshot has it.
-          last_event_id: turn_snapshot && turn_snapshot["event_id"],
+          last_event_seq: reads.event_seq,
+          last_event_id: reads.event_id,
           timing: timing,
           **objectives_field(id, raw_messages, turn_snapshot)
         })
@@ -231,6 +272,12 @@ module Samagotchi
                                             served_expected_by: snapshot["served_expected_by"])
           # The model notes its prompt carries now (a /model there changes them).
           session_json = session_json.merge(prompt_notes: snapshot["prompt_notes"]) if snapshot["prompt_notes"].is_a?(Array)
+          # The newest context estimate the worker has (a turn in flight: the
+          # last request's), so a page opened mid-turn shows the percent at
+          # once. Owner show only: a participant's show is ParticipantView's
+          # allowlist. A snapshot without the key (an older worker) sends
+          # nothing, so its page reads as it always did.
+          session_json = session_json.merge(context_status: snapshot["context_status"]) if snapshot.key?("context_status")
         else
           session_json = session_json.merge(saved_served_model(session, persisted))
         end

data/lib/samagotchi/web/viewer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../client_id"
+
+module Samagotchi
+  module Web
+    # Who looks at chi web's main page and what they may do there: the
+    # page draws a control, and makes a call, only when +can+ names its
+    # capability (viewer.js; docs/internals/web-frontend.md, The viewer).
+    # Not Web::Capabilities: that one says what the page renders (markdown
+    # display) and whether this request's viewer can open a path in this
+    # machine's editor; this one says which of the owner's controls this
+    # viewer gets at all. The page reads it from <body> at boot
+    # (App#index_data_attributes, #body_data) and from a show's +viewer+.
+    #
+    # +kind+ "owner" | "participant"; +id+ and +name+ a participant's grant's
+    # (nil for the owner); +can+ the frozen list of capability names.
+    Viewer = Data.define(:kind, :id, :name, :can) do
+      # @param principal [Principal] the request's
+      # @return [Viewer] the owner's with every capability; a participant's
+      #   with PARTICIPANT_CAPABILITIES only (what their routes serve).
+      def self.for(principal)
+        return Viewer::OWNER if principal.owner?
+
+        grant = principal.grant
+        new(kind: "participant", id: grant.id, name: grant.name, can: Viewer::PARTICIPANT_CAPABILITIES)
+      end
+
+      def owner? = kind == "owner"
+
+      # The client id chi web gives this viewer's turns (it replaces the
+      # body's): a participant's review:<grant id> (ClientId.review), so the
+      # page can tell its own turns; nil for the owner (each tab names its own).
+      def client_id = owner? ? nil : ClientId.review(id)
+
+      def can?(name) = can.include?(name.to_s)
+
+      # The <body> data attributes the page reads at boot: the kind and the
+      # space-separated +can+ list (no names or ids: those come with a show).
+      def body_attributes = { "viewer-kind" => kind, "viewer-can" => can.join(" ") }
+
+      # A participant's carries their client id too.
+      def to_h = { kind: kind, id: id, name: name, can: can, **(owner? ? {} : { client_id: client_id }) }
+    end
+
+    # The capabilities the main page gates by, each named for what the
+    # owner does with it (the page's controls and calls behind each one:
+    # docs/internals/web-frontend.md, The viewer).
+    Viewer::CAPABILITIES = %w[
+      sessions models prompt_history push context working_set working_set_items participants_admin rename images
+      session_controls revise apply answer_cards render block_renderers stop_any_turn steer_any_turn
+    ].freeze
+
+    # A participant's capabilities: names of their own (the owner's are
+    # CAPABILITIES), each one a participant route serves. +send+: their
+    # composer (POST …/turn); +stop_own_turn+: the stage's Stop turn on a
+    # turn they started (POST …/cancel with its turn_id); +steer_own_turn+:
+    # a message sent while their own turn runs goes in at its next step
+    # (a worker with Delivery::OWN_TURN_STEER_FEATURE); +revise_own_turn+:
+    # Revise on the answer to their own message with only their own turns
+    # after it (POST …/turn with revises, ParticipantRevise). And of the owner's,
+    # those a participant's route serves filtered: +working_set+ (GET
+    # …/working_set, the project's files only) and +images+ (POST …/images
+    # within their cap and quota; GET …/images/<name> only for an image
+    # they uploaded; their turn takes only those: ParticipantImages).
+    Viewer::PARTICIPANT_CAPABILITIES = %w[send stop_own_turn steer_own_turn revise_own_turn working_set images].freeze
+
+    Viewer::OWNER = Viewer.new(kind: "owner", id: nil, name: nil, can: Viewer::CAPABILITIES)
+  end
+end

data/lib/samagotchi/web/working_set_routes.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../working_set"
+require_relative "../llm_context_view"
+require_relative "../session_setting"
+require_relative "../memory_paths"
+require_relative "participant_view"
+
+module Samagotchi
+  module Web
+    # The working set's routes (web.working_set), mixed into App. See
+    # docs/internals/working-set.md (Delivery).
+    module WorkingSetRoutes
+      # What a working-set build reads off a session: its +messages+ (symbol
+      # keys at the top, as paired_runs reads them), the +strategy+ its
+      # llm_context summary names, its folder (+cwd+) and its +pins+.
+      Source = Data.define(:messages, :strategy, :cwd, :pins)
+
+      private
+
+      # GET /api/sessions/:id/working_set: the working set as the model has
+      # it ({items:, at:, running:}, WorkingSet), what the page overlays on its rows'
+      # set when it seeds a session's and when the expanded view opens (a
+      # file changed while the session sat idle). A live worker's snapshot
+      # messages are the truth, as #handle_show's, else the file's; the
+      # strategy is the session's llm_context summary's, the folder its working
+      # directory. running: a turn runs. The snapshot's messages lag it, so
+      # the answer is then the turn's last :working_set_updated (the
+      # snapshot's working_set, TurnAccumulator#working_set); before the
+      # turn emitted one, or from an older worker without the field, it is
+      # the session's messages, behind that turn's events, and the page
+      # keeps theirs (working_set.js newerSnapshot).
+      # A participant's is filtered (ParticipantView.working_set: the
+      # project's files only).
+      def handle_working_set(req, id)
+        session = @session_class.load(id, state_dir: default_state_dir)
+        set = working_set_payload(id, session)
+        return json_response(200, set) if principal(req).owner?
+
+        viewer = participant_viewer(req, session)
+        # Redacted as the stream's event is (ParticipantView.event): a file name may hold a secret's shape.
+        shown = Redact.deep(ParticipantView.working_set(set, viewer), viewer)
+        json_response(200, shown.merge("running" => set[:running] == true))
+      end
+
+      # GET /api/sessions/:id/working_set/item?kind=&key=[&now=1]: what the
+      # model has of one item, its timeline (WorkingSet.timeline_of: every
+      # run of it, in conversation order), the reader's and the popover
+      # peek's. Owner only. Always built from messages, unlike the set's
+      # route: the worker's snapshot messages (they lag a running turn's
+      # events; the page asks again on its next :working_set_updated), else
+      # the file's. Whole texts: the tool limits bound them (read's
+      # truncate_at_bytes, the ToolRunner cap). +now+ (a memory): what its
+      # latest read would answer now and the diff (WorkingSet.memory_now).
+      def handle_working_set_item(req, id)
+        kind = req.params["kind"].to_s
+        key = req.params["key"].to_s
+        unless [WorkingSet::FILE, WorkingSet::MEMORY, WorkingSet::URL].include?(kind) && !key.strip.empty?
+          return error_response(400, "invalid_item", "expected kind (file, memory or url) and key")
+        end
+
+        session = @session_class.load(id, state_dir: default_state_dir)
+        source = working_set_source(bridge_get_json(id, "snapshot"), session)
+        timeline = WorkingSet.timeline_of(source.messages, kind: kind, key: key, strategy: source.strategy, cwd: source.cwd)
+        body = timeline.to_h
+        if req.params["now"] == "1" && kind == WorkingSet::MEMORY
+          body[:now] = WorkingSet.memory_now(source.messages, key: key, strategy: source.strategy, cwd: source.cwd,
+                                             root: MemoryPaths.system_dir)&.to_h
+        end
+        json_response(200, body)
+      end
+
+      def working_set_payload(id, session)
+        live = bridge_get_json(id, "snapshot")
+        worker_snapshot = live && live["snapshot"]
+        running = !worker_snapshot&.dig("current_turn").nil?
+        turn_set = running && running_working_set(live["snapshot"]["working_set"])
+        return turn_set.merge(running: true) if turn_set
+
+        idle_set = idle_working_set(worker_snapshot && worker_snapshot["idle_working_set"]) unless running
+        return idle_set.merge(running: false) if idle_set
+
+        source = working_set_source(live, session)
+        snapshot = WorkingSet.build(source.messages, cwd: source.cwd, strategy: source.strategy, pins: source.pins)
+        snapshot.to_h.merge(running: running)
+      end
+
+      # What a build from messages reads (+live+: the worker's Bridge
+      # snapshot answer, nil without a worker): the worker's snapshot
+      # messages, as #handle_show reads them, else the file's; the strategy
+      # the worker's llm_context summary names, else the saved chip's.
+      # @return [Source]
+      def working_set_source(live, session)
+        messages = live_or_saved(live && live["snapshot"], "messages") { session.messages }
+        # A snapshot's entries have string keys (paired_runs reads symbols).
+        messages = Array(messages).map { |message| message.is_a?(Hash) ? message.transform_keys(&:to_sym) : message }
+        llm_context = SessionSetting::LLM_CONTEXT.snapshot_value(live && live["session_state_snapshot"]) do
+          SessionSetting::LLM_CONTEXT.saved_summary(session, registry: host_registry)
+        end
+        Source.new(messages: messages, strategy: working_set_strategy(llm_context), cwd: session.working_directory,
+                   pins: session.working_set_pins)
+      end
+
+      # The running turn's set from a worker's snapshot ({"items", "at"}), as
+      # {items:, at:}; nil when it has none (none emitted yet, an older worker).
+      def running_working_set(set)
+        return nil unless set.is_a?(Hash) && set["items"].is_a?(Array) && set["at"].is_a?(Integer)
+
+        { items: set["items"], at: set["at"] }
+      end
+
+      # The worker's between-turns working set ({"items", "at", optional
+      # "adds"}); nil for an older or malformed snapshot.
+      def idle_working_set(set)
+        return nil unless set.is_a?(Hash) && set["items"].is_a?(Array) && set["at"].is_a?(Integer)
+        return nil if set.key?("adds") && !set["adds"].is_a?(Array)
+
+        { items: set["items"], at: set["at"] }.tap do |snapshot|
+          snapshot[:adds] = set["adds"] if set.key?("adds")
+        end
+      end
+
+      # The strategy an llm_context summary names ("none", "stale,forget"), as
+      # LLMContextView takes it; none when there is no chip.
+      def working_set_strategy(llm_context)
+        named = llm_context.is_a?(Hash) ? (llm_context[:strategy] || llm_context["strategy"]).to_s : ""
+        layers = named.split(",").map(&:strip).reject { |layer| layer.empty? || layer == "none" }
+        layers.empty? ? LLMContextView::NONE : layers.map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/samagotchi/worker.rb

@@ -1412,8 +1412,9 @@ module Samagotchi
       @turn_enqueued_id = origin.enqueued_id
       verdicts_before = @session.verdicts.size
       @reporting_turn = reports_to_parent?(origin)
-      # A participant's review turn merges no input (#pending_input_drain).
-      @participant_turn = origin.participant?
+      # Who wrote the running turn (a participant's author, nil for the
+      # owner's): its drain merges only their own lines (#pending_input_drain).
+      @turn_author = origin.participant_author
       restores = @turn_flow.restores
       begin
         @checkpoint.begin_turn(prompt: prompt, turn_id: turn_args[:id], enqueued_id: origin.enqueued_id, author: turn_author_fields(origin))
@@ -1603,15 +1604,12 @@ module Samagotchi
         # one (steering merges text only): skipped here, not a barrier, so a
         # line sent after it still goes in at this boundary. Only the files
         # claimed below reach @merged_this_turn and the checkpoint.
-        # A participant's review turn takes none: the owner's lines (the
-        # Bridge queues them, this covers a file it didn't see) run as the
-        # owner's own turns after it, never inside its review boundary.
-        files = if @participant_turn
-                  []
-                else
-                  SessionInbox.find_new_input_files(@session_dir).sort
-                              .reject { |input_file| SessionInbox.waits_for_turn_end?(input_file) }
-                end
+        # A participant's turn takes only their own lines: the owner's and
+        # anyone else's (the Bridge queues them, this covers a file it didn't
+        # see) run as their own turns after it, never inside its boundary;
+        # and the owner's turn takes no participant's (SessionInbox.turn_end_data?).
+        files = SessionInbox.find_new_input_files(@session_dir).sort
+                            .reject { |input_file| SessionInbox.waits_for_turn_end?(input_file, running_author: @turn_author) }
         merged = files.filter_map do |input_file|
           claimed_file = SessionInbox.claim_input_file(input_file)
           next unless claimed_file
@@ -1624,6 +1622,13 @@ module Samagotchi
               next
             end
             begin
+              # A participant's line gets the checks their queued turn gets at
+              # its start (#participant_refusal: the link, the cap): refused,
+              # it is taken off as that turn would be, and never merged.
+              if (author = input.origin.participant_author) && (reason = participant_refusal(author))
+                refuse_participant_turn(input.origin, reason)
+                next
+              end
               prompt = input.prompt.to_s.strip
               # Which turn took it, on disk before its file goes (a wait for
               # it reads this, not an inference: ReplyWait::Poll#follow_merge).
@@ -1660,10 +1665,10 @@ module Samagotchi
     end
 
     # Whether a person's message waits that the next boundary merges
-    # (SessionInbox.steer_waiting?): a running task_wait ends on it. Never
-    # in a participant's turn, whose drain merges none.
+    # (SessionInbox.steer_waiting?): a running task_wait ends on it. In a
+    # participant's turn only their own.
     def input_waiting?
-      !@participant_turn && SessionInbox.steer_waiting?(@session_dir)
+      SessionInbox.steer_waiting?(@session_dir, running_author: @turn_author)
     end
 
     # A participant's author fields (Engine#author_fields), {} for the owner.