samagotchi 0.150.0 → 0.152.0

data/lib/samagotchi/session_chain.rb

@@ -129,7 +129,7 @@ module Samagotchi
     # A turn's opening, not a `!shell` line: a command the user ran after
     # the answer leaves it the last word.
     def later_turn?(message)
-      Steer.turn_prompt?(message) && !shell_line?(message)
+      Steer.turn_opening?(message)
     end
 
     # At most +max+ bytes of +text+'s start, cut on a character.
@@ -181,18 +181,13 @@ module Samagotchi
 
         text = msg[:content]
         next unless text.is_a?(String) && !text.strip.empty?
-        next if shell_line?(msg)
+        next if Steer.shell_line?(msg)
 
         return text.strip
       end
       nil
     end
 
-    # A stored `!shell` line: "!(cmd)\n<output>", no turn_id.
-    def shell_line?(message)
-      message[:turn_id].nil? && message[:content].is_a?(String) && message[:content].start_with?("!(")
-    end
-
     def clock(iso)
       iso && Time.iso8601(iso.to_s).localtime.strftime("%Y-%m-%d %H:%M")
     rescue ArgumentError

data/lib/samagotchi/session_commands.rb

@@ -317,16 +317,9 @@ module Samagotchi
       text = line.to_s.strip
       entry = @registry.lookup(text)
       return nil unless entry&.handler
-      return run_bundle_command(entry, text, confirm: confirm) unless entry.source == "core"
 
-      # Only commands that may ask take the flag.
-      return send(entry.id, text, confirm: confirm) if CONFIRMING.include?(entry.id)
-      # Who sent it goes to its handler per call, never through an ivar:
-      # an anytime command runs on another thread against this instance.
-      return continue_command(text, as_parent: as_parent) if entry.id == :continue
-      return parent_answers(text, user_ui: user_ui) if entry.id == :parent_answers
-
-      instance_exec(text, &entry.handler)
+      # A card it shows names it (Engine#running_command).
+      @engine.running_command(entry.name) { dispatch(entry, text, confirm:, as_parent:, user_ui:) }
     end
 
     # /continue [yes|no|no, <reason>]: the continue offer's answer.
@@ -367,6 +360,19 @@ module Samagotchi
 
     private
 
+    def dispatch(entry, text, confirm:, as_parent:, user_ui:)
+      return run_bundle_command(entry, text, confirm: confirm) unless entry.source == "core"
+
+      # Only commands that may ask take the flag.
+      return send(entry.id, text, confirm: confirm) if CONFIRMING.include?(entry.id)
+      # Who sent it goes to its handler per call, never through an ivar:
+      # an anytime command runs on another thread against this instance.
+      return continue_command(text, as_parent: as_parent) if entry.id == :continue
+      return parent_answers(text, user_ui: user_ui) if entry.id == :parent_answers
+
+      instance_exec(text, &entry.handler)
+    end
+
     # The resolved ref (what the session stores and --alias/--default write).
     def model_name = @engine.effective_model_ref
 

data/lib/samagotchi/session_config.rb

@@ -13,7 +13,7 @@ module Samagotchi
   # (RecapSetup). Its
   # bundles part: {bundle => {key => value}}, string keys, scalar values
   # (.typed). A bundle offers the keys a session may set in its manifest's
-  # session_settings: (recorded at install, InstalledBundle#session_settings);
+  # session_settings: (recorded at install, InstalledManifest#session_settings);
   # any other bundle or key is refused, so a typo isn't saved, and so is a
   # value of another type than the manifest gives the key (session_settings:
   # {cap: number}). The session keeps them (Session#settings, SessionSetup)
@@ -308,9 +308,10 @@ module Samagotchi
           notes[name] = "#{name} is installed but its plugin doesn't load: #{reason}"
           next
         end
-        offered[name] = bundle.session_settings
-        types[name] = bundle.session_setting_types unless bundle.session_setting_types.empty?
-        if bundle.session_settings.empty? && shipped_settings?(shipped_dir, name)
+        manifest = bundle.manifest
+        offered[name] = manifest.session_settings
+        types[name] = manifest.session_setting_types unless manifest.session_setting_types.empty?
+        if manifest.session_settings.empty? && shipped_settings?(shipped_dir, name)
           notes[name] = "(run `chi update` or `chi bundle upgrade #{name}` to refresh it)"
         end
       end

data/lib/samagotchi/session_manager.rb

@@ -1018,15 +1018,18 @@ module Samagotchi
       turns.is_a?(Array) && turns.empty?
     end
 
-    # A folder's cards.json is empty only when it is a JSON object whose
-    # turns is an integer zero. Anything unreadable, not JSON, not an
-    # object, the wrong type, or turns not an integer reads as "not empty":
-    # a broken or wrong-shape cards file keeps the folder instead of
-    # raising (Array#/Hash#to_i) or reading as empty.
+    # A folder's cards.json is empty only when it is a JSON object with no
+    # turn in it: an empty turn_log, or an older file's (Bridge::CardStore
+    # version 1) turns an integer zero. Anything unreadable, not JSON, not an
+    # object, the wrong type, or neither of those reads as "not empty": a
+    # broken or wrong-shape cards file keeps the folder instead of raising
+    # (Array#/Hash#to_i) or reading as empty.
     def self.cards_empty?(path)
       data = read_json(path)
-      turns = data.is_a?(Hash) ? data["turns"] : nil
-      turns.is_a?(Integer) && turns.zero?
+      return false unless data.is_a?(Hash)
+
+      turns = data["turns"]
+      data["turn_log"] == [] || (turns.is_a?(Integer) && turns.zero?)
     end
 
     # A session-dir JSON file's contents, or nil when it is missing,

data/lib/samagotchi/steer.rb

@@ -336,6 +336,23 @@ module Samagotchi
       prompt?(message) && (!input?(message) || start)
     end
 
+    # A stored `!shell` line: "!(cmd)\n<output>", no turn id. A user message,
+    # so #turn_prompt? takes it; no turn ran.
+    def shell_line?(message)
+      return false unless message.is_a?(Hash)
+
+      content = message[:content] || message["content"]
+      (message[:turn_id] || message["turn_id"]).nil? && content.is_a?(String) && content.start_with?("!(")
+    end
+
+    # A turn's opening as the page draws it (TURN_PROMPT, bubbles.js): a prompt
+    # or a wake turn's note or report, not a `!shell` line. What the recap, the
+    # cards' count and "a later turn" go by. #turn_prompt? stays what bounds a
+    # turn's slice, where a `!shell` line ends one.
+    def turn_opening?(message)
+      turn_prompt?(message) && !shell_line?(message)
+    end
+
     # Call a loop's drain: +at_answer+ goes only to a drain that takes it
     # (the Engine's); a caller's own drain (a queue's #drain) is called bare.
     # A failing drain drains nothing (the loop keeps going).

data/lib/samagotchi/system_one/record.rb

@@ -7,7 +7,8 @@ module Samagotchi
   module SystemOne
     # One rule's record: what System 1 has judged for it and what the user
     # did about those asks. Built from `SystemOne::Log#entries` (judgments
-    # joined with their last label), filtered to one rule. The gate before
+    # joined with their last label), filtered to one rule — an ask two rules
+    # raised counts for each of them (its `other_rules`). The gate before
     # System 1 answers for the user: enough clean allows at the threshold,
     # and no false allow among the rule's last 20 labelled asks
     # (docs/guardrails.md, "System 1"). A rule in
@@ -41,7 +42,14 @@ module Samagotchi
       #   rule's. A line with no repo is in no repository's record.
       def initialize(entries, rule:, repo: nil)
         @rule = rule.to_s
-        @entries = Array(entries).select { |entry| entry["rule"].to_s == @rule && (repo.nil? || entry["repo"] == repo) }
+        @entries = Array(entries).select { |entry| asks?(entry) && (repo.nil? || entry["repo"] == repo) }
+      end
+
+      # The judgment names the rule the ask was for; an ask two rules raised
+      # carries the others in `other_rules`, so it counts in each of their
+      # records too.
+      def asks?(entry)
+        entry["rule"].to_s == @rule || Array(entry["other_rules"]).any? { |other| other.to_s == @rule }
       end
 
       # @param threshold [Float] the probability an auto-allow needs

data/lib/samagotchi/terminal_ui.rb

@@ -544,13 +544,13 @@ module Samagotchi
 
     # The session's cards.json and pending_card.json, kept as a worker's
     # Bridge keeps them (it owns the session as a worker would): this REPL's
-    # kept turns count on from the saved count, so a card an earlier worker
-    # showed stays that many turns back, and its own cards and notices are
-    # saved for the next; an open card with actions is on disk, where
+    # turns go on the same turn log, so a card an earlier worker showed keeps its
+    # place above the turns after it, and its own cards and notices are saved
+    # for the next; an open card with actions is on disk, where
     # `chi web`'s session hub reads it to mark the session as waiting.
     def keep_cards(session)
       path = File.join(Session.session_dir(session.id), Bridge::CardStore::FILE)
-      @cards_handle ||= @engine.subscribe(observer: Bridge::CardStore.new(path: path))
+      @cards_handle ||= @engine.subscribe(observer: Bridge::CardStore.new(path: path, messages: -> { @engine.session&.messages }))
       keep_pending_card(session)
     end
 

data/lib/samagotchi/tools/delegate.rb

@@ -159,7 +159,8 @@ module Samagotchi
       # repository (a worktree the parent meant to pass as cwd:), which makes
       # every write there an ask for the user (child-boundary). One warning
       # line, however many are named; nil when the task names none, or names
-      # only the checkout holding the child's folder (or a subfolder of it).
+      # only the checkout holding the child's folder (or a subfolder of it),
+      # or main while the child itself runs in a worktree of it.
       # Never raises: a started child must not come back as an Error:.
       # @return [String, nil]
       def self.other_checkout(task, folder, parent:, child_id:, no_cwd:)
@@ -180,6 +181,9 @@ module Samagotchi
       # not the one holding +folder+: the first path token in the task that
       # belongs to one (the deepest containing it), else nil. Reads files
       # only, no git process, so a spec stubbing Process.spawn is unaffected.
+      # A child started in a linked worktree is never pointed at main: its
+      # work belongs in the worktree, so naming a main-checkout file - mostly
+      # to read it - is not a cwd: the parent forgot.
       # @return [String, nil] an absolute checkout folder
       def self.foreign_checkout(task, folder)
         common = MemoryPaths.common_git_dir(folder)
@@ -187,17 +191,31 @@ module Samagotchi
 
         checkouts = Guardrails::GitInfo.checkouts(common).map { |checkout| File.realpath(checkout) }
         own = deepest_checkout(File.realpath(folder), checkouts)
+        main = main_checkout(common)
         task.to_s.scan(PATH_TOKEN) do |token|
           path = existing_ancestor(File.expand_path(token.sub(/[.:!?]+\z/, ""), folder))
           next if path.nil?
 
           found = deepest_checkout(path, checkouts)
-          return found if found && found != own
+          next if found.nil? || found == own || found == main
+
+          return found
         end
         nil
       end
       private_class_method :foreign_checkout
 
+      # The main checkout of a common git dir (the folder holding it), nil for
+      # a bare or separate-git-dir layout, which has none.
+      def self.main_checkout(common)
+        return nil unless File.basename(common) == ".git"
+
+        File.realpath(File.dirname(common))
+      rescue StandardError
+        nil
+      end
+      private_class_method :main_checkout
+
       # The checkout containing +path+, matched by whole components (so
       # /x/app is not found in /x/app-fix): the deepest, so a nested worktree's
       # path belongs to that worktree, not to main; nil when none does.

data/lib/samagotchi/turn_checkpoint.rb

@@ -171,17 +171,20 @@ module Samagotchi
 
     # A turn begins (before Engine#run_turn and the worker's running save):
     # the overlay starts as the history plus +prompt+ (text only: no
-    # images, no turn id), marked at iteration 0, so a worker killed before
-    # the loop's first boundary leaves the prompt and a mark the next one
-    # settles. A continue turn (no prompt) is the history, marked.
+    # images), marked at iteration 0, so a worker killed before the loop's
+    # first boundary leaves the prompt and a mark the next one settles. The
+    # prompt carries +turn_id+, as the first boundary's copy does: a card's
+    # place counts from it (Bridge::CardStore). A continue turn (no prompt)
+    # is the history, marked.
     # Every mark of the turn carries +enqueued_id+ and a participant's
     # +author+ (InterruptedTurn's).
     # @param prompt [String, nil]
+    # @param turn_id [String, nil] the id the turn runs under
     # @param enqueued_id [String, nil] the input the turn runs
     # @param author [Hash] a participant's prompt's author fields
     #   (Engine#author_fields), so a kill before the first boundary leaves
     #   it theirs; {} for the owner's
-    def begin_turn(prompt: nil, enqueued_id: nil, author: {})
+    def begin_turn(prompt: nil, turn_id: nil, enqueued_id: nil, author: {})
       @boundaries = 0
       @enqueued_id = enqueued_id.to_s.empty? ? nil : enqueued_id.to_s
       @author = author[:author]
@@ -190,7 +193,10 @@ module Samagotchi
       messages = Array(@session.messages).dup
       # Stamped by the wall clock here, a moment before the turn's own
       # stamp (Engine's Turn#wall), which the turn's first boundary saves.
-      messages << { role: "user", content: prompt, **author, MessageTime::KEY => MessageTime.iso(MessageTime.now) } unless prompt.to_s.empty?
+      unless prompt.to_s.empty?
+        messages << { role: "user", content: prompt, **(turn_id ? { turn_id: turn_id } : {}), **author,
+                      MessageTime::KEY => MessageTime.iso(MessageTime.now) }
+      end
       @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0,
                                                                                    enqueued_id: @enqueued_id, author: @author) }
     end

data/lib/samagotchi/turn_flow.rb

@@ -191,8 +191,8 @@ module Samagotchi
     # Restore the pre-turn checkpoint (!rollback after a Ctrl-C). A pending
     # offer goes too: the turn it offered to continue is gone. (The REPL
     # reads every line as an answer while an offer is pending; a worker
-    # also takes !rollback then.) :turn_rolled_back tells the cards' count
-    # (Bridge::CardStore) that the turn's prompt is gone.
+    # also takes !rollback then.) The cards' places follow the messages
+    # (Bridge::CardStore).
     # @return [Boolean] false when there is none
     def rollback!
       return false unless @checkpoint
@@ -200,7 +200,6 @@ module Samagotchi
       restore(@checkpoint)
       @checkpoint = nil
       @offer = nil
-      @engine.announce({ type: :turn_rolled_back })
       true
     end
 

data/lib/samagotchi/update_command.rb

@@ -10,6 +10,7 @@ require_relative "gem_update"
 require_relative "installed_gem"
 require_relative "live_versions"
 require_relative "memory_bundle/file_standing"
+require_relative "memory_bundle/manifest_standing"
 require_relative "memory_bundle/shipped_update"
 require_relative "memory_bundle/system_bundle"
 require_relative "session"
@@ -331,10 +332,20 @@ module Samagotchi
 
       require_relative "bundle_command/installed_check"
       bundles.flat_map do |bundle|
-        BundleCommand::InstalledCheck.run(bundle).map { |found| Row.new(component: bundle.name, status: found.text, level: found.level) }
+        kept = MemoryBundle::ManifestStanding.keep(bundle, dry_run: @dry_run)
+        [manifest_row(kept)].compact +
+          BundleCommand::InstalledCheck.run(kept.bundle).map { |found| Row.new(component: bundle.name, status: found.text, level: found.level) }
       end
     end
 
+    # What an external bundle's manifest.yml came to (ManifestStanding.keep):
+    # kept (or would be) is a change, anything else to say a warning.
+    def manifest_row(kept)
+      return nil unless kept.line
+
+      Row.new(component: kept.bundle.name, status: kept.line, level: kept.kept ? nil : "warn")
+    end
+
     def bundle_row(update)
       row = Row.new(component: update.name, from: update.from, to: update.to)
       earlier = update.status == :failed ? [] : Array(update.earlier)
@@ -343,7 +354,7 @@ module Samagotchi
       when :would_update, :updated
         notes = [adds(update.adds), *notes, replaced(update.replaced), *update.kept_own].compact
         done(row, :update, notes.empty? ? nil : notes.join("; "))
-      when :would_merge, :merged, :up_to_date then same_version(row, [*notes, update.note].compact, changed: Array(update.merged).any?)
+      when :would_merge, :merged, :up_to_date then same_version(row, [*notes, update.note, update.manifest].compact, changed: Array(update.merged).any?)
       when :skipped then skipped(row, [update.note, *notes].join("; "))
       else failed(row, [update.note, *notes].compact.join("; "))
       end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -62,6 +62,7 @@ require_relative "editor"
 require_relative "../message_parts"
 require_relative "../launch_mode"
 require_relative "session_summary"
+require_relative "session_hub"
 require_relative "project_list"
 require_relative "session_access_routes"
 require_relative "principal"
@@ -74,6 +75,7 @@ require_relative "session_create"
 require_relative "session_control"
 require_relative "verify_fresh_routes"
 require_relative "push_routes"
+require_relative "block_renderer_routes"
 require_relative "update_check"
 require_relative "update_ops"
 require_relative "proxy_gate"
@@ -107,6 +109,7 @@ module Samagotchi
       include SessionControl
       include VerifyFreshRoutes
       include PushRoutes
+      include BlockRendererRoutes
       include ProxyGate
 
       DEFAULT_HOST = BridgeClient::HOST
@@ -222,8 +225,11 @@ module Samagotchi
       private
 
       # No page of chi web's may be framed by another (clickjacking): every
-      # HTML answer says so. The page's full CSP is a later change.
-      FRAME_HEADERS = { "X-Frame-Options" => "DENY", "Content-Security-Policy" => "frame-ancestors 'none'" }.freeze
+      # HTML answer says so. frame-src 'none': a page's own frames can't navigate
+      # anywhere, which a block renderer's frame's own CSP doesn't stop (a srcdoc
+      # frame still loads under it; docs/internals/block-renderers.md). The page's
+      # full CSP is a later change.
+      FRAME_HEADERS = { "X-Frame-Options" => "DENY", "Content-Security-Policy" => "frame-ancestors 'none'; frame-src 'none'" }.freeze
       FRAME_DESTS = %w[iframe frame embed object].freeze
 
       def unframed(response)
@@ -315,6 +321,8 @@ module Samagotchi
         ["DELETE", %r{\A/api/push/subscriptions/([^/]+)\z}, :handle_push_remove, :owner],
         ["POST", %r{\A/api/push/test\z}, :handle_push_test, :owner],
         ["POST", %r{\A/api/push/presence\z}, :handle_push_presence, :owner],
+        ["GET", %r{\A/api/block_renderers\z}, :handle_block_renderers, :owner],
+        ["GET", %r{\A/api/block_renderers/([^/]+)/([^/]+)\z}, :handle_block_renderer_file, :owner],
         ["GET", %r{\A/api/sessions/([^/]+)\z}, :handle_show, :participant, :session],
         ["DELETE", %r{\A/api/sessions/([^/]+)\z}, :handle_delete, :owner, :session]
       ].freeze
@@ -1018,7 +1026,7 @@ module Samagotchi
       def handle_info(req)
         return participant_info unless principal(req).owner?
 
-        chi_state = @hub&.chi_state || { version: Samagotchi::VERSION, installed: nil, available: nil, update_blocked: nil, auto: "off", restart: "idle", auto_offers: nil }
+        chi_state = @hub&.chi_state || SessionHub::HUBLESS_STATE
         json_response(200, { app: "chi-web", **chi_state, pid: Process.pid,
                              cwd: Dir.pwd, start_dir: start_dir, features: INFO_FEATURES, lan: @lan && @lan[:ip],
                              proxy: @public_url && { identity_header: @public_url.identity_header } })
@@ -1800,21 +1808,24 @@ module Samagotchi
         rel = rel.split("/").reject { |p| p == ".." || p.empty? }.join("/")
         full = File.join(@public_dir, rel)
         if File.file?(full) && full.start_with?(@public_dir)
-          body = File.binread(full)
-          # no-cache + a content ETag: the browser revalidates every asset
-          # (the ES-module imports too) and gets a cheap 304 while it is
-          # unchanged, so a gem upgrade + chi web restart takes effect on the
-          # next load instead of after max-age runs out.
-          etag = %("#{Digest::SHA256.hexdigest(body)[0, 32]}")
-          headers = { "Cache-Control" => "no-cache", "ETag" => etag }
-          return [304, headers, []] if etag_match?(req.get_header("HTTP_IF_NONE_MATCH"), etag)
-
-          [200, headers.merge("Content-Type" => mime_type(full), "Content-Length" => body.bytesize.to_s), [body]]
+          revalidated_body(req, File.binread(full), mime_type(full))
         else
           not_found(path: req.path_info)
         end
       end
 
+      # no-cache + a content ETag: the browser revalidates every asset
+      # (the ES-module imports too) and gets a cheap 304 while it is
+      # unchanged, so a gem upgrade + chi web restart takes effect on the
+      # next load instead of after max-age runs out.
+      def revalidated_body(req, body, content_type)
+        etag = %("#{Digest::SHA256.hexdigest(body)[0, 32]}")
+        headers = { "Cache-Control" => "no-cache", "ETag" => etag }
+        return [304, headers, []] if etag_match?(req.get_header("HTTP_IF_NONE_MATCH"), etag)
+
+        [200, headers.merge("Content-Type" => content_type, "Content-Length" => body.bytesize.to_s), [body]]
+      end
+
       def etag_match?(if_none_match, etag)
         return false if if_none_match.nil?
 

data/lib/samagotchi/web/block_renderer_routes.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../block_renderers"
+
+module Samagotchi
+  module Web
+    # What the owner's page asks to draw a fenced block (App::ROUTES, :owner
+    # rows; a participant's page shows the source). Included in App: its helpers
+    # answer. docs/internals/block-renderers.md.
+    module BlockRendererRoutes
+      private
+
+      # {renderers: [{lang, bundle, files}]}
+      def handle_block_renderers(_req)
+        json_response(200, { renderers: BlockRenderers.for_installed.map(&:to_h) })
+      end
+
+      # One of a renderer's files. The captures are the URL's and unchecked:
+      # BlockRenderers.script_path never makes a path of one that isn't a
+      # renderer's. A file changed since the install gets an error, so the page
+      # keeps the block as source.
+      def handle_block_renderer_file(req, bundle, file)
+        path = BlockRenderers.script_path(bundle, file)
+        return not_found(path: req.path_info) unless path
+
+        revalidated_body(req, File.binread(path), "text/javascript; charset=utf-8")
+      rescue BlockRenderers::Invalid => e
+        error_response(409, "renderer_changed", e.message)
+      end
+    end
+  end
+end

data/lib/samagotchi/web/markdown_renderer.rb

@@ -2,6 +2,7 @@
 
 require "nokogiri"
 require "uri"
+require_relative "../block_renderers"
 
 module Samagotchi
   module Web
@@ -17,6 +18,12 @@ module Samagotchi
       ALLOWED_ELEMENTS = %w[a blockquote br code del em h1 h2 h3 h4 h5 h6 hr li ol p pre s strong span table tbody td th thead tr ul].freeze
       DROP_ELEMENTS = %w[iframe object script style svg].freeze
       ALLOWED_PROTOCOLS = %w[http https mailto].freeze
+      # Both Commonmarker calls take these: the parse that reads the fences has
+      # to see the blocks #render's own parse does.
+      OPTIONS = {
+        render: { escape: true }, # escape raw HTML from source; highlighter output is still emitted
+        extension: { header_ids: nil }
+      }.freeze
 
       def initialize(enabled: false)
         @enabled = enabled
@@ -46,10 +53,7 @@ module Samagotchi
       def render(markdown)
         return nil unless available?
 
-        html = Commonmarker.to_html(markdown.to_s, options: {
-          render: { escape: true }, # escape raw HTML from source; highlighter output is still emitted
-          extension: { header_ids: nil }
-        }, plugins: {
+        html = Commonmarker.to_html(markdown.to_s, options: OPTIONS, plugins: {
           # An empty theme makes syntect emit scope classes (`keyword`, `string`, ...)
           # instead of inline colours from one fixed theme, so the page's light and
           # dark palettes colour code blocks (the --code-* tokens in index.html).
@@ -57,7 +61,7 @@ module Samagotchi
         })
         return nil unless html
 
-        sanitize(html)
+        sanitize(html, fence_languages(markdown.to_s))
       end
 
       private
@@ -77,7 +81,35 @@ module Samagotchi
         @commonmarker_installed = Gem::Specification.find_all_by_name("commonmarker").any?
       end
 
-      def sanitize(html)
+      # Every code block's language, in document order (nil for an indented block
+      # or a bare fence): the highlighter drops it from the HTML, the parse tree
+      # has it. [] for a text with no fence: its blocks have no language.
+      def fence_languages(markdown)
+        return [] unless markdown.include?("```") || markdown.include?("~~~")
+
+        languages = []
+        Commonmarker.parse(markdown, options: OPTIONS).walk do |node|
+          languages << language_of(node.fence_info) if node.type == :code_block
+        end
+        languages
+      end
+
+      def language_of(info)
+        word = info.to_s.split.first.to_s.downcase
+        word if word.match?(BlockRenderers::LANG)
+      end
+
+      # After the walk, which drops every attribute it doesn't know. Blocks and
+      # languages pair by position; a count that differs says the two parses
+      # disagree, and then no block gets one (it shows as source).
+      def mark_languages(fragment, languages)
+        blocks = fragment.css("pre")
+        return unless blocks.size == languages.size
+
+        blocks.zip(languages) { |pre, language| pre["data-lang"] = language if language }
+      end
+
+      def sanitize(html, languages)
         fragment = Nokogiri::HTML5.fragment(html)
         fragment.traverse do |node|
           next unless node.element?
@@ -90,6 +122,7 @@ module Samagotchi
             sanitize_attributes(node)
           end
         end
+        mark_languages(fragment, languages)
         fragment.to_html
       end
 

data/lib/samagotchi/web/message_display.rb

@@ -59,7 +59,7 @@ module Samagotchi
         return nil unless saved
 
         messages = Array(session.messages)
-        since = messages.drop(saved[:covered].to_i).count { |m| Samagotchi::Steer.turn_prompt?(m) }
+        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
       rescue StandardError
         nil
@@ -288,8 +288,8 @@ module Samagotchi
       end
 
       # As JSON has them (string keys and values), like a snapshot's.
-      def saved_cards(id)
-        JSON.parse(JSON.generate(Samagotchi::Bridge::CardStore.saved(Session.session_dir(id, state_dir: default_state_dir))))
+      def saved_cards(id, messages: nil)
+        JSON.parse(JSON.generate(Samagotchi::Bridge::CardStore.saved(Session.session_dir(id, state_dir: default_state_dir), messages: messages)))
       rescue StandardError
         []
       end

data/lib/samagotchi/web/participant_view.rb

@@ -85,7 +85,7 @@ module Samagotchi
         llm_context_edited merged_input objectives_updated participants_changed pending_input_merged plugin_init_finished
         plugin_init_started plugin_init_wait prompt_restored question question_relay reasoning_history_refused
         recap_ready reminder_injected sampling_refused session_end session_start side_usage steer_cut thinking_dropped
-        thinking_refused tool_dispatch_completed tool_dispatch_started turn_rolled_back used_memories_updated working_set_updated
+        thinking_refused tool_dispatch_completed tool_dispatch_started used_memories_updated working_set_updated
       ].freeze
 
       # A merged input line's saved sources a participant sees: a person's

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

@@ -71,6 +71,7 @@ import { createAnnotateBar } from "./annotate_bar.js";
 import { VERIFY_PRESET, VERIFY_UNAVAILABLE, verifyWorkerUnavailable, withVerify } from "./verify_preset.js";
 import { OWNER_FINAL, verifyTurnOf } from "./verify_target.js";
 import { actionLine, annotationActions, composerWithAction } from "./annotate_actions.js";
+import { createBlockHost } from "./block_host.js";
 import { copyText, installCopy } from "./copy.js";
 import { installAnswerFold, sweepAnswerFolds } from "./answer_fold.js";
 import { installDetailsMotion } from "./details_motion.js";
@@ -2119,6 +2120,7 @@ historyEl.addEventListener("click", (e) => {
 });
 turnDom.scrollEl.addEventListener("scroll", annotateBar.schedule, true);
 turnRoots().forEach((root) => installCopy(root));
+createBlockHost({ roots: turnRoots(), sessionId: () => store.selected });
 // A steps block, a thinking block and the recap open and close by hand
 // with their height animated (details_motion.js), in the history and on
 // the stage.