samagotchi 0.112.0 → 0.114.0

data/lib/samagotchi/idle_recap.rb

@@ -11,6 +11,7 @@ require_relative "image_store"
 require_relative "output_formatter"
 require_relative "steer"
 require_relative "recap_store"
+require_relative "recap_title"
 require_relative "log"
 
 module Samagotchi
@@ -143,8 +144,17 @@ module Samagotchi
       # user decisions) — tolerated. The "we" variant was 4/4 consistent.
       # %<plain>s is the range, e.g. "2-4 plain sentences"; %<shape>s is SHAPE
       # or ONE_SHAPE.
+      # Auto-title spike (eval 0004, 2026-10-25; local Qwen3.8-Flash-Next,
+      # the 4 recap-spike sessions, first recap + update, N=5): a first-line
+      # title parsed in 50/50, 2-6 words and no actor in all, no recap
+      # regression against "Reply with the recap only" (one reply echoed
+      # "Blank line follows title." before the recap: RecapTitle drops it).
+      # Asked last, it was there in 15/50 and 4 replies were the title alone.
+      # A quoted example title (probe p0) was copied as the title: none here.
+      TITLE = "Reply with a title line, a blank line, then the recap. The title line is \"#{RecapTitle::LABEL} \" " \
+              "followed by 2-6 words naming the task, no actors. The recap: "
       SYSTEM = "You write short recaps of a chat between a user and an assistant, for the user " \
-               "coming back to it later. Reply with the recap only: %<plain>s, no heading, " \
+               "coming back to it later. #{TITLE}%<plain>s, no heading, " \
                "no preamble, no notes about the task or the transcript. Do not mention what the " \
                "transcript lacks or does not say; leave it out. Centre it on outcomes, not on " \
                "the order of events. %<shape>s Keep project names " \
@@ -169,6 +179,10 @@ module Samagotchi
       UPDATE = " You are given the earlier recap and the conversation since the earlier recap: " \
                "write an updated recap of the whole session that also covers what happened since " \
                "(do not just repeat the earlier recap)."
+      # With an earlier title (the user message's "Earlier title:" line): the
+      # spike kept it in 14/15 updates on the same task and changed it on 4/5
+      # where the focus moved, so a card doesn't rename at every idle window.
+      UPDATE_TITLE = " Keep the earlier title unless the focus moved."
       # Holds the length once the recap covers more (S0: an updated recap ran
       # to 6 sentences for 2-4 without it, within range+1 in 95%+ with it).
       # The first-sentence line keeps the list preview on the task.
@@ -210,7 +224,9 @@ module Samagotchi
       #   transcript to summarize
       # @param sentences [Array(Integer, Integer)] the range, from #sentences_range
       # @param offer [Boolean] a continue offer is open: add OFFER_LINE
-      def build(transcript, tool_count: nil, tool_names: [], previous: nil, sentences: DEFAULT_SENTENCES, offer: false)
+      # @param previous_title [String, nil] the earlier recap's title (with +previous+)
+      def build(transcript, tool_count: nil, tool_names: [], previous: nil, previous_title: nil, sentences: DEFAULT_SENTENCES,
+                offer: false)
         body = cap(transcript.to_s.strip)
         return nil if body.empty?
 
@@ -227,8 +243,11 @@ module Samagotchi
         one = sentences.last == 1
         range = { plain: sentences_text(sentences, "plain "), sentences: sentences_text(sentences),
                   shape: one ? ONE_SHAPE : SHAPE, focus: one ? "it" : "the first sentence" }
-        system = format(SYSTEM, range) + (previous ? UPDATE + format(UPDATE_LENGTH, range) : "") + tools
+        earlier_title = previous && !previous_title.to_s.strip.empty? ? previous_title.to_s.strip : nil
+        update = "#{UPDATE}#{UPDATE_TITLE if earlier_title}#{format(UPDATE_LENGTH, range)}"
+        system = format(SYSTEM, range) + (previous ? update : "") + tools
         user = +""
+        user << "Earlier title: #{earlier_title}\n\n" if earlier_title
         user << "Earlier recap:\n#{previous}\n\n" if previous
         user << "Transcript#{" since the earlier recap" if previous} (the system prompt and tool " \
                 "internals were removed; only user turns and assistant prose remain):\n---\n#{body}\n---\n"
@@ -269,8 +288,9 @@ module Samagotchi
     #   answer (the Worker's or the REPL's TurnFlow); read at each attempt
     attr_writer :awaiting_continue
 
-    # @return [Hash, nil] the last recap written: {text:, covered:,
-    #   covered_digest:, model:, created_at:}, where covered counts the
+    # @return [Hash, nil] the last recap written: {text:, title:, covered:,
+    #   covered_digest:, model:, created_at:} (title: the auto title, absent
+    #   when no reply gave one), where covered counts the
     #   session messages it summarizes and covered_digest fingerprints the
     #   last of them. With a store, loaded from it for each new session.
     def state
@@ -467,12 +487,13 @@ module Samagotchi
       return :nothing_new if transcript.strip.empty?
 
       prompt = RecapPrompt.build(transcript, tool_names: TranscriptFilter.tool_names(fresh), previous: previous&.dig(:text),
-                                                     sentences: @sentences, offer: offer_open?)
+                                             previous_title: previous&.dig(:title), sentences: @sentences, offer: offer_open?)
       return :nothing_new if prompt.nil?
 
       asked = target
       @in_flight = { thread: spawn_summarize(client_for(asked), prompt), generation: gen, deadline: @clock.call + @timeout,
-                     covered: parsed.size, covered_digest: self.class.digest(parsed.last), model: asked.label }
+                     covered: parsed.size, covered_digest: self.class.digest(parsed.last), model: asked.label,
+                     previous_title: previous&.dig(:title) }
       :started
     rescue StandardError
       :failed
@@ -499,9 +520,16 @@ module Samagotchi
       # An IdleClient::Summary names the model that answered; a plain String
       # (a stubbed client) doesn't, and the asked label stands in.
       served = recap.model if recap.respond_to?(:model)
-      text = recap.to_s
-      saved = { text: text, covered: job[:covered], covered_digest: job[:covered_digest],
-                model: served || job[:model], created_at: Time.now.utc.iso8601 }
+      # The title line off the recap (RecapTitle): the text is the recap
+      # alone. A reply without a title that passes keeps the earlier one, so
+      # a broken line doesn't blank the card; a title alone is no recap.
+      split = RecapTitle.split(recap.to_s)
+      text = split.body
+      return if text.empty?
+
+      title = split.title || job[:previous_title]
+      saved = { text: text, title: title, covered: job[:covered], covered_digest: job[:covered_digest],
+                model: served || job[:model], created_at: Time.now.utc.iso8601 }.compact
       @mutex.synchronize { @state = saved }
       save(saved)
       @engine.emit_recap(recap: text, generation: job[:generation], covered: job[:covered], created_at: saved[:created_at])

data/lib/samagotchi/push_command.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require_relative "cli/command"
+require_relative "cli/exit"
+require_relative "cli/flags"
+require_relative "config"
+require_relative "web/push"
+require_relative "web/running"
+
+module Samagotchi
+  # `chi web push`: this machine's Web Push devices (Web::Push::Store),
+  # without chi web running: list them, remove one, send a test push.
+  # Never prints an endpoint or keys: a device is its short id and chi's
+  # label. bin/chi branches here on `web push` before RunOptions (which
+  # would refuse the word); `chi --remote X web push` is refused before
+  # that (chi web runs on this machine only). See docs/cli.md.
+  class PushCommand
+    include CLI::Command
+
+    USAGE = <<~TEXT
+      Usage: chi web push <ls|rm|test> [options]
+        ls [--format json]   the devices chi web pushes to: id, label, origin, added, last delivery,
+                             last error, done turns; "stale" for another origin's (never sent to)
+        rm ID                remove a device (it turns the bell on again to come back)
+        test [ID]            a test push to ID, or to every device not stale (chi web need not run)
+      A device is added by the bell in the phone's Home Screen app (docs/configuration.md, Phone notifications).
+    TEXT
+
+    SUBCOMMANDS = %w[ls rm test].freeze
+
+    FLAGS = {
+      "ls" => CLI::Flags.new(help: HELP_WORDS) { |f| f.value "--format" },
+      "rm" => CLI::Flags.new(help: HELP_WORDS),
+      "test" => CLI::Flags.new(help: HELP_WORDS)
+    }.freeze
+
+    # @param store [Web::Push::Store, nil] this machine's by default
+    # @param origin [#call] → the public origin chi web runs on now (the
+    #   running one's, else web.public_url's), nil when neither
+    # @param client [#call, nil] (sub) → a Client for its origin; one
+    #   signed with the store's key by default
+    def initialize(argv, stdout: $stdout, stderr: $stderr, store: nil, origin: nil, client: nil)
+      @argv = argv.dup
+      @stdout = stdout
+      @stderr = stderr
+      @store = store || Web::Push::Store.new
+      @origin = origin || -> { PushCommand.current_origin }
+      @client = client
+    end
+
+    # The running chi web's https origin (a --tunnel's too), else
+    # web.public_url's; nil when neither.
+    def self.current_origin
+      Web::Running.live_public_url&.origin || Web::PublicUrl.from_config(url: Config.get("web.public_url"))&.origin
+    rescue Web::PublicUrl::Invalid
+      nil
+    end
+
+    # @return [Integer] 0 done, 1 refused (a store others can read, a
+    #   corrupt one, an unknown device, a failed test), 2 usage
+    def run
+      @sub = @argv[0]
+      if @sub.nil? || HELP_WORDS.include?(@sub)
+        @stdout.puts(USAGE)
+        return 0
+      end
+      return usage_error("unknown subcommand #{@sub}") unless SUBCOMMANDS.include?(@sub)
+
+      parsed = parse_flags(FLAGS.fetch(@sub), @argv[1..])
+      return parsed if parsed.is_a?(Integer)
+
+      send(:"run_#{@sub}", parsed.options, parsed.args)
+    rescue Web::Push::Store::Insecure, Web::Push::Store::Corrupt, Web::Push::Refused => e
+      error_line("#{command_name}: #{e.message}")
+      CLI::Exit::FAILED
+    end
+
+    private
+
+    def command_name = @sub && SUBCOMMANDS.include?(@sub) ? "chi web push #{@sub}" : "chi web push"
+    def usage_on_error = nil
+
+    def run_ls(options, args)
+      return usage_error("ls takes no arguments") unless args.empty?
+
+      format = options[:format]
+      return usage_error("unknown format #{format.inspect}: use --format text|json") unless [nil, "text", "json"].include?(format)
+
+      subs = devices
+      origin = @origin.call
+      if format == "json"
+        @stdout.puts(JSON.generate(subs.map { |sub| sub.public_h.merge(stale: stale?(sub, origin)) }))
+      elsif subs.empty?
+        @stdout.puts("no devices (turn the bell on in the phone's Home Screen app)")
+      else
+        print_table(subs, origin)
+      end
+      0
+    end
+
+    def run_rm(_options, args)
+      return usage_error("give one device ID (chi web push ls)") unless args.size == 1
+
+      devices
+      id = args.first
+      gone = Web::Push::Store.short_id?(id) && @store.remove_device(id)
+      return no_device(id) unless gone
+
+      @stdout.puts("#{gone.id}  #{gone.label}  removed")
+      0
+    end
+
+    def run_test(_options, args)
+      return usage_error("give at most one device ID (chi web push ls)") if args.size > 1
+
+      subs = devices
+      if args.empty?
+        origin = @origin.call
+        subs = subs.reject { |sub| stale?(sub, origin) }
+        if subs.empty?
+          error_line("#{command_name}: no device to push to (chi web push ls)")
+          return CLI::Exit::FAILED
+        end
+      else
+        subs = subs.select { |sub| sub.id == args.first }
+        return no_device(args.first) if subs.empty?
+      end
+      results = subs.map { |sub| test(sub) }
+      results.all? ? 0 : CLI::Exit::FAILED
+    end
+
+    # One test push, its line printed; a :gone device is removed (as the
+    # route does). @return [Boolean] delivered
+    def test(sub)
+      result = client_for(sub).deliver(sub, Web::Push::TEST_PAYLOAD, ttl: Web::Push::TEST_TTL, urgency: "high")
+      words = "#{result.status} #{result.code}#{" (#{result.ms} ms)" if result.ms}"
+      words += ": #{result.error}" if result.error && !result.ok?
+      if result.status == :gone
+        @store.remove(sub.id)
+        words += ": removed (the push service no longer knows it)"
+      else
+        @store.mark(sub.id, ok: result.ok?, error: result.ok? ? nil : (result.error || result.code))
+      end
+      @stdout.puts("#{sub.id}  #{sub.label}  #{words}")
+      result.ok?
+    end
+
+    def client_for(sub)
+      return @client.call(sub) if @client
+
+      Web::Push::Client.new(key: Web::Push.load_key(@store), contact: Web::Push.contact(sub.origin))
+    end
+
+    # The store's devices, after its permission check.
+    def devices
+      @store.check_permissions!
+      @store.subscriptions!
+    end
+
+    def no_device(id)
+      error_line("#{command_name}: no device #{id[0, 16]} (chi web push ls)")
+      CLI::Exit::FAILED
+    end
+
+    # Stale: made on another origin than chi web's now; none is when that
+    # isn't known.
+    def stale?(sub, origin) = !origin.nil? && sub.origin != origin
+
+    def print_table(subs, origin)
+      rows = subs.map do |sub|
+        [sub.id, sub.label.to_s, sub.origin.to_s, when_text(sub.created_at), when_text(sub.last_ok_at) || "never",
+         sub.done? ? "on" : "off", [stale?(sub, origin) ? "stale" : nil, sub.last_error].compact.join(", ")]
+      end
+      rows.unshift(["ID", "LABEL", "ORIGIN", "ADDED", "LAST OK", "DONE", "NOTE"])
+      widths = rows.transpose.map { |column| column.map(&:length).max }
+      rows.each { |row| @stdout.puts(row.zip(widths).map { |cell, width| cell.ljust(width) }.join("  ").rstrip) }
+    end
+
+    # An iso time as local "YYYY-MM-DD HH:MM"; nil for none.
+    def when_text(iso)
+      iso && Time.iso8601(iso).localtime.strftime("%Y-%m-%d %H:%M")
+    rescue ArgumentError
+      iso
+    end
+  end
+end

data/lib/samagotchi/recap_store.rb

@@ -8,7 +8,9 @@ require_relative "session"
 
 module Samagotchi
   # The idle recap saved with its session, in <session dir>/recap.json:
-  #   {text, covered, covered_digest, model, created_at}
+  #   {text, title, covered, covered_digest, model, created_at}
+  # (title: the auto title the recap reply led with, RecapTitle; absent in
+  # a recap saved before it, or when no reply gave one).
   # A separate file, so it never races the session-file save at the end of a
   # turn. Follows the Engine's current session (the REPL can switch).
   class RecapStore
@@ -77,11 +79,26 @@ module Samagotchi
       nil
     end
 
+    # What a session card or list row reads from the saved recap.
+    # +preview+: #preview's sentence; +title+: the auto title, or nil.
+    Card = Data.define(:preview, :title)
+
+    # @return [Card] the saved recap's preview and auto title, from one
+    #   read (both nil when there is no recap)
+    def self.card(session_dir)
+      data = read(session_dir)
+      title = data&.dig(:title).to_s.gsub(/\s+/, " ").strip
+      Card.new(preview: preview_of(data), title: title.empty? ? nil : title)
+    end
+
     # @return [String, nil] the first sentence of the recap saved in
     #   +session_dir+, on one line, without the subject phrase (SUBJECT_RE)
     #   and cut to PREVIEW_CHARS. The full recap keeps its sentence.
-    def self.preview(session_dir)
-      text = read(session_dir)&.dig(:text).to_s.gsub(/\s+/, " ").strip
+    def self.preview(session_dir) = preview_of(read(session_dir))
+
+    # #preview of a recap already read (RecapStore.read's hash, or nil).
+    def self.preview_of(data)
+      text = data&.dig(:text).to_s.gsub(/\s+/, " ").strip
       return nil if text.empty?
 
       first = text[/\A.*?[.!?](?=\s|\z)/] || text

data/lib/samagotchi/recap_title.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # The auto title the recap reply leads with (IdleRecap::RecapPrompt::TITLE):
+  # "Title: <2-6 words>", a blank line, then the recap. #split takes the
+  # title line off, so the recap text the bubble, /recap, a continue's carry
+  # note and the next "Earlier recap:" read never holds it. A title line
+  # last is taken too (the spike's last-line arm put it there; a model may
+  # drift). A title that isn't 2-6 words or names an actor is no title, but
+  # its line still goes. Never raises.
+  module RecapTitle
+    LABEL = "Title:"
+    # As long as a card's title shows on a phone without wrapping twice.
+    MAX_CHARS = 60
+    WORDS = (2..6)
+    # "Title: Foo", "**Title:** Foo", "## Title: Foo" (a colon only: a
+    # recap may open "Title-casing the headings…").
+    LINE_RE = /\A[\s*_#>]*title[\s*_]*:[\s*_]*(?<title>.*)\z/i
+    # An instruction echoed between the title and the recap (the spike's
+    # "Blank line follows title."), or "(blank line)": dropped.
+    ECHO_RE = /\A[\s*_(\[]*(?:a |the )?blank line\b[^\n]{0,40}\z/i
+    # A "Recap:" label before the recap's first sentence: dropped, the
+    # sentence kept.
+    RECAP_LABEL_RE = /\A[\s*_#]*recap[\s*_]*:[\s*_]*/i
+    # The recap prompt's actors (RecapPrompt::SYSTEM: no "the user", no "the
+    # assistant", no "I", no "we"). A bare "User" or "Chi" stays: "User
+    # settings page", "Chi web push devices" name things.
+    ACTOR_RE = /\A(?:the\s+(?:user|assistant)(?:'s)?|(?:user|assistant)'s|i|we|you)(?=\s|\z)/i
+    QUOTES = "\"'`“”‘’«»"
+
+    # A reply split in two: +title+ nil when it has none (or none that
+    # passes), +body+ the recap without the title line.
+    Split = Data.define(:title, :body)
+
+    module_function
+
+    # @param text [String] the recap model's reply
+    # @return [Split]
+    def split(text)
+      lines = text.to_s.strip.lines(chomp: true)
+      if lines.first && LINE_RE.match?(lines.first)
+        title = lines.shift[LINE_RE, :title]
+        lines = lead_cleaned(lines)
+      elsif lines.size > 1 && LINE_RE.match?(lines.last)
+        title = lines.pop[LINE_RE, :title]
+      else
+        return Split.new(title: nil, body: text.to_s.strip)
+      end
+      Split.new(title: clean(title), body: lines.join("\n").strip)
+    rescue StandardError
+      Split.new(title: nil, body: text.to_s.strip)
+    end
+
+    # The title as a card shows it: markup, quotes and a closing period
+    # gone, one line, cut at MAX_CHARS; nil when it isn't 2-6 words or
+    # starts with an actor.
+    def clean(raw)
+      title = raw.to_s.gsub(/[*_#]+/, " ").gsub(/\s+/, " ").strip
+      title = title.delete_prefix(title[0]).delete_suffix(title[-1]).strip while quoted?(title)
+      title = title.sub(/[.。]+\z/, "").strip
+      return nil unless WORDS.cover?(title.split.size)
+      return nil if ACTOR_RE.match?(title)
+
+      title.length > MAX_CHARS ? "#{title[0, MAX_CHARS - 1].rstrip}…" : title
+    end
+
+    def quoted?(title) = title.length > 1 && QUOTES.include?(title[0]) && QUOTES.include?(title[-1])
+
+    # Blank lines, echoed instructions and a "Recap:" label before the recap.
+    def lead_cleaned(lines)
+      lines = lines.drop_while { |line| line.strip.empty? || ECHO_RE.match?(line) }
+      return lines if lines.empty?
+
+      first = lines.first.sub(RECAP_LABEL_RE, "")
+      first.strip.empty? ? lead_cleaned(lines.drop(1)) : [first, *lines.drop(1)]
+    end
+  end
+end

data/lib/samagotchi/run_options.rb

@@ -154,6 +154,7 @@ module Samagotchi
                  chi bootstrap [HOST[:PORT]|URL]  first setup: find the model server, write config.yml
                  chi scratch [options]            a one-time session in this terminal: nothing is kept
                  chi web [--port PORT] [--open] [--scope=all]   the web UI
+                 chi web push <ls|rm|test>        the phones chi web pushes notifications to
                  chi sessions <list|stop|restart|archive|unarchive|delete|prune|clean|stats>
                  chi note [--source NAME] [-m TEXT] ID...|--all   background context for sessions
                  chi broadcast [-m TEXT] [--all] [--dry-run] | log | deliver   a note for every session it may concern

data/lib/samagotchi/session_manager.rb

@@ -308,12 +308,13 @@ module Samagotchi
     # @param exclude [String, nil] a session id to leave out (the asker)
     # @param include_archived [Boolean] archived sessions too
     # @return [Array<Hash>] {id:, short_id:, desc:, preview:, cwd:, project:,
-    #   updated_at:, status:, live:, busy:, owner:, recap:, parent_id:,
+    #   updated_at:, status:, live:, busy:, owner:, recap:, auto_title:, parent_id:,
     #   parent_short_id:, continues:, continues_short_id:, delegate:, archived:, scratch:, test_run:, waiting:,
     #   waiting_id:, stopped_by:}; busy =
     #   live with a turn running, delegate = started by the delegate tool
     #   (Session#delegate?; a fork has a parent_id but isn't one), continues = the session it continues (the
-    #   previous link of its chain, Session#continues), recap = the saved recap's first sentence, project =
+    #   previous link of its chain, Session#continues), recap = the saved recap's first sentence, auto_title =
+    #   the auto title its reply led with (RecapTitle) or nil, project =
     #   Session#project_root, waiting = the kind of question it waits on
     #   ("question", "approval", "hook"; Session#waiting_question) or nil,
     #   waiting_id = that question's id or nil, relayed_to = the parent
@@ -339,7 +340,7 @@ module Samagotchi
 
         { id: s.id, short_id: s.id[0, 8], desc: summary_desc(s), preview: summary_preview(s), title: s.title, cwd: s.working_directory,
           project: s.project_root(cache: roots), updated_at: s.updated_at, status: s.status, live: owned, busy: owned && s.status == Session::STATUS_RUNNING,
-          owner: owner&.kind, recap: RecapStore.preview(Session.session_dir(s.id, state_dir: sd)),
+          owner: owner&.kind, **recap_fields(Session.session_dir(s.id, state_dir: sd)),
           ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd),
                                                     budget_tokens: -> { budgets.call(s) })&.round(1),
           parent_id: s.parent_id, parent_short_id: s.parent_id&.[](0, 8), continues: s.continues,
@@ -478,6 +479,12 @@ module Samagotchi
       cut(desc, SUMMARY_DESC_LIMIT)
     end
 
+    # A session row's recap: and auto_title: (RecapStore.card, one read).
+    private_class_method def self.recap_fields(session_dir)
+      card = RecapStore.card(session_dir)
+      { recap: card.preview, auto_title: card.title }
+    end
+
     private_class_method def self.summary_preview(session)
       cut(summary_text(session), SUMMARY_PREVIEW_LIMIT)
     end

data/lib/samagotchi/sessions_command.rb

@@ -217,12 +217,13 @@ module Samagotchi
         # scratch: a `chi scratch` session (deleted when its REPL ends, a
         # leftover one at the next sweep)
         # ctx_pct: how full the context was after the last turn, or nil
-        # title: the session's own name (/title; desc shows it too), or nil
+        # title: the session's own name (/title; desc shows it too), or nil;
+        # auto_title: the one its recap gave it (RecapTitle), or nil
         # waiting: the kind of question it waits on (question, approval,
         # hook: chi answer or the web answers it), or nil; waiting_id: its
         # id, for chi answer --question; relayed_to: the parent session (short
         # id) whose card it also waits in (the approval relay), or nil
-        keys = %i[id short_id desc title cwd project updated_at live busy owner recap parent_id continues delegate archived scratch ctx_pct
+        keys = %i[id short_id desc title auto_title cwd project updated_at live busy owner recap parent_id continues delegate archived scratch ctx_pct
                   waiting waiting_id relayed_to stopped_by]
         @stdout.puts JSON.generate(summaries.map { |summary| summary.slice(*keys) })
       when "tsv"
@@ -234,12 +235,13 @@ module Samagotchi
                   elsif summary[:busy] then "running"
                   else summary[:live] ? "live" : summary[:status].to_s
                   end
-          # The saved recap's first sentence says more than the last prompt
-          # (text only: tsv and json keep desc for pickers); a title (in
-          # desc) says what the user named it.
+          # The recap's auto title, else its first sentence, says more than
+          # the last prompt (text only: tsv and json keep desc for pickers);
+          # a title (in desc) says what the user named it.
           desc = summary[:desc]
-          if summary[:recap] && !summary[:title]
-            desc = [File.basename(summary[:cwd].to_s), summary[:recap]].reject(&:empty?).join(" · ")
+          named = summary[:auto_title] || summary[:recap]
+          if named && !summary[:title]
+            desc = [File.basename(summary[:cwd].to_s), named].reject(&:empty?).join(" · ")
             desc = "#{desc[0, 59]}…" if desc.length > 60
           end
           # A delegated session points at its parent.
@@ -265,15 +267,16 @@ module Samagotchi
       sort ||= "updated_at"
       order ||= "desc"
       sessions = @access.list(sort: sort, order: order, limit: limit, project_root: project, include_archived: include_archived)
-      # The session's title, else the saved recap's first sentence, else the
-      # last prompt (or the first message, before any turn), cut as before.
+      # The session's title, else the recap's auto title, else its first
+      # sentence, else the last prompt (or the first message, before any
+      # turn), cut as before.
       # These rows read each session's folder here (its recap, saved
       # context, owner): machine-local, the server's rows remotely (P2's
       # list parity).
       state_dir = Samagotchi::Session.default_state_dir
       list_text = lambda do |s|
-        recap = s.title ? nil : Samagotchi::RecapStore.preview(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
-        (recap || Samagotchi::SessionManager.summary_text(s))[0, 60]
+        card = s.title ? nil : Samagotchi::RecapStore.card(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
+        (card&.title || card&.preview || Samagotchi::SessionManager.summary_text(s))[0, 60]
       end
       # How full the context was after the last turn: "ctx 12%", counted
       # against the session's llm_context budget when one is set and smaller

data/lib/samagotchi/title_command.rb

@@ -48,10 +48,15 @@ module Samagotchi
 
     private
 
-    # "title: Coordinator", or "title: none (shows the first message: hey chi …)"
+    # "title: Coordinator", "title: none (shows the auto title: Parser tab
+    # handling)" (the recap's, RecapTitle), or "title: none (shows the
+    # first message: hey chi …)"
     def listing(session)
       return "title: #{session.title}" if session.title
 
+      auto = @engine.recap&.state&.dig(:title)
+      return "title: none (shows the auto title: #{auto})" if auto
+
       preview = session.first_preview.to_s
       "title: none (shows #{preview.empty? ? "the first message" : "the first message: #{preview}"})"
     end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -273,6 +273,7 @@ module Samagotchi
         ["DELETE", %r{\A/api/push/subscriptions\z}, :handle_push_unsubscribe, :owner],
         # The id checked in the handler (participant_gate_spec fills ([^/]+) captures only).
         ["PATCH", %r{\A/api/push/subscriptions/([^/]+)\z}, :handle_push_prefs, :owner],
+        ["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/sessions/([^/]+)\z}, :handle_show, :participant, :session],
@@ -617,16 +618,58 @@ module Samagotchi
         log_refused(refused_peer(req), req.path_info, reason)
         return error_response(401, "unauthorized", unauthorized_detail(req, reason)) if req.path_info.start_with?("/api/")
 
-        body = @public_url ? PUBLIC_UNAUTHORIZED_PAGE : UNAUTHORIZED_PAGE
+        body = unauthorized_page(req)
         [401, { "Content-Type" => "text/html; charset=utf-8", "Content-Length" => body.bytesize.to_s, "Cache-Control" => "no-store" },
          [body]]
       end
 
+      # Which page a refused page request gets: the LAN page with no
+      # web.public_url, the proxy page for a request that came through it,
+      # and for a browser on this machine the one pointing at the public
+      # address (#direct_public?): there the paste box can't help.
+      def unauthorized_page(req)
+        return direct_public_page if direct_public?(req)
+        return PUBLIC_UNAUTHORIZED_PAGE if @public_url
+
+        UNAUTHORIZED_PAGE
+      end
+
+      # A browser on this machine, with web.public_url set: the gate refuses
+      # it like every other request, and no trade can fix it here — loopback
+      # takes the token as Bearer only, so there is no cookie for it to keep
+      # (a cookie for 127.0.0.1 reaches every server on any local port). The
+      # page says where to open chi web instead. The origin is this machine's
+      # config, not a secret; it is escaped all the same, and no token or
+      # link code is in it.
+      def direct_public_page
+        origin = CGI.escapeHTML(@public_url.origin)
+        <<~HTML
+          <!doctype html>
+          <html lang="en"><head><meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <title>chi web: open it at its public address</title>
+          <style>
+            :root { color-scheme: light dark; }
+            body { font: 16px/1.5 -apple-system, system-ui, sans-serif; max-width: 30rem; margin: 3rem auto; padding: 0 1rem; }
+            a { color: inherit; }
+          </style></head>
+          <body>
+          <h1>chi web</h1>
+          <p>chi web is behind an access proxy, so every request needs its access token, this machine's too.
+          A browser here can't trade a token for a cookie on 127.0.0.1, so this page can't let you in: open
+          chi web at its public address instead.</p>
+          <p><a href="#{origin}/">#{origin}/</a></p>
+          <p>chi web prints a link to it in its terminal every time it starts.</p>
+          </body></html>
+        HTML
+      end
+
       def unauthorized_detail(req, reason)
         return "chi web behind the proxy: #{reason || "needs its access token"}" if proxied?(req)
-        return "chi web with web.public_url needs its access token, on this machine too" if @public_url
+        return "chi web on the LAN needs its access token" unless @public_url
 
-        "chi web on the LAN needs its access token"
+        detail = "chi web with web.public_url needs its access token, on this machine too"
+        direct_public?(req) ? "#{detail}; open its public address #{@public_url.origin}/ instead" : detail
       end
 
       # Who a refusal is logged as: the peer, or behind a proxy (every peer

data/lib/samagotchi/web/markdown_renderer.rb

@@ -7,6 +7,11 @@ module Samagotchi
   module Web
     class MarkdownRenderer
       WARNING = "Markdown rendering is enabled, but the optional commonmarker gem is not installed. Install it with: gem install commonmarker"
+      # The session view's tip while rendering is off (#tip): how to turn it
+      # on, the gem first when it isn't installed. Each fits two lines on a
+      # phone (390px), hence the short lead and the gem one without config.yml.
+      TIP = "Markdown answers: restart chi web with --web-markdown (or web.markdown: true in config.yml)."
+      TIP_GEM = "Markdown answers: gem install commonmarker, then restart chi web with --web-markdown."
       # NOTE: `span` is allowed because the syntax highlighter (commonmarker/syntect)
       # emits classed <span>s; keeping it lets highlighting render.
       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
@@ -29,6 +34,15 @@ module Samagotchi
         WARNING if enabled? && !load_bundled_commonmarker!
       end
 
+      # The tip while rendering is off, nil when it is on. Whether the gem is
+      # installed is read from its gemspec, not by loading it: a server that
+      # won't render has no use for the native extension.
+      def tip
+        return nil if enabled?
+
+        commonmarker_installed? ? TIP : TIP_GEM
+      end
+
       def render(markdown)
         return nil unless available?
 
@@ -57,6 +71,12 @@ module Samagotchi
         @commonmarker_available = false
       end
 
+      def commonmarker_installed?
+        return @commonmarker_installed unless @commonmarker_installed.nil?
+
+        @commonmarker_installed = Gem::Specification.find_all_by_name("commonmarker").any?
+      end
+
       def sanitize(html)
         fragment = Nokogiri::HTML5.fragment(html)
         fragment.traverse do |node|