samagotchi 0.156.0 → 0.158.0

data/lib/samagotchi/web/app.rb

@@ -17,6 +17,7 @@ require_relative "../delivery"
 require_relative "../answer_tail"
 require_relative "../answer_refs"
 require_relative "../question_asked"
+require_relative "../project_init"
 require_relative "../bridge_client"
 require_relative "../worker_link"
 require_relative "../bridge/bounded_queue"
@@ -27,6 +28,7 @@ require_relative "../session_metrics"
 require_relative "../session_commands"
 require_relative "../steer"
 require_relative "../host_registry"
+require_relative "../effective_model"
 require_relative "../llm_context_override"
 require_relative "../working_set"
 require_relative "../model_catalog"
@@ -75,6 +77,7 @@ require_relative "session_show"
 require_relative "session_create"
 require_relative "session_control"
 require_relative "verify_fresh_routes"
+require_relative "reload_check_route"
 require_relative "push_routes"
 require_relative "block_renderer_routes"
 require_relative "update_check"
@@ -109,6 +112,7 @@ module Samagotchi
       include SessionCreate
       include SessionControl
       include VerifyFreshRoutes
+      include ReloadCheckRoute
       include PushRoutes
       include BlockRendererRoutes
       include ProxyGate
@@ -146,6 +150,9 @@ module Samagotchi
       #   freshly-spawned worker's bridge before answering POST /api/sessions.
       # @param working_set [Boolean] the stage view's working set
       #   (web.working_set); ?working_set=1|0 overrides it for one page load
+      # @param reload_check [Boolean] the page checks each finished turn
+      #   against a reload of it and posts the counts (web.reload_check,
+      #   opt-in; POST /api/sessions/:id/reload_check logs them)
       # @param annotate_presets [String, Array] the quick replies next to
       #   Annotate (web.annotate_presets, "|"-separated); "" shows none. The
       #   page parses them (annotate_presets.js).
@@ -184,6 +191,7 @@ module Samagotchi
                      events_heartbeat: EVENTS_HEARTBEAT, events_queue: EVENTS_QUEUE,
                      registry: nil, models_wait_timeout: MODELS_WAIT_TIMEOUT, lan: nil,
                      working_set: Config::BY_KEY["web.working_set"].default, wait_poll_interval: ReplyWait::POLL_INTERVAL,
+                     reload_check: Config::BY_KEY["web.reload_check"].default,
                      grants: nil, public_url: nil, public_token: nil, push: nil, start_dir: nil, update_runner: nil,
                      update_blocked: nil, update_ops: nil)
         @start_dir = start_dir
@@ -199,6 +207,8 @@ module Samagotchi
         @bridge_wait_timeout = bridge_wait_timeout
         @markdown_renderer = MarkdownRenderer.new(enabled: markdown)
         @working_set = working_set
+        @reload_check = reload_check
+        @reload_checks = ReloadCheckRoute::Seen.new
         @annotate_presets = annotate_presets.is_a?(Array) ? annotate_presets.join("|") : annotate_presets.to_s
         @editor_url = Editor.template(editor)
         @hub = hub
@@ -259,6 +269,7 @@ module Samagotchi
         ["GET", %r{\A/(?:index\.html)?\z}, :serve_index, :participant],
         ["GET", %r{\A/api/sessions\z}, :handle_list, :owner],
         ["GET", %r{\A/api/projects\z}, :handle_projects, :owner],
+        ["POST", %r{\A/api/projects\z}, :handle_project_create, :owner],
         ["POST", %r{\A/api/sessions\z}, :handle_create, :owner],
         ["GET", %r{\A/api/sessions/resolve\z}, :handle_resolve, :participant],
         ["GET", %r{\A/api/sessions/summaries\z}, :handle_summaries, :owner],
@@ -292,6 +303,7 @@ module Samagotchi
         ["GET", %r{\A/api/sessions/([^/]+)/worker\z}, :handle_worker, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/exit\z}, :handle_exit, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/recap\z}, :handle_recap, :owner, :session],
+        ["POST", %r{\A/api/sessions/([^/]+)/reload_check\z}, :handle_reload_check, :owner, :session],
         ["POST", %r{\A/api/sessions/([^/]+)/guardrails/wrong\z}, :handle_system_one_wrong, :owner, :session],
         ["GET", %r{\A/api/sessions/([^/]+)/stats\z}, :handle_stats, :owner, :session],
         ["GET", %r{\A/api/sessions/([^/]+)/children/counts\z}, :handle_children_counts, :owner, :session],
@@ -996,6 +1008,39 @@ module Samagotchi
         json_response(200, ProjectList.build(@hub.snapshot, start_dir: start_dir, current_root: current_root))
       end
 
+      def handle_project_create(req)
+        body = parse_json(request_body(req))
+        return error_response(400, "invalid_json", "invalid JSON body") unless body.is_a?(Hash)
+
+        requested = body["dir"]
+        requested = requested.strip if requested.is_a?(String)
+        unless requested.is_a?(String) && !requested.empty? && !requested.include?("\0")
+          return error_response(400, "invalid_dir", "dir must be an absolute folder")
+        end
+
+        home = Dir.home
+        dir = if requested == "~"
+                home
+              elsif requested.start_with?("~/")
+                File.join(home, requested.delete_prefix("~/"))
+              else
+                requested
+              end
+        return error_response(400, "invalid_dir", "dir must be an absolute folder") unless dir.start_with?("/")
+
+        # One normal form for the decision, the mkdir and the realpath (a `..` after a symlink would differ).
+        dir = File.expand_path(dir)
+        outcome = ProjectInit.call(dir, home: home)
+        return error_response(422, outcome.reason.to_s, outcome.message) if outcome.kind == :refused
+
+        if outcome.kind == :git
+          failed = ProjectInit.ensure_folder(dir)
+          return error_response(422, failed.reason.to_s, failed.message) if failed
+        end
+        dir = File.realpath(dir)
+        json_response(200, outcome: outcome.kind.to_s, root: outcome.root, dir: dir)
+      end
+
       # A scope folder from the page: [dir, nil] (dir nil when none was
       # given), or [nil, a 400 response] when it isn't an existing absolute
       # folder (a bookmarked worktree deleted since, a typo).
@@ -1157,30 +1202,29 @@ module Samagotchi
 
           settings = ModelSettings.all
           models.each do |model|
-            target = registry.resolve(model[:name])
-            names = registry.lookup_names(model[:name], target: target)
-            summary = SamplingSettings.summary(target, names: names, models: settings)
+            effective = EffectiveModel.of(registry, ModelChoice.new(name: model[:name], typed: model[:name]), models: settings)
+            summary = SamplingSettings.summary(effective.lookup)
             model[:sampling] = summary if summary
-            add_llm_context(model, target, names, settings)
-            add_thinking(model, target, names, settings)
+            add_llm_context(model, effective)
+            add_thinking(model, effective)
           end
         end
       end
 
       # The LLM context +model+ starts under (the start page's ⚙ panel);
-      # one that can't be read leaves this model without, not the others.
-      def add_llm_context(model, target, names, settings)
-        Degrade.call(:web, "model_llm_context_unreadable") do
-          model[:llm_context] = LLMContextStrategy.explain(target, names: names, models: settings).summary(nil)
-        end
+      # one that can't be read leaves this model without (the key absent),
+      # not the others.
+      def add_llm_context(model, effective)
+        explained = effective.llm_context_explained({})
+        model[:llm_context] = explained.summary(nil) if explained
       end
 
       # The thinking level +model+ starts at, with where it came from (the
-      # start page's ⚙ panel; SettingExplained#summary, no session).
-      def add_thinking(model, target, names, settings)
-        Degrade.call(:web, "model_thinking_unreadable") do
-          model[:thinking] = Thinking.explain(target, names: names, models: settings).summary
-        end
+      # start page's ⚙ panel; SettingExplained#summary, no session); one
+      # that can't be read leaves this model without (the key absent).
+      def add_thinking(model, effective)
+        explained = effective.thinking_explained(own: nil)
+        model[:thinking] = explained.summary if explained
       end
 
       # The served model a session's last generation reported (analytics.json,
@@ -1210,17 +1254,16 @@ module Samagotchi
         end
       end
 
-      # Built again when config.yml's hosts: changed (compared as read: the
-      # YAML read is mtime-cached), so the model picker lists a host added
+      # The shared registry (HostRegistry.current: built again when
+      # config.yml's hosts: changed), so the model picker lists a host added
       # while chi web runs. An injected registry (specs) stays.
       def host_registry
         @models_mutex.synchronize do
           next @registry if @registry_given
 
-          hosts = HostConfig.all
-          if @registry.nil? || hosts != @registry_hosts
-            @registry = HostRegistry.new(hosts_config: hosts)
-            @registry_hosts = hosts
+          current = HostRegistry.current
+          unless current.equal?(@registry)
+            @registry = current
             @models_thread = nil # a listing of the old hosts
           end
           @registry
@@ -1905,6 +1948,8 @@ module Samagotchi
         attrs["home"] = Dir.home
         # Only when on: the page reads its presence.
         attrs["working-set"] = "1" if working_set?(req.params["working_set"])
+        # The opt-in reload check (reload_check.js): only when on.
+        attrs["reload-check"] = "1" if @reload_check
         attrs.merge!(annotate_presets_data)
         dir, = scope_dir(req.params["dir"])
         unless dir

data/lib/samagotchi/web/message_display.rb

@@ -9,12 +9,14 @@ require_relative "../message_parts"
 require_relative "../message_time"
 require_relative "../objectives"
 require_relative "../output_formatter"
+require_relative "../recap_place"
 require_relative "../recap_store"
 require_relative "../ref"
 require_relative "../revise_anchor"
 require_relative "../steer"
 require_relative "../turn_note"
 require_relative "../bridge/card_store"
+require_relative "../bridge/turn_drawings"
 
 module Samagotchi
   module Web
@@ -47,20 +49,26 @@ module Samagotchi
       # a live worker's (it counts against its Engine's messages), else
       # recap.json against the session file. A stopped session gets its
       # recap without a worker being woken.
-      # @return [Hash, nil] {text:, turns_since:, created_at:} (created_at:
-      #   when it was written, UTC ISO; absent from an older recap)
+      # The last turn it covers names its place (opening_id, RecapPlace);
+      # an older worker's saved_recap has none: the page counts turns_since.
+      # @return [Hash, nil] {text:, turns_since:, opening_id:, created_at:}
+      #   (created_at: when it was written, UTC ISO; absent from an older
+      #   recap)
       def saved_recap_for(id, session, turn_snapshot)
         if turn_snapshot
           saved = turn_snapshot["saved_recap"]
-          return saved && { text: saved["text"], turns_since: saved["turns_since"].to_i, created_at: saved["created_at"] }.compact
+          return saved && { text: saved["text"], turns_since: saved["turns_since"].to_i, opening_id: saved["opening_id"],
+                            created_at: saved["created_at"] }.compact
         end
 
         saved = RecapStore.read(@session_class.session_dir(id, state_dir: default_state_dir))
         return nil unless saved
 
         messages = Array(session.messages)
-        since = messages.drop(saved[:covered].to_i).count { |m| Samagotchi::Steer.turn_opening?(m) }
-        { text: saved[:text], turns_since: since, created_at: saved[:created_at] }.compact
+        covered = saved[:covered].to_i
+        since = messages.drop(covered).count { |m| Samagotchi::Steer.turn_opening?(m) }
+        { text: saved[:text], turns_since: since, opening_id: RecapPlace.opening_id(messages, covered),
+          created_at: saved[:created_at] }.compact
       rescue StandardError
         nil
       end
@@ -91,14 +99,22 @@ module Samagotchi
       # @param markdown [Boolean] false: no html for a delegate report or an
       #   answer (the participant review drops both and renders its replies
       #   from their redacted text, ParticipantReview#with_reply_html)
-      def messages_for_display(msgs, parts: false, cwd: nil, markdown: true)
+      # @param drawings [Array<Bridge::TurnDrawings::Line>] the valid lines
+      #   (TurnDrawings.valid against +msgs+): each item of a kind a drawing
+      #   draws (#drawn_kind?) from a line's range gets `drawn: <turn_id>`
+      # @param strip_drawn [Boolean] a stamped item's parts go (the drawing
+      #   has them); it keeps its ✂ marks as `marks: {tool_id => edit}`
+      def messages_for_display(msgs, parts: false, cwd: nil, markdown: true, drawings: [], strip_drawn: false)
         filtered = []
         list = Array(msgs)
+        # Each item's message index, for the drawings' stamps.
+        origins = []
         # The outputs' ✂ marks (LLM context edits), by id, for the parts.
         marks = parts ? MessageParts.edit_marks(list) : {}
         # The list before each objectives note, for what its entry says changed.
         objectives = nil
         list.each_with_index do |m, index|
+          origins.fill(index - 1, origins.size...filtered.size)
           role = (m[:role] || m["role"]).to_s
           content = (m[:content] || m["content"]).to_s
           if Samagotchi::ContextNote.note?(m)
@@ -205,11 +221,45 @@ module Samagotchi
           message[:parts] = did if did
           filtered << message
         end
-        filtered
+        origins.fill(list.size - 1, origins.size...filtered.size)
+        stamp_drawn(filtered, origins, Array(drawings), strip: strip_drawn)
       rescue StandardError
         []
       end
 
+      # +items+ with a drawn turn's stamp on each item of a kind its drawing
+      # draws (the opening, steps, steers, merged lines, the empty answer):
+      # a context note, a `!cmd`'s record and anything else keep today's
+      # place. +origins+: each item's message index.
+      def stamp_drawn(items, origins, drawings, strip:)
+        return items if drawings.empty?
+
+        items.each_with_index.map do |item, i|
+          line = drawings.find { |l| l.range.cover?(origins[i]) }
+          next item unless line && drawn_kind?(item)
+
+          stamped = item.merge(drawn: line.turn_id)
+          strip ? without_parts(stamped) : stamped
+        end
+      end
+
+      def drawn_kind?(item)
+        case item[:role]
+        when "note" then item[:turn_start] == true
+        when "user" then !(item[:turn_id].nil? && item[:content].match?(/\A!\(.*\)\n/))
+        else %w[assistant steer empty_answer].include?(item[:role])
+        end
+      end
+
+      # A drawn item without its parts: its ✂ marks by output id stay (an
+      # overlay on the drawing's rows: later state, as a card's latest body).
+      def without_parts(item)
+        tools = Array(item.dig(:parts, :tools))
+        marks = tools.filter_map { |tool| [tool[:tool_id], tool[:edit]] if tool[:tool_id] && tool[:edit] }.to_h
+        out = item.except(:parts)
+        marks.empty? ? out : out.merge(marks: marks)
+      end
+
       # A turn opening's Revise stamp as {revises: {turn_id:}}, checked again
       # (a stored file is never trusted), or nothing.
       def revises_of(message)

data/lib/samagotchi/web/participant_access.rb

@@ -395,7 +395,7 @@ module Samagotchi
       # send --wait, D11): only for a turn of theirs (+turn+, the enqueued
       # id their POST …/turn answered); the body's busy, queue and created
       # don't count. The answer is what their wait on that turn needs
-      # (SendCommand's WaitTarget.after with the turn asked, the wait's
+      # (ReplyWait::Target.wait_only with the turn asked, the wait's
       # baseline), never the owner's wait state: the last turn's end (the
       # baseline's last_turn), whether their turn is known, whether a worker
       # runs it, and last_turn_id only when it is their turn. No cursor

data/lib/samagotchi/web/project_list.rb

@@ -6,8 +6,8 @@ require_relative "push/attention"
 
 module Samagotchi
   module Web
-    # Projects represented by the session hub, plus the start project even
-    # when it has no sessions.
+    # Projects represented by the session hub, plus the start and current
+    # projects even when they have no sessions.
     module ProjectList
       module_function
 
@@ -24,6 +24,7 @@ module Samagotchi
           (groups[root] ||= []) << summary
         end
         groups[default_root] ||= [] if valid_root?(default_root)
+        groups[current_root] ||= [] if valid_root?(current_root)
 
         rows = groups.map do |root, sessions|
           default = root == default_root

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

@@ -50,8 +50,11 @@ export function newActivity() {
 //   refs: a plugin tool's refs (the server's RowRefs: [{kind, target,
 //     label?, actions}]): the first on the row's title, the others in its
 //     menu (refs.js bindRowRefs).
+//   tool_id: the id the call's output is saved under (the server's ToolIds,
+//     "t41"; not a row field there), so a row names the output a reload's
+//     part and a strategy's edit name.
 export const ACTIVITY_FIELDS = Object.freeze(["title", "called_as", "via"]);
-export const EVENT_FIELDS = Object.freeze(["view", "ref", "refs"]);
+export const EVENT_FIELDS = Object.freeze(["view", "ref", "refs", "tool_id"]);
 const ROW_FIELDS = Object.freeze([...ACTIVITY_FIELDS, ...EVENT_FIELDS]);
 
 // The +fields+ of +source+ that are set, as an object (for a spread).
@@ -115,10 +118,10 @@ function markStart(row, event, now) {
 
 // Update (or synthesize) a row from a :tool_call_completed event. Returns the row.
 // If no matching :tool_call_started was seen (e.g. a replay gap), a row is
-// created on the fly so the completion is never lost. Its duration
-// (duration_ms, as a reloaded row has it from the tool record): a
-// snapshot's own, else from the start the page saw to +now+, less the time
-// the call waited for an approval (waited_ms), as the worker times it.
+// created on the fly so the completion is never lost. Its duration: the
+// event's duration_ms (the worker's, the figure a reload's tool record and
+// the terminal show), else (an older worker) from the start the page saw to
+// +now+, less the time the call waited for an approval (waited_ms).
 export function addCompleted(model, event = {}, now = null) {
   const iteration = event.iteration ?? 0;
   const callIndex = event.call_index ?? 0;
@@ -137,8 +140,10 @@ export function addCompleted(model, event = {}, now = null) {
     row = synthesized.row;
   }
   row.status = completedStatus(event.activity?.status);
-  row.output = event.output || "";
-  row.output_truncated = !!event.output_truncated;
+  // A long output's web cut (the worker's preview: the text a reload's row
+  // has from the saved output), else the output itself.
+  row.output = event.preview ?? (event.output || "");
+  row.output_truncated = event.preview != null || !!event.output_truncated;
   if (event.activity?.params) row.params = event.activity.params;
   // The completed event carries the title (ACTIVITY_FIELDS) in its activity.
   Object.assign(row, pickFields(event.activity, ACTIVITY_FIELDS));
@@ -160,6 +165,10 @@ export function addCompleted(model, event = {}, now = null) {
   // What an edit/write changed in its file (a reload draws it from the
   // saved parts, turn_html.js toolRowTemplate).
   if (event.diff) row.diff = event.diff;
+  // An LLM context edit's ✂ mark on its output, later state a drawn turn's
+  // row takes from its saved item (turn_block.js drawnTurnNodes); no live
+  // event carries one.
+  if (event.edit) row.edit = event.edit;
   const duration = callDuration(row, event, now);
   if (duration !== null) row.duration_ms = duration;
   return row;

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

@@ -53,6 +53,7 @@ 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 { createReloadCheck } from "./reload_check.js";
 import { createWorkingSet, groupItems } from "./working_set_view.js";
 import { createObjectives } from "./objectives_wiring.js";
 import { turnGroups } from "./timing.js";
@@ -356,6 +357,17 @@ const turnDom = createStageView({
   workingSet,
   // Stop turn in its status row (disabled until the request settles).
   onCancel: () => handleCancel(),
+  onHandedOff: (handed) => reloadCheck.handedOff(handed),
+});
+// The opt-in reload check (web.reload_check): a handed-off turn against a
+// reload of it, the counts to chi web (reload_check.js).
+const reloadCheck = createReloadCheck({
+  enabled: () => document.body.dataset.reloadCheck === "1",
+  sessionId: () => store.selected,
+  running: () => liveTurn.running,
+  read: (id) => getSession(id, { parts: true }),
+  render: (data) => turnHistoryNodes(data.messages || [], normalizeTiming(data.timing), historyOpts(data)),
+  post: (id, body) => api(`/api/sessions/${id}/reload_check`, { method: "POST", body: JSON.stringify(body) }),
 });
 // The history's bottom reserve and the toast's place follow the composer
 // card and the stage floating over the history (dock_reserve.js).
@@ -1001,7 +1013,7 @@ function renderSessionView(data, { kept = [] } = {}) {
   });
   liveTurn.timing.ended = store.current.timing.turnRecords.length;
   const activeTurnId = store.current.timing.activeTurn?.id || null;
-  if (data.messages && data.messages.length) renderHistory(data.messages);
+  if (data.messages && data.messages.length) renderHistory(data.messages, data);
   else renderHistory(data.history || []);
   seedWorkingSet(data);
   objectives.seed(data.objectives);
@@ -1029,9 +1041,12 @@ function renderSessionView(data, { kept = [] } = {}) {
   // The recap saved with the session (also a stopped one's), else a live
   // worker's from before saved_recap existed. After the cards: the last
   // turn's check-in notice goes to the end, and the recap closes the page.
-  if (data.saved_recap) showRecap(data.saved_recap.text, data.saved_recap.turns_since, data.saved_recap.created_at || null);
+  const saved = data.saved_recap;
+  if (saved) showRecap(saved.text, saved.turns_since, saved.created_at || null, saved.opening_id || null);
   else showRecap(data.recap);
-  const replay = snapshotEvents({
+  // chi web's unfold of the join (TurnAccumulator.join_events); the page's
+  // own only for a mixed cache (an older chi web's payload has none).
+  const replay = data.replay ?? snapshotEvents({
     current_turn: data.current_turn,
     queued: data.queued,
     queued_commands: data.queued_commands,
@@ -1048,7 +1063,8 @@ function renderSessionView(data, { kept = [] } = {}) {
     turnDom.runningWithoutTurn?.(liveTurn.running);
     if (liveTurn.running && store.current.timing.activeTurn?.started_at) liveTurn.timing.start(store.current.timing.activeTurn.started_at, activeTurnId);
   } else if (liveTurn.running) {
-    // The replayed turn_started carries no id: the running turn's record's.
+    // The live line's turn: the running turn's record's (the replayed
+    // turn_started carries the same id, on both unfolds).
     liveTurn.timing.turnId = activeTurnId;
   }
   turnDom.flush();
@@ -1079,7 +1095,7 @@ function renderSessionView(data, { kept = [] } = {}) {
 function seedWorkingSet(data) {
   if (!workingSet) return;
   const items = data.messages || [];
-  const groups = typeof items[0] === "object" && items[0]?.role ? turnGroups(items, store.current.timing).filter((g) => g.kind === "turn") : [];
+  const groups = typeof items[0] === "object" && items[0]?.role ? turnGroups(items, store.current.timing, { drawings: data.turn_drawings }).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();
@@ -1087,17 +1103,22 @@ function seedWorkingSet(data) {
   }));
 }
 
-function renderHistory(items) {
+// turnHistoryNodes' options for a read's +data+: its turns' drawings
+// (turn_drawing.js) and cards (a drawn card's body).
+const historyOpts = (data = {}) => ({ thumbs: (images) => thumbsTemplate(store.selected, images), workingSet: !!workingSet,
+  drawings: data.turn_drawings || null, cards: data.cards || null, capabilities: pageCapabilities });
+
+function renderHistory(items, data = {}) {
   gapClock.seed(null);
   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, store.current.timing, { thumbs: (images) => thumbsTemplate(store.selected, images), workingSet: !!workingSet }));
+    historyEl.replaceChildren(turnHistoryNodes(items, store.current.timing, historyOpts(data)));
     ownerVerify.renderSaved();
     // The live dividers count from the history's last activity.
-    gapClock.seed(lastActivity(turnGroups(items, store.current.timing), items));
+    gapClock.seed(lastActivity(turnGroups(items, store.current.timing, { drawings: data.turn_drawings }), items));
     linkTextRefs();
   } else {
     historyEl.replaceChildren(...items.map((c) => elementOf(outputBubbleTemplate(c))));

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

@@ -4,7 +4,8 @@
 // notices, plugins' steers, command and note bubbles. The markup is lit
 // (turn_html.js elementOf); createBubbles puts them in the history.
 import { html, nothing } from "./vendor/lit-html.js";
-import { fullTime, normalize, recapLabel, recapPlace } from "./format.js";
+import { fullTime, normalize, recapLabel } from "./format.js";
+import { recapStampPlace } from "./recap_stamp.js";
 import { BADGES, elementOf, noteBubbleTemplate, stateBadgeTemplate, steerRowTemplate, userBubbleTemplate } from "./turn_html.js";
 import { thumbsTemplate } from "./images.js";
 import { appendAboveLiveTiming, STOPPED_LINE_CLASS } from "./timing.js";
@@ -254,14 +255,16 @@ export function createBubbles({
   // the end of the history. A turn starting leaves it in place, marked
   // earlier; only a new recap replaces it.
 
-  function showRecap(text, turnsSince = 0, createdAt = null) {
+  // +openingId+: a saved recap's stamp, the last turn it covers (its place;
+  // without one, +turnsSince+ counts it).
+  function showRecap(text, turnsSince = 0, createdAt = null, openingId = null) {
     if (!text) return;
     removeRecap();
     const details = elementOf(recapTemplate(text, turnsSince, createdAt));
     // A stale one sits where it was written, above the turns it doesn't cover.
     // Never in the stage: a recap is between turns.
     turnDom.settleFold();
-    const prompt = recapPlace(turnPromptBubbles(historyEl), turnsSince);
+    const prompt = recapStampPlace(turnPromptBubbles(historyEl), openingId, turnsSince);
     // Above that turn's gap divider too: the recap was written before the quiet stretch ended. The
     // snapshot's cards placed at that prompt (placed first) sit between the divider and the prompt.
     // A delegate report's fold row (answer_fold.js) heads its prompt.
@@ -314,6 +317,8 @@ export function createBubbles({
     // Page-only: kept across a resync of this session (keptCommandBubbles).
     const id = selected();
     if (id) div.dataset.keptFor = id;
+    // A reminder's: the turn it went into (restoreCommandBubbles).
+    if (view.turnId) div.dataset.turnId = view.turnId;
     drawCommandBubble(div, view);
     // When it happened (a reminder's at): the hover, as a reload's bubbles.
     const when = fullTime(view.at);

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

@@ -92,6 +92,14 @@ export function createCardsPlace({
   function placeSnapshotCards(entries, { before: end = null } = {}) {
     const users = turnPromptBubbles(historyEl);
     for (const entry of entries) {
+      // A drawn turn's own card or row is in its drawing, where live drew it
+      // (turn_block.js drawnTurnNodes): only its body refreshes, by id. Its
+      // question is still placed from here.
+      if (drawnEntry(entry)) {
+        const el = isCard(entry) ? cardElement(entry.id) : null;
+        if (el) refreshCardBody(el, entry);
+        continue;
+      }
       const before = snapshotPlace(users, entry) || (entry.after_failed ? null : end);
       if (isCard(entry)) upsertCard(entry, { before });
       else if (entry.type === "question") placeResolvedQuestion(entry, before);
@@ -101,6 +109,13 @@ export function createCardsPlace({
     }
   }
 
+  // An in-turn entry (not a question) of a turn the history drew from its
+  // drawing (its pieces carry data-drawn; the entry's of_turn, CardStore's).
+  function drawnEntry(entry) {
+    if (!entry?.in_turn || entry.type === "question" || typeof entry.of_turn !== "string") return false;
+    return [...historyEl.querySelectorAll("[data-drawn]")].some((el) => el.dataset.drawn === entry.of_turn);
+  }
+
   // A finished turn's row, a hook's notice or the loop's asking again
   // (+before+: the next turn's prompt, or null for the last turn): a row of
   // its step, above the row of the call it came before, as live; else (a

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

@@ -268,11 +268,15 @@ export function keptCommandBubbles(historyEl, id) {
     .filter(({ el }) => keepsCommandBubble(el.querySelector(":scope > .command-line")?.textContent));
 }
 
-// The kept bubbles back into the redrawn history, each after its turn.
+// The kept bubbles back into the redrawn history, each after its turn; a
+// reminder's whose turn the history now draws from its drawing
+// (data-drawn: the drawing has the reminder) stays out.
 export function restoreCommandBubbles(historyEl, kept) {
   if (!kept.length) return;
   historyEl.querySelector(".hint")?.remove();
+  const drawn = new Set([...historyEl.querySelectorAll("[data-drawn]")].map((el) => el.dataset.drawn));
   kept.forEach(({ el, anchor }) => {
+    if (el.dataset.turnId && drawn.has(el.dataset.turnId)) return;
     const { els, kinds } = historyAnchors(historyEl);
     const at = anchorInsertIndex(kinds, anchor);
     if (at < els.length) els[at].before(el);

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

@@ -130,9 +130,11 @@ export function uploadImage(id, file, name, opts = {}) {
 // (mergeTiming), and opts.turnId asks for that turn's answer.
 // opts.timing: the whole timing alone (when the merge came up short).
 // opts.parts: each saved message with what it did (thinking, tool calls
-// and their output), for the turn block's reload.
+// and their output), for the turn block's reload; with it, drawings=1: a
+// finished turn with a drawing comes as its turn_drawings, its items
+// stamped (drawn) without their parts (turn_drawing.js).
 export function getSession(id, { tail, recent, turnId, timing, parts, cards, ...opts } = {}) {
-  let query = cards ? "?cards=1" : tail ? "?tail=1" : timing ? "?timing=1" : parts ? "?parts=1" : "";
+  let query = cards ? "?cards=1" : tail ? "?tail=1" : timing ? "?timing=1" : parts ? "?parts=1&drawings=1" : "";
   if (tail && recent) query += "&recent=1";
   if (tail && turnId) query += `&turn_id=${encodeURIComponent(turnId)}`;
   return api(`/api/sessions/${id}${query}`, opts);