samagotchi 0.100.1 → 0.102.0

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -9,6 +9,7 @@ require_relative "../steer_cut"
 require_relative "../memory_bundle/index_size"
 require_relative "../prompt_note"
 require_relative "../prompt_files"
+require_relative "../session_config"
 require_relative "../tools/task_record"
 require_relative "model_segments_text"
 
@@ -477,14 +478,17 @@ module Samagotchi
         end.join("\n")
       end
 
-      RECAP_OFF_TEXT = "recap is off (recap: false in config.yml, or SAMAGOTCHI_RECAP_ENABLED=false)"
+      RECAP_OFF_TEXT = "recap is off (recap: false in config.yml, or SAMAGOTCHI_RECAP_ENABLED=false; /recap on turns it on here)"
+      # Off by the session's own recap.enabled (/recap off, --set recap.enabled=false).
+      RECAP_SESSION_OFF_TEXT = "recap is off for this session (/recap on turns it on, /recap default goes back to config.yml)"
 
       # What /recap says (the REPL's words, attached mode's too): the saved
       # recap, then what came of asking for a new one.
       # @param saved [Hash, nil] {text:, turns_since:}
       # @param request [Symbol, String, nil] IdleRecap#request_now's answer
-      def recap_command_text(enabled:, saved: nil, request: nil, min_user_turns: nil)
-        return RECAP_OFF_TEXT unless enabled
+      # @param session_off [Boolean] off by the session's own setting
+      def recap_command_text(enabled:, saved: nil, request: nil, min_user_turns: nil, session_off: false)
+        return session_off ? RECAP_SESSION_OFF_TEXT : RECAP_OFF_TEXT unless enabled
 
         saved = saved&.transform_keys(&:to_sym)
         lines = []
@@ -640,6 +644,9 @@ module Samagotchi
         # A chat host's only: a native one ignores it (the summary is nil).
         history = setting_stats_text(snapshot[:reasoning_history])
         lines << "reasoning history: #{history}" if history
+        # The session's own settings (chi --set; JSON keys from a worker).
+        settings = snapshot[:settings]
+        lines << "settings:         #{SessionConfig.text(settings)}" if settings.is_a?(Hash) && !settings.empty?
         if snapshot[:served_model]
           asked = snapshot[:served_model_for]
           differs = !snapshot[:served_expected_by] && ServedModel.differs?(asked, snapshot[:served_model])

data/lib/samagotchi/terminal_ui.rb

@@ -102,7 +102,7 @@ module Samagotchi
     # @param toolkit [Toolkit, nil] --toolkit/--tool/--no-tool: a new
     #   session's toolkit (config's toolkit.default without); a resumed one
     #   keeps its own, with a line naming +toolkit_flags+ (the flags given)
-    # @param bundle_settings [Hash] --set's values (BundleSessionSettings):
+    # @param settings [SessionConfig::Settings, nil] --set's values:
     #   a new session's own; a resumed one keeps its own (--set is in
     #   +toolkit_flags+ then)
     # @param parent_answers [String, nil] --parent-answers: a new session's
@@ -110,12 +110,12 @@ module Samagotchi
     #   +toolkit_flags+ then)
     def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
                    spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil,
-                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], bundle_settings: {}, parent_answers: nil)
+                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], settings: nil, parent_answers: nil)
       @scratch        = scratch
       @parent_answers = parent_answers
       @toolkit        = toolkit
       @toolkit_flags  = toolkit_flags
-      @bundle_settings = bundle_settings
+      @session_settings = settings
       @thinking_word  = thinking
       @prompt         = prompt
       @llm_context_words = llm_context
@@ -227,7 +227,7 @@ module Samagotchi
       @turn_flow = TurnFlow.new(engine: @engine)
       # A recap written while a continue offer waits says the turn stopped
       # unfinished. (Answering at the prompt is typing: activity already.)
-      @engine.recap&.awaiting_continue = -> { @turn_flow.awaiting_continue? }
+      @engine.recap_awaiting_continue = -> { @turn_flow.awaiting_continue? }
       @commands = SessionCommands.new(engine: @engine, turn_flow: @turn_flow, default_model: @default_model_name,
                                       registry: @engine.command_registry)
       # Runtime --model flag or resumed session: switch the Engine (client,
@@ -285,7 +285,7 @@ module Samagotchi
         muted_memory_names: @muted_memory_names,
         scratch: @scratch,
         setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files, toolkit: @toolkit || Toolkit.configured,
-                                bundle_settings: @bundle_settings, parent_answers: @parent_answers)
+                                settings: @session_settings, parent_answers: @parent_answers)
       ))
       # --llm-context*: the session's own values, over a resumed one's.
       # Saved at once on a resumed one: leaving before a turn keeps them.
@@ -890,6 +890,8 @@ module Samagotchi
           show_command_result(command)
           refresh_status_row(clear_unknown_context: true) if command.changed.include?(:model)
           refresh_status_row if command.changed.include?(:title)
+          # /recap on|off|default doesn't save itself (a worker saves a changed command).
+          save_session(session) if command.changed.include?(:recap)
           persist_recent_history(input) if command.shell
           return
         end
@@ -1180,7 +1182,7 @@ module Samagotchi
     # chat moved on (it prints when it arrives, BetweenTurns#flush_recap).
     def handle_recap_command
       recap = @engine.recap
-      return recap_command_text(enabled: false) unless recap
+      return recap_command_text(enabled: false, session_off: @engine.recap_override == false) unless recap
 
       saved = @engine.saved_recap
       request = @engine.turn_running? ? :busy : @engine.request_recap

data/lib/samagotchi/testing/bundle.rb

@@ -429,9 +429,10 @@ module Samagotchi
       #   of another type than it gives the key
       def setup_with(session_settings, setup)
         values = { @name => stringify(session_settings) }
-        BundleSessionSettings.check!(values, bundles: { @name => @manifest.session_settings },
+        SessionConfig.check!(values, bundles: { @name => @manifest.session_settings },
                                              types: { @name => @manifest.session_setting_types }, flag: "session_settings")
-        (setup || SessionSetup.new).with(bundle_settings: values)
+        setup ||= SessionSetup.new
+        setup.with(settings: setup.settings.with(bundles: values))
       end
 
       def stringify(value) = Sandbox.stringify(value)

data/lib/samagotchi/testing/fake_executable.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require "tmpdir"
 
 module Samagotchi
   module Testing
     # Fake commands for a test's PATH (Sandbox#fake_executable), cheap to
     # exec: macOS checks a new executable file on its first exec (about
-    # 0.5–1 s, once per file). A fake is a symlink to one launcher, made
-    # once per process, that runs the fake's body (<name>.sh beside the
-    # link) with /bin/sh: writing a new body costs nothing.
+    # 0.5–1 s, once per file; minutes on a busy machine). A fake is a
+    # symlink to the checked-in launcher, which runs the fake's body
+    # (<name>.sh beside the link) with /bin/sh: writing a new body costs
+    # nothing.
     module FakeExecutable
-      LAUNCHER = "#!/bin/sh\nexec /bin/sh \"$0.sh\" \"$@\"\n"
+      LAUNCHER = File.expand_path("fake_executable_launcher", __dir__)
 
       module_function
 
@@ -26,17 +26,7 @@ module Samagotchi
         path
       end
 
-      def launcher
-        @launcher ||= begin
-          dir = Dir.mktmpdir("chi-fake-exec")
-          owner = Process.pid
-          at_exit { FileUtils.rm_rf(dir) if Process.pid == owner }
-          File.join(dir, "launcher").tap do |path|
-            File.write(path, LAUNCHER)
-            File.chmod(0o755, path)
-          end
-        end
-      end
+      def launcher = LAUNCHER
     end
   end
 end

data/lib/samagotchi/testing/fake_executable_launcher

@@ -0,0 +1,6 @@
+#!/bin/sh
+# What every FakeExecutable (and spec/support/fake_executables.rb) fake
+# links to: runs the fake's body, <link>.sh, with /bin/sh. Checked in, not
+# written per process: macOS scans a just-written executable at its first
+# exec, which under a busy run can stall for minutes.
+exec /bin/sh "$0.sh" "$@"

data/lib/samagotchi/tool_response.rb

@@ -10,10 +10,11 @@ module Samagotchi
   module ToolResponse
     SEPARATOR = "\n\n---\n\n"
     # Saved with a result for the web's reload (a plugin tool's params line,
-    # label and row refs, an edit/write's diff) and for the LLMContextView (each
+    # label and row refs, an edit/write's diff), for the LLMContextView (each
     # run's chi-owned id, ToolIds, and a strategy's edits by id,
-    # LLMContextEdit); the prompt never renders them.
-    SAVED_KEYS = %i[tool_params tool_labels tool_diffs tool_refs tool_ids edits].freeze
+    # LLMContextEdit) and for WorkingSet (a file run's stamp, ToolRun#stamp);
+    # the prompt never renders them.
+    SAVED_KEYS = %i[tool_params tool_labels tool_diffs tool_refs tool_ids tool_stamps edits].freeze
     # The tools a chat result loaded (#single), saved with it.
     LOADED = :loaded
     # A run's "[name]" lead: the name, then a newline, a space or the end.
@@ -84,7 +85,7 @@ module Samagotchi
         entry[:image_counts] = runs.map { |run| Array(run.images).size }
       end
       saved = { tool_params: runs.map(&:shown_params), tool_labels: runs.map(&:shown_label),
-                tool_diffs: runs.map(&:diff), tool_refs: runs.map(&:refs) }
+                tool_diffs: runs.map(&:diff), tool_refs: runs.map(&:refs), tool_stamps: runs.map(&:stamp) }
       saved.each { |key, values| entry[key] = values if values.any? }
       entry[:tool_ids] = ids
       entry
@@ -92,8 +93,10 @@ module Samagotchi
 
     # The chat loop's entry for one call: its capped output, paired with the
     # call by +tool_call_id+, and its chi-owned id (a one-id +ids+, as
-    # #joined's tool_ids); a find_tools hit's +loaded+ names (saved on every
-    # chat backend: a wire that loads tools renders them, LLM::AnthropicWire).
+    # #joined's tool_ids) and its stamp (a one-stamp tool_stamps, likewise:
+    # read by the run's place); a find_tools hit's +loaded+ names (saved on
+    # every chat backend: a wire that loads tools renders them,
+    # LLM::AnthropicWire).
     def single(run, tool_call_id:, ids:)
       entry = { role: "tool_response", content: run.capped_output, tool_call_id: tool_call_id }
       entry[:images] = run.images if run.images&.any?
@@ -102,6 +105,7 @@ module Samagotchi
       entry[:tool_diffs] = run.diff if run.diff
       entry[:tool_refs] = run.refs if run.refs
       entry[:tool_ids] = ids
+      entry[:tool_stamps] = [run.stamp] if run.stamp
       entry[LOADED] = run.loaded if run.loaded&.any?
       entry
     end

data/lib/samagotchi/tool_runner.rb

@@ -3,6 +3,7 @@
 require_relative "tool_activity"
 require_relative "tool_row_fields"
 require_relative "row_refs"
+require_relative "file_ref"
 require_relative "guardrails"
 require_relative "vision_context"
 require_relative "log"
@@ -18,12 +19,14 @@ module Samagotchi
   # One call's result from ToolRunner#run, read by ToolResponse (the loops'
   # tool_response entries) and the loops' activity list. Fields a call didn't
   # produce (images, shown_params, shown_label, refs, diff, output_file,
-  # loaded) are nil. +loaded+: the tools a find_tools hit loads
-  # (Tools::ToolIndex::FoundText#loaded), by their wire names.
+  # loaded, stamp) are nil. +loaded+: the tools a find_tools hit loads
+  # (Tools::ToolIndex::FoundText#loaded), by their wire names. +stamp+: an
+  # ok read/edit/write's file right after it ran ({path:, mtime_ns:,
+  # size:}), what WorkingSet tells a file changed since by.
   ToolRun = Data.define(:output, :capped_output, :truncated, :activity, :images, :shown_params, :shown_label, :refs, :diff,
-                        :output_file, :loaded) do
+                        :output_file, :loaded, :stamp) do
     def initialize(output: nil, capped_output: nil, truncated: nil, activity: nil, images: nil, shown_params: nil,
-                   shown_label: nil, refs: nil, diff: nil, output_file: nil, loaded: nil)
+                   shown_label: nil, refs: nil, diff: nil, output_file: nil, loaded: nil, stamp: nil)
       super
     end
   end
@@ -153,11 +156,27 @@ module Samagotchi
                   images: images&.any? ? images : nil,
                   shown_params: params && plugin_tool?(call[:name]) ? params : nil,
                   shown_label: label, refs: refs.empty? ? nil : refs, diff: diff, output_file: output_file,
-                  loaded: result[:loaded])
+                  loaded: result[:loaded], stamp: status == "ok" ? file_stamp(call) : nil)
     end
 
     private
 
+    # An ok read/edit/write's file as it is now, right after the call:
+    # {path:, mtime_ns:, size:}, the path as FileRef has it (against the
+    # session's folder, no realpath). nil for any other tool, a path it
+    # can't place and a stat that fails or isn't a file's.
+    def file_stamp(call)
+      ref = FileRef.for(call[:name], call, cwd: session_cwd)
+      return nil unless ref
+
+      stat = File.stat(ref.path)
+      return nil unless stat.file?
+
+      { path: ref.path, mtime_ns: (stat.mtime.to_i * 1_000_000_000) + stat.mtime.nsec, size: stat.size }
+    rescue SystemCallError
+      nil
+    end
+
     # +output+ cut to +cap+ by its tool's policy (ToolOutputCut); an
     # execute result keeps its tail too, its whole output saved in the
     # session's folder.
@@ -310,7 +329,7 @@ module Samagotchi
     # The session's folder (the Engine's, KernelLoop#session_cwd), else the
     # process's: a bare kernel (specs) has none.
     def session_cwd
-      cwd = @kernel.respond_to?(:session_cwd) && @kernel.session_cwd&.call
+      cwd = @kernel.session_cwd&.call if @kernel.respond_to?(:session_cwd)
       cwd.to_s.empty? ? Dir.pwd : cwd
     end
 

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.100.1"
+  VERSION = "0.102.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -25,6 +25,7 @@ require_relative "../session_commands"
 require_relative "../steer"
 require_relative "../host_registry"
 require_relative "../llm_context_override"
+require_relative "../working_set"
 require_relative "../model_catalog"
 require_relative "../model_profile"
 require_relative "../session_setting"
@@ -97,6 +98,8 @@ module Samagotchi
       #   freshly-spawned worker's bridge before answering POST /api/sessions.
       # @param view ["stage", "turn"] the page's view of a turn (web.view);
       #   ?view=stage|turn overrides it for one page load
+      # @param working_set [Boolean] the stage view's working set
+      #   (web.working_set); ?working_set=1|0 overrides it for one page load
       # @param annotate_presets [String, Array] the quick replies next to
       #   Annotate (web.annotate_presets, "|"-separated); "" shows none. The
       #   page parses them (annotate_presets.js).
@@ -119,7 +122,8 @@ module Samagotchi
                      annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
                      editor: Config::BY_KEY["web.editor"].default,
                      events_heartbeat: EVENTS_HEARTBEAT, events_queue: EVENTS_QUEUE,
-                     registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT, lan: nil)
+                     registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT, lan: nil,
+                     working_set: Config::BY_KEY["web.working_set"].default)
         @manager = manager || SessionManager
         @registry = registry
         @registry_given = !registry.nil?
@@ -132,6 +136,7 @@ module Samagotchi
         @bridge_wait_timeout = bridge_wait_timeout
         @markdown_renderer = MarkdownRenderer.new(enabled: markdown)
         @view = view
+        @working_set = working_set
         @annotate_presets = annotate_presets.is_a?(Array) ? annotate_presets.join("|") : annotate_presets.to_s
         @editor_url = Editor.template(editor)
         @hub = hub
@@ -183,6 +188,7 @@ module Samagotchi
         ["GET", %r{\A/api/sessions/([^/]+)/context/([^/]+)\z}, :handle_context_show, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/context\z}, :handle_context_add, :session],
         ["DELETE", %r{\A/api/sessions/([^/]+)/context/([^/]+)\z}, :handle_context_delete, :session],
+        ["GET", %r{\A/api/sessions/([^/]+)/working_set\z}, :handle_working_set, :session],
         ["GET", %r{\A/api/sessions/([^/]+)\z}, :handle_show, :session],
         ["DELETE", %r{\A/api/sessions/([^/]+)\z}, :handle_delete, :session]
       ].freeze
@@ -664,13 +670,13 @@ module Samagotchi
         thinking, error = request_thinking(body["thinking"])
         return error if error
 
-        # bundle_settings: the session's own bundle settings (chi --set:
-        # {bundle => {key => scalar}}), checked against the installed
-        # bundles the same way.
+        # settings: the session's own settings, flat as chi --set names
+        # them ({"recap.enabled" => false, "cost-cap.cap" => 3}), checked
+        # the same way (SessionConfig.from_request).
         begin
-          bundle_settings = BundleSessionSettings.from_request(body["bundle_settings"])
-        rescue BundleSessionSettings::Error => e
-          return error_response(400, "invalid_bundle_settings", e.message)
+          settings = SessionConfig.from_request(body["settings"])
+        rescue SessionConfig::Error => e
+          return error_response(400, "invalid_settings", e.message)
         end
 
         folder = dir ? { working_directory: dir } : {}
@@ -683,7 +689,7 @@ module Samagotchi
         # until that turn is saved.
         preview = idle ? body["preview"].to_s.strip : ""
         folder[:preview] = preview unless preview.empty?
-        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking, bundle_settings: bundle_settings)
+        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking, settings: settings)
         folder[:setup] = setup unless setup.empty?
         begin
           session = @manager.spawn_session(prompt: idle ? nil : prompt.to_s, state_dir: @state_dir, **folder)
@@ -703,7 +709,7 @@ module Samagotchi
       # POST /api/sessions with continues: <id, prefix or last:id>: the next
       # link of that session's chain (SessionManager.continue_session), in its
       # folder and with its own setup (SessionSetup: llm_context, thinking
-      # and reasoning_history levels, bundle settings), so dir, llm_context, thinking and bundle_settings are
+      # and reasoning_history levels, settings), so dir, llm_context, thinking and settings are
       # refused beside it (a create takes no reasoning_history). It runs on
       # model (or model_name) when given, else on the previous link's: one
       # whose host is gone falls back to the default, and the 201's
@@ -718,9 +724,9 @@ module Samagotchi
         unless given.is_a?(String) && !given.strip.empty?
           return error_response(400, "invalid_continues", "continues is a session id")
         end
-        if (fields = %w[dir llm_context thinking bundle_settings].select { |key| body.key?(key) }).any?
+        if (fields = %w[dir llm_context thinking settings].select { |key| body.key?(key) }).any?
           return error_response(400, "invalid_continues",
-                                "continues takes the previous session's folder, llm_context, thinking and bundle_settings; " \
+                                "continues takes the previous session's folder, llm_context, thinking and settings; " \
                                 "leave out #{fields.join(", ")}")
         end
 
@@ -1477,6 +1483,53 @@ module Samagotchi
         error_response(409, e.reason.to_s, "#{e.message}; try again in a moment")
       end
 
+      # ── The working set (web.working_set) ───────────────────────────────
+
+      # 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 ctx chip'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).
+      def handle_working_set(_req, id)
+        session = @session_class.load(id, state_dir: default_state_dir)
+        live = bridge_get_json(id, "snapshot")
+        running = !live&.dig("snapshot", "current_turn").nil?
+        turn_set = running && running_working_set(live["snapshot"]["working_set"])
+        return json_response(200, turn_set.merge(running: true)) if turn_set
+
+        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
+        snapshot = WorkingSet.build(messages, cwd: session.working_directory, strategy: working_set_strategy(llm_context))
+        json_response(200, snapshot.to_h.merge(running: running))
+      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 strategy an llm ctx chip 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
+
       # ── Attached context (ContextSources): the session bar's chips ───────
       # A source's command isn't shown (the page may be on a phone over the
       # LAN), and the web adds a URL only, through an installed bundle's
@@ -2126,6 +2179,8 @@ module Samagotchi
         # the one serving now (an upgraded chi web after a reconnect).
         attrs = { "sessions-dir" => sessions_dir_label, "server-dir" => home_label(Dir.pwd), "version" => Samagotchi::VERSION }
         attrs["view"] = view_name(req.params["view"])
+        # Only when on: the page reads its presence (the turn view ignores it).
+        attrs["working-set"] = "1" if working_set?(req.params["working_set"])
         # Always there: an empty one means no presets, not the default.
         attrs["annotate-presets"] = @annotate_presets
         dir, = scope_dir(req.params["dir"])
@@ -2154,6 +2209,16 @@ module Samagotchi
         VIEWS.include?(param) ? param : @view
       end
 
+      # The working set for this page load: ?working_set=1|0 wins, anything
+      # else leaves the config's choice (web.working_set).
+      def working_set?(param)
+        case param
+        when "1" then true
+        when "0" then false
+        else @working_set
+        end
+      end
+
       def json_response(status, payload)
         body = JSON.generate(payload)
         [status, { "Content-Type" => "application/json; charset=utf-8", "Content-Length" => body.bytesize.to_s, "Cache-Control" => "no-store" }, [body]]

data/lib/samagotchi/web/public/app.js

@@ -21,6 +21,7 @@ import {
   detachContext,
   addContext,
   renderText,
+  getWorkingSet,
 } from "./data.js";
 import { createContextChips } from "./context_chips.js";
 import { createLlmContextControl } from "./llm_context_chip.js";
@@ -37,6 +38,8 @@ import { elementOf, emptyAnswerTemplate } from "./turn_html.js";
 import { createBubbles, hintEl, outputBubbleTemplate } from "./bubbles.js";
 import { createCardsPlace } from "./cards_place.js";
 import { createStageView } from "./stage_view.js";
+import { createWorkingSet, groupItems } from "./working_set_view.js";
+import { turnGroups } from "./timing.js";
 import { createMarkdownPlace } from "./markdown_place.js";
 import { openerFill, openTitle, restoredComposer } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
@@ -225,10 +228,23 @@ const markdownPlace = createMarkdownPlace({
   answerRefsOf,
 });
 const { renderMarkdown, pairRefsIn, linkRefsIn, applyFinalMarkdown, linkTextRefs } = markdownPlace;
+// The stage view's working set (web.working_set, or ?working_set=1|0):
+// what each turn brought into context, in a rail in the stage, a footprint
+// under each finished turn and a "set N" chip in the mem chip's place
+// (working_set_view.js). The turn view ignores it.
+const workingSet = view === "stage" && document.body.dataset.workingSet === "1"
+  ? createWorkingSet({
+    historyEl, stageRoot: () => turnDom.root, state: () => current, session: () => selected, infoEl: infoTextEl,
+    onChange: () => updateInfoBar(), getWorkingSet,
+    // A drop or undrop from the list: the session's command, as typed.
+    sendLine: (line) => (selected ? sendCommand(selected, line, { clientId }) : null),
+  })
+  : null;
+document.body.classList.toggle("working-set", !!workingSet);
 const turnDom = view === "stage"
   ? createStageView({
     ...viewArgs, isNearBottom: () => atHistoryEnd(), dockEl: $("#dock"), centerEl: $("#center"), composerEl,
-    renderMarkdown, linkRefs: linkRefsIn,
+    renderMarkdown, linkRefs: linkRefsIn, workingSet,
   })
   : createTurnView(viewArgs);
 // The history's bottom reserve and the toast's place follow the composer
@@ -862,6 +878,7 @@ function renderSessionView(data, { kept = [] } = {}) {
   reasoningHistoryControl.refresh();
   if (data.messages && data.messages.length) renderHistory(data.messages);
   else renderHistory(data.history || []);
+  seedWorkingSet(data);
   restoreCommandBubbles(historyEl, kept);
   // A failed turn's prompt went back to the user: shown after the
   // conversation, marked failed, as it was live (prompt_restored).
@@ -921,13 +938,27 @@ function renderSessionView(data, { kept = [] } = {}) {
   updateComposerMode();
 }
 
+// The working set's turns from a session's messages, as turnHistoryNodes
+// numbers them; the running turn (the replay draws it in the stage) isn't
+// one of them yet.
+function seedWorkingSet(data) {
+  if (!workingSet) return;
+  const items = data.messages || [];
+  const groups = typeof items[0] === "object" && items[0]?.role ? turnGroups(items, current.timing).filter((g) => g.kind === "turn") : [];
+  if (data.current_turn && groups.length) groups.pop();
+  workingSet.seed(groups.map((g, i) => {
+    const text = String(items[g.user]?.content ?? "").replace(/\s+/g, " ").trim();
+    return { items: groupItems(g, i), prompt: text.length > 60 ? `${text.slice(0, 59)}\u2026` : text };
+  }));
+}
+
 function renderHistory(items) {
   if (!items.length) {
     historyEl.replaceChildren(hintEl("No output yet. Send a message."));
     return;
   }
   if (typeof items[0] === "object" && items[0].role) {
-    historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsTemplate(selected, images) }));
+    historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsTemplate(selected, images), workingSet: !!workingSet }));
     linkTextRefs();
   } else {
     historyEl.replaceChildren(...items.map((c) => elementOf(outputBubbleTemplate(c))));
@@ -1088,7 +1119,7 @@ function updateInfoBar() {
   const { buttons, bar } = sessionBar({
     id: selected, state: current, sessions: allSessions, versions, cardTitle: (s) => lists.cardTitle(s),
     continuing: sessionActions.continuing, restarting: restartingIds, streaming: !!streamControl, running: liveTurn.running,
-    now: Date.now(),
+    now: Date.now(), workingSet: workingSet ? workingSet.chip() : undefined,
   });
   const stopBtn = document.getElementById("infoStopBtn");
   const deleteBtn = document.getElementById("infoDeleteBtn");
@@ -1269,6 +1300,7 @@ const streamHandlers = createStreamHandlers({
   llmContextControl,
   thinkingControl,
   reasoningHistoryControl,
+  workingSet,
   sentIds,
   earlyRestores,
   stream: {