samagotchi 0.133.0 → 0.135.0

data/lib/samagotchi/tools/read.rb

@@ -81,10 +81,10 @@ module Samagotchi
 
         preview_block = [
           "[TRUNCATED_PREVIEW_HEAD]",
-          preview[:head],
-          "[... omitted #{preview[:omitted_bytes]} bytes ...]",
+          preview.head,
+          "[... omitted #{preview.omitted_bytes} bytes ...]",
           "[TRUNCATED_PREVIEW_TAIL]",
-          preview[:tail]
+          preview.tail
         ].join("\n")
 
         metadata_lines = [
@@ -92,8 +92,8 @@ module Samagotchi
           "path=#{path}",
           "preview_strategy=head_tail",
           "file_bytes=#{file_size}",
-          "returned_preview_bytes=#{preview[:returned_preview_bytes]}",
-          "omitted_bytes=#{preview[:omitted_bytes]}"
+          "returned_preview_bytes=#{preview.returned_preview_bytes}",
+          "omitted_bytes=#{preview.omitted_bytes}"
         ]
 
         telemetry = telemetry_lines_for(preview_block)

data/lib/samagotchi/turn_anchors.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "revise_anchor"
+require_relative "verify_anchor"
+
+module Samagotchi
+  # What a turn points at in an earlier turn: a Verify turn's claim
+  # (VerifyAnchor) and a Revise turn's draft (ReviseAnchor). One carrier
+  # through every layer a turn's input travels (chi web's POST /turn, the
+  # Bridge, the input file, SessionInbox::Input, WorkerInbound::Prompt, a
+  # failed turn's restore), so a new anchor is one field here. On the wire
+  # and in the input file each is its own key ("verify", "revises"); a
+  # missing or malformed one is nil. The Engine takes them as run_turn's
+  # keywords (#kwargs): what each means is its own.
+  TurnAnchors = Data.define(:verify, :revises) do
+    def self.from(value)
+      return value if value.is_a?(self)
+
+      fields = value.is_a?(Hash) ? value.to_h { |key, entry| [key.to_s, entry] } : {}
+      new(verify: fields["verify"], revises: fields["revises"])
+    end
+
+    # Whether a parsed input file names an anchor (a Hash under its key,
+    # well-formed or not): SessionInbox.turn_end_data? holds it.
+    def self.named_in?(data) = %w[verify revises].any? { |key| data[key].is_a?(Hash) }
+
+    def initialize(verify: nil, revises: nil)
+      super(verify: VerifyAnchor.from(verify), revises: ReviseAnchor.from(revises))
+    end
+
+    def empty? = verify.nil? && revises.nil?
+
+    # The anchors given, each answering FEATURE (the worker's Bridge
+    # feature it needs) and UNAVAILABLE (the refusal without it).
+    def present = [verify, revises].compact
+
+    # The body's and the input file's keys.
+    def to_file = { "verify" => verify&.to_file, "revises" => revises&.to_file }.compact
+
+    # A :prompt_restored event's fields.
+    def to_h = { verify: verify&.to_h, revises: revises&.to_h }.compact
+
+    # Engine#run_turn's keywords.
+    def kwargs = { verify:, revises: }.compact
+
+    # A participant's: they can't Revise (participant_access.rb, the Bridge).
+    def without_revises = with(revises: nil)
+  end
+end

data/lib/samagotchi/update_command.rb

@@ -3,6 +3,7 @@
 require_relative "cli/command"
 require_relative "cli/flags"
 require_relative "chi_home"
+require_relative "child_env"
 require_relative "config"
 require_relative "desktop"
 require_relative "gem_update"
@@ -89,7 +90,7 @@ module Samagotchi
       # Built after the home is known: its install env goes into the home.
       @gem_update_given = gem_update
       @exec = exec || ->(argv) { Kernel.exec(*argv) }
-      @bundler = bundler.nil? ? (defined?(::Bundler) || !ENV["BUNDLE_GEMFILE"].to_s.empty?) : bundler
+      @bundler = bundler.nil? ? ChiHome.under_bundler? : bundler
       @argv = argv.dup
       @stdout = stdout
       @stderr = stderr
@@ -168,11 +169,14 @@ module Samagotchi
 
     # A chi on another Ruby than the home's updates the home: exec its chi
     # (newer?, --to and the bundle rows are then the home's), once
-    # (IN_HOME_ENV).
+    # (IN_HOME_ENV), outside a `bundle exec`'s bundle (ChildEnv.unbundled,
+    # as worker spawns and chi web's restart boot it). hand_over never runs
+    # under Bundler: the gem row skips there.
     def to_home(options)
       notice(options, "updating the chi home (#{@run_home.ruby})")
       @stdout.flush
-      @exec.call([{ IN_HOME_ENV => "1" }, *@run_home.boot_argv(run: ChiHome::CHI_BOOT), "--", "update", *@argv])
+      @exec.call([ChildEnv.unbundled.merge(IN_HOME_ENV => "1"), *@run_home.boot_argv(run: ChiHome::CHI_BOOT), "--",
+                  "update", *@argv])
       0 # only when exec is a spec's stand-in
     end
 

data/lib/samagotchi/update_hint.rb

@@ -52,8 +52,13 @@ module Samagotchi
       "chi #{version}: #{parts.join(" and ")} can be updated: chi update"
     end
 
+    # The helper whose chi reads this chi's config dir: an isolated run
+    # (XDG_CONFIG_HOME elsewhere) never hints about the real one.
     def default_helper(env)
-      Desktop.supported? ? Desktop::MacOS.new(env: env) : nil
+      return nil unless Desktop.supported?
+
+      helper = Desktop::MacOS.new(env: env, register: false)
+      helper.reads_this_config? ? helper : nil
     end
   end
 end

data/lib/samagotchi/verify_anchor.rb

@@ -3,9 +3,6 @@
 module Samagotchi
   # A claim selected in an earlier turn, carried only by a Verify turn.
   VerifyAnchor = Data.define(:turn_id, :quote) do
-    UUID = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
-    QUOTE_MAX = 200
-
     def self.from(value)
       return value if value.is_a?(self)
       return nil unless value.is_a?(Hash)
@@ -15,8 +12,8 @@ module Samagotchi
 
       turn_id = fields["turn_id"]
       quote = fields["quote"]
-      return nil unless turn_id.is_a?(String) && UUID.match?(turn_id)
-      return nil unless quote.is_a?(String) && quote.length.between?(1, QUOTE_MAX) && !quote.strip.empty?
+      return nil unless turn_id.is_a?(String) && self::UUID.match?(turn_id)
+      return nil unless quote.is_a?(String) && quote.length.between?(1, self::QUOTE_MAX) && !quote.strip.empty?
 
       new(turn_id:, quote:)
     end
@@ -26,6 +23,9 @@ module Samagotchi
     def to_file = { "turn_id" => turn_id, "quote" => quote }
   end
 
+  # The shape of the turn id an anchor names (ReviseAnchor's too).
+  VerifyAnchor::UUID = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+  VerifyAnchor::QUOTE_MAX = 200
   VerifyAnchor::FEATURE = "verify"
   VerifyAnchor::UNAVAILABLE = {
     "error" => "verify_unavailable",

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -134,8 +134,6 @@ module Samagotchi
 
       # @param bridge_wait_timeout [Float] bounded seconds to wait for a
       #   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
@@ -168,7 +166,7 @@ module Samagotchi
       # @param start_dir [String] the folder chi web starts in (StartDir):
       #   where a new session without a dir starts (nil: the cwd)
       def initialize(manager: nil, session_class: nil, state_dir: nil, public_dir: nil,
-                     bridge_wait_timeout: BRIDGE_WAIT_TIMEOUT, markdown: false, view: Config::BY_KEY["web.view"].default, hub: nil,
+                     bridge_wait_timeout: BRIDGE_WAIT_TIMEOUT, markdown: false, hub: nil,
                      annotate_presets: Config::BY_KEY["web.annotate_presets"].default,
                      editor: Config::BY_KEY["web.editor"].default,
                      events_heartbeat: EVENTS_HEARTBEAT, events_queue: EVENTS_QUEUE,
@@ -188,7 +186,6 @@ module Samagotchi
         @public_dir = public_dir || File.expand_path("public", __dir__)
         @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)
@@ -2015,8 +2012,7 @@ module Samagotchi
         # The owner's home: a claim link's quote reads it "~", as the
         # participant page shows it (claim_link.js).
         attrs["home"] = Dir.home
-        attrs["view"] = view_name(req.params["view"])
-        # Only when on: the page reads its presence (the turn view ignores it).
+        # Only when on: the page reads its presence.
         attrs["working-set"] = "1" if working_set?(req.params["working_set"])
         attrs.merge!(annotate_presets_data)
         dir, = scope_dir(req.params["dir"])
@@ -2060,14 +2056,6 @@ module Samagotchi
         File.directory?(dir) && ProjectScope.root_for(dir) ? dir : nil
       end
 
-      VIEWS = Config::BY_KEY["web.view"].enum_values
-
-      # The view for this page load: ?view=stage|turn wins, anything
-      # else leaves the config's choice (web.view).
-      def view_name(param)
-        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)

data/lib/samagotchi/web/message_display.rb

@@ -10,6 +10,7 @@ require_relative "../message_time"
 require_relative "../output_formatter"
 require_relative "../recap_store"
 require_relative "../ref"
+require_relative "../revise_anchor"
 require_relative "../steer"
 require_relative "../turn_note"
 require_relative "../bridge/card_store"
@@ -70,7 +71,7 @@ module Samagotchi
 
       # @param msgs [Array<Hash>] a session's messages; symbol keys from disk,
       #   string keys from a Bridge snapshot
-      # @param parts [Boolean] the turn view's reload (?parts=1): each
+      # @param parts [Boolean] the turn block's reload (?parts=1): each
       #   assistant message also carries what it did (MessageParts: thinking,
       #   tool calls with params and output), and a message with nothing to
       #   show but that (a text-less step) is kept with empty content
@@ -91,6 +92,7 @@ module Samagotchi
             if Samagotchi::Steer.turn_prompt?(m)
               note[:turn_start] = true
               note[:turn_id] = (m[:turn_id] || m["turn_id"]).to_s
+              note.merge!(revises_of(m))
             end
             filtered << note
             next
@@ -135,6 +137,13 @@ module Samagotchi
           # record by this, not by its place.
           turn_id = m[:turn_id] || m["turn_id"]
           message[:turn_id] = turn_id.to_s if norm_role == "user" && turn_id
+          # The turn it revised (a Revise stack, Engine#stamp_opening), and
+          # whether it was a Verify turn (the page offers no Revise on its
+          # answer).
+          if norm_role == "user" && turn_id && !message[:merged]
+            message.merge!(revises_of(m))
+            message[:verify] = true if Samagotchi::VerifyAnchor.from(m[:verify] || m["verify"])
+          end
           # A participant's message names them (the page's author badge).
           if norm_role == "user"
             message.merge!(Samagotchi::Steer.author_fields(m[:author] || m["author"], m[:author_name] || m["author_name"]))
@@ -166,6 +175,13 @@ module Samagotchi
         []
       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)
+        anchor = Samagotchi::ReviseAnchor.from(message[:revises] || message["revises"])
+        anchor ? { revises: anchor.to_h } : {}
+      end
+
       # The entry's wall time (MessageTime: the page's hover and gap
       # dividers) as {at:}, or nothing for an entry saved without one.
       def time_of(message)

data/lib/samagotchi/web/participant_access.rb

@@ -272,10 +272,10 @@ module Samagotchi
         reason = participant_turn_refusal(grant, prompt, body)
         return participant_turn_refused(grant, prompt, *reason) if reason
 
-        verify = VerifyAnchor.from(body["verify"])
+        # A Verify turn's claim; never a Revise (the owner's stacks).
         result = SessionManager.deliver_turn(id, prompt: prompt, client_id: ClientId.review(grant.id),
                                                  delivery: Delivery::QUEUE, author: grant.author,
-                                                 verify: verify,
+                                                 anchors: TurnAnchors.from(body).without_revises,
                                                  pending_limit: grant.queue_limit + 1,
                                                  state_dir: @state_dir, manager: @manager,
                                                  bridge: -> { live_bridge_client(id) })

data/lib/samagotchi/web/participant_view.rb

@@ -4,6 +4,7 @@ require_relative "../output_formatter"
 require_relative "../steer"
 require_relative "../turn_origin"
 require_relative "../participant_mode"
+require_relative "../revise_anchor"
 require_relative "../verify_anchor"
 
 module Samagotchi
@@ -134,6 +135,10 @@ module Samagotchi
         out = { "type" => field(event, :type).to_s, **id_fields(event) }
         verdict = verdict_record(field(event, :verdict), viewer)
         out["verdict"] = verdict if verdict
+        # The turn a completed Revise turn revised (as on its prompt; the
+        # page doesn't draw stacks yet).
+        revises = ReviseAnchor.from(field(event, :revises))
+        out["revises"] = revises.to_file if revises
         out
       end
 
@@ -249,6 +254,9 @@ module Samagotchi
         out["content"] = field(message, :content).to_s
         out["turn_id"] = turn_id.to_s if turn_id
         out["merged"] = true if merged
+        # The turn it revised (a Revise stack; the page doesn't draw it yet).
+        revises = ReviseAnchor.from(field(message, :revises))
+        out["revises"] = revises.to_file if revises && turn_id && !merged
         out.merge!(author_fields(field(message, :author), field(message, :author_name), viewer,
                                  field(message, :participant_mode)))
         images = field(message, :images)

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

@@ -154,7 +154,7 @@ export function addCompleted(model, event = {}, now = null) {
       ...(guardrail.judgment_id ? { judgment_id: guardrail.judgment_id } : {}),
     };
   }
-  // The images the tool returned (a reload in the turn view draws them from
+  // The images the tool returned (a reload's turn block draws them from
   // the saved parts, turn_html.js toolRowTemplate).
   if (event.images?.length) row.images = event.images;
   // What an edit/write changed in its file (a reload draws it from the

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

@@ -27,7 +27,7 @@ export function annotationSource(node) {
   }
   const thinking = el.closest(".thinking-body");
   if (thinking) return { kind: "thinking", root: thinking };
-  // A step's narration in the turn view (the live one streams).
+  // A step's narration in a turn block (the live one streams).
   const step = el.closest(".gen-text");
   if (step) return step.classList.contains("streaming") ? null : { kind: "step", root: step };
   const own = el.closest(".bubble.user .user-message");

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

@@ -0,0 +1,262 @@
+// Folding a long answer by hand (per viewer). A completed answer bubble
+// longer than FOLD_LINES lines or FOLD_CHARS characters of its message text
+// gets a fold row: a sibling just before the bubble, never inside it (the
+// bubble's copy text, its claims and a live end's innerHTML stay the
+// bubble's own). Folded, the bubble has the class `.folded` (CSS hides it;
+// no inline style) and the row reads its first line
+// and its size, "‹first line› · N lines ▸"; unfolded, the row stays as a
+// slim "▾ N lines" header.
+//
+// Which answers are folded is this browser's choice (localStorage through
+// storage.js): one key per session holding the folded answers' keys, the
+// last FOLD_KEEP of them. An answer's key is its turn's id
+// (data-answer-turn), a delegate report's reply its own (data-reply-key);
+// a bubble with neither (an answer before any prompt, a canceled turn's
+// partial) gets no row. The keys of sessions gone from the session list go
+// when the list loads (sweepAnswerFolds).
+//
+// One observer on #history decorates every path that fills it (a reload's
+// render, a live turn's end, the stage's hand-off), as copy.js does. A jump
+// into a folded answer unfolds it (history_reveal.js); the row follows the
+// bubble's class.
+//
+// A module of its own: static JS is cached at unversioned URLs, and a new
+// export on an old module would blank the page.
+import { bubbleCopyText } from "./copy.js";
+import { clip } from "./format.js";
+import { readStored, removeStored, storedKeys, writeStored } from "./storage.js";
+
+// The fold threshold: an answer longer than either gets a fold row.
+export const FOLD_LINES = 25;
+export const FOLD_CHARS = 2000;
+// How many folded answers a session's key keeps (the oldest go first).
+export const FOLD_KEEP = 200;
+export const FOLD_PREFIX = "chi_answer_fold:";
+// A folded row's label, at most this long (CSS cuts it to the row's width).
+const LABEL_CHARS = 160;
+
+const ROW_CLASS = "answer-fold";
+const ANSWERS = ".bubble.output";
+// Not done yet: still streaming.
+const UNFINISHED = ".streaming";
+
+// +text+'s lines (a trailing newline ends the last one, it adds none).
+export function lineCount(text) {
+  const s = String(text ?? "").replace(/\s+$/, "");
+  return s ? s.split("\n").length : 0;
+}
+
+// Whether an answer of +text+ gets a fold row.
+export function foldable(text) {
+  const s = String(text ?? "");
+  return lineCount(s) > FOLD_LINES || s.length > FOLD_CHARS;
+}
+
+// A markdown line as plain words: no heading marks, list or quote lead, no
+// emphasis or code ticks.
+function plainLine(line) {
+  return line
+    .replace(/^\s*(?:#{1,6}\s+|>\s*|[-*+]\s+|\d+[.)]\s+)/, "")
+    .replace(/(\*\*|__|`)/g, "")
+    .trim();
+}
+
+// A folded answer's label: the first line of what a hook presented in its
+// place (+display+: the text is that), else its first markdown heading,
+// else its first text line (a code fence's marks skipped); one line.
+export function foldLabel(text, { display = false } = {}) {
+  const lines = String(text ?? "").replace(/\r\n?/g, "\n").split("\n");
+  const texts = lines.filter((l) => l.trim() && !/^\s*(```|~~~)/.test(l));
+  const heading = display ? null : texts.find((l) => /^\s{0,3}#{1,6}\s+\S/.test(l));
+  return clip(plainLine(heading ?? texts[0] ?? ""), LABEL_CHARS);
+}
+
+// The row's words: folded, the label and the size; unfolded, the size.
+export function foldRowText(text, { display = false, folded = true } = {}) {
+  const n = lineCount(text);
+  const size = `${n} line${n === 1 ? "" : "s"}`;
+  if (!folded) return { label: "", size };
+  const label = foldLabel(text, { display });
+  return { label, size: label ? `\u00a0\u00b7 ${size}` : size };
+}
+
+// ---- The stored choice ----
+
+export function foldStoreKey(sessionId) {
+  return sessionId ? `${FOLD_PREFIX}${sessionId}` : null;
+}
+
+function readEntry(key) {
+  try {
+    const entry = JSON.parse(readStored(key, "null"));
+    if (!entry || !Array.isArray(entry.turns)) return null;
+    return { root: typeof entry.root === "string" ? entry.root : null, turns: entry.turns.filter((t) => typeof t === "string") };
+  } catch (_) {
+    return null;
+  }
+}
+
+// The session's folded answers' keys, oldest first; [] when none or they
+// can't be read.
+export function readFolded(sessionId) {
+  const key = foldStoreKey(sessionId);
+  return (key && readEntry(key)?.turns) || [];
+}
+
+// +list+ with +answerKey+ folded (moved to the end) or not, at most
+// FOLD_KEEP long. Pure.
+export function withFold(list, answerKey, folded) {
+  const rest = list.filter((k) => k !== answerKey);
+  return (folded ? [...rest, answerKey] : rest).slice(-FOLD_KEEP);
+}
+
+// Saves +answerKey+ folded or not for +sessionId+. +root+: the session's
+// project root, kept for the sweep of a project's list.
+export function writeFold(sessionId, answerKey, folded, { root = null } = {}) {
+  const key = foldStoreKey(sessionId);
+  if (!key || !answerKey) return;
+  const turns = withFold(readFolded(sessionId), answerKey, folded);
+  if (!turns.length) removeStored(key);
+  else writeStored(key, JSON.stringify({ root, turns }));
+}
+
+// The session list loaded (+sessions+, each {id, project_root}): the fold
+// keys of sessions not in it go. A project's list (+scoped+) only knows its
+// own project's sessions, so there a key goes only when its project root is
+// one the list shows; an unreadable key goes.
+export function sweepAnswerFolds(sessions, { scoped = false } = {}) {
+  const list = Array.isArray(sessions) ? sessions : [];
+  const ids = new Set(list.map((s) => s?.id).filter(Boolean));
+  const roots = new Set(list.map((s) => s?.project_root).filter(Boolean));
+  for (const key of storedKeys(FOLD_PREFIX)) {
+    if (ids.has(key.slice(FOLD_PREFIX.length))) continue;
+    const entry = readEntry(key);
+    if (!entry || !scoped || (entry.root && roots.has(entry.root))) removeStored(key);
+  }
+}
+
+// ---- The rows ----
+
+// The key an answer bubble is folded by, or null.
+export function answerKey(bubble) {
+  return bubble?.getAttribute?.("data-answer-turn") || bubble?.getAttribute?.("data-reply-key") || null;
+}
+
+function answerText(bubble) {
+  return bubbleCopyText(bubble);
+}
+
+function drawRow(row, bubble) {
+  const folded = bubble.classList.contains("folded");
+  const text = answerText(bubble);
+  const { label, size } = foldRowText(text, { display: bubble.hasAttribute("data-answer-display"), folded });
+  row.setAttribute("aria-expanded", folded ? "false" : "true");
+  row.title = folded ? "Show the answer" : "Fold the answer";
+  row.classList.toggle("folded", folded);
+  const [labelEl, sizeEl] = row.children;
+  if (labelEl.textContent !== label) labelEl.textContent = label;
+  if (sizeEl.textContent !== size) sizeEl.textContent = size;
+}
+
+function makeRow(doc) {
+  const row = doc.createElement("button");
+  row.type = "button";
+  row.className = ROW_CLASS;
+  const label = doc.createElement("span");
+  label.className = "answer-fold-label";
+  const size = doc.createElement("span");
+  size.className = "answer-fold-size";
+  row.append(label, size);
+  return row;
+}
+
+// Runs +mutate+ and scrolls +scroller+ so +row+ stays where it was on
+// screen (folding a long answer above the view would pull the page up), in
+// sight at least.
+export function keepRowInView(scroller, row, mutate) {
+  const before = row.getBoundingClientRect().top;
+  mutate();
+  const after = row.getBoundingClientRect().top;
+  if (scroller && after !== before) scroller.scrollTop += after - before;
+  const box = row.getBoundingClientRect();
+  const view = scroller?.getBoundingClientRect?.();
+  if (view && (box.top < view.top || box.bottom > view.bottom)) row.scrollIntoView?.({ block: "nearest" });
+}
+
+// @param historyEl the history (#history), also its scroller
+// @param sessionId () => the open session's id
+// @param projectRoot () => the open session's project root, or null
+// @return {decorate(root)} (the observer runs it; specs call it)
+export function installAnswerFold({ historyEl, sessionId, projectRoot = () => null }) {
+  // Each bubble's row, and each row's bubble.
+  const rows = new WeakMap();
+  const bubbleOf = new WeakMap();
+
+  function decorateBubble(bubble, stored) {
+    if (bubble.parentElement !== historyEl) return;
+    const key = answerKey(bubble);
+    let row = rows.get(bubble);
+    if (!key || bubble.matches(UNFINISHED) || (!row && !foldable(answerText(bubble)))) return;
+    if (!row) {
+      row = makeRow(historyEl.ownerDocument);
+      rows.set(bubble, row);
+      bubbleOf.set(row, bubble);
+      // The stored choice, once: after that the bubble's class is the state
+      // (a jump that unfolds it, history_reveal.js, isn't saved).
+      if (stored().includes(key)) bubble.classList.add("folded");
+    }
+    if (bubble.previousElementSibling !== row) historyEl.insertBefore(row, bubble);
+    drawRow(row, bubble);
+  }
+
+  // Rows whose bubble left (a re-render, a replaced bubble) go with it.
+  function dropOrphans() {
+    for (const row of historyEl.querySelectorAll(`:scope > .${ROW_CLASS}`)) {
+      const bubble = bubbleOf.get(row);
+      if (!bubble || bubble.parentElement !== historyEl) row.remove();
+      else if (row.nextElementSibling !== bubble) historyEl.insertBefore(row, bubble);
+    }
+  }
+
+  function decorate(root) {
+    let folded = null;
+    const stored = () => (folded ??= readFolded(sessionId()));
+    if (root.matches?.(ANSWERS)) decorateBubble(root, stored);
+    for (const bubble of root.querySelectorAll?.(ANSWERS) || []) decorateBubble(bubble, stored);
+  }
+
+  // Synchronous (not a frame later, as copy buttons are): the row lands in
+  // the same frame as its bubble, so nothing below it shifts after a paint.
+  new MutationObserver((records) => {
+    const roots = new Set();
+    let removed = false;
+    for (const r of records) {
+      if (r.type === "attributes") {
+        if (r.target.matches?.(ANSWERS)) roots.add(r.target);
+        continue;
+      }
+      if (r.removedNodes.length) removed = true;
+      const answer = r.target.closest?.(ANSWERS);
+      if (answer) roots.add(answer);
+      for (const n of r.addedNodes) if (n.nodeType === 1 && !n.classList.contains(ROW_CLASS)) roots.add(n);
+    }
+    if (removed) dropOrphans();
+    for (const el of roots) if (el.isConnected) decorate(el);
+  }).observe(historyEl, { childList: true, subtree: true, attributes: true, attributeFilter: ["class"] });
+  decorate(historyEl);
+
+  historyEl.addEventListener("click", (e) => {
+    const row = e.target.closest?.(`.${ROW_CLASS}`);
+    const bubble = row && bubbleOf.get(row);
+    if (!bubble) return;
+    e.preventDefault();
+    const folded = !bubble.classList.contains("folded");
+    keepRowInView(historyEl, row, () => {
+      bubble.classList.toggle("folded", folded);
+      drawRow(row, bubble);
+    });
+    writeFold(sessionId(), answerKey(bubble), folded, { root: projectRoot() });
+  });
+
+  return { decorate };
+}

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

@@ -67,6 +67,8 @@ export function applyFinalAnswer(messages, bubbles, normalize) {
   if (typeof message.html === "string") {
     bubble.classList.add("markdown");
     bubble.setAttribute(COPY_SOURCE_ATTR, copySource(message));
+    // A hook's display in the answer's place (answer_fold.js's label).
+    bubble.toggleAttribute("data-answer-display", typeof message.display === "string");
     // The server's rendered markdown, sanitized there (Web::MarkdownRenderer#sanitize): set as it is, not templated.
     bubble.innerHTML = message.html;
   }