samagotchi 0.139.1 → 0.141.0

data/lib/samagotchi/context_candidates.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "context_absorber"
+require_relative "context_candidates_log"
+require_relative "context_fetch"
+require_relative "context_providers"
+require_relative "context_sources"
+require_relative "log"
+require_relative "owner_prompt"
+
+module Samagotchi
+  # A session's pool of candidate context (ContextSources::Candidate, from
+  # ctx.context.propose) and the one thing that attaches one in slice 1:
+  # the owner mentioning it. A candidate's status is derived, never stored:
+  # attached while a source of its name (or its URL) is attached, declined
+  # while the user's declined marker names it (or its URL), else proposed.
+  #
+  # Mentions (#mention_in): whole tokens, any case; a "#N" only for N ≥ 10
+  # or right after "PR" / "pull" ("PR #4"); any other word (a branch) only
+  # when it is at least 6 characters and holds a /, - or _; a URL exactly.
+  # Text inside fenced code blocks (pasted logs) never counts.
+  #
+  # Only the owner's own prompts count (OwnerPrompt), and nothing happens in
+  # a review session: a participant never attaches a source to the owner's
+  # session.
+  module ContextCandidates
+    STATUSES = %w[proposed attached declined].freeze
+    # How long a turn waits for a mention-attached source's first text, so
+    # its note lands in the turn that mentioned it; past it the note comes
+    # with a later turn.
+    FIRST_FETCH_SECONDS = 10
+    BRANCH_MIN_CHARS = 6
+    NUMBER_MIN = 10
+    # A fenced code block's opening line (up to 3 spaces, then ``` or ~~~).
+    FENCE_OPEN = /\A {0,3}(`{3,}|~{3,})/
+    # What may sit around a word-like mention without joining it.
+    WORD_BEFORE = %r{(?<![\w./#-])}
+    WORD_AFTER = %r{(?![\w/-])(?!\.[\w/-])}
+    # A candidate attached from a mention, and the mention.
+    Hit = Data.define(:candidate, :mention)
+
+    module_function
+
+    # @param attached [Array<ContextSources::Attached>] what the session sees
+    # @return [String] "attached", "declined" or "proposed"
+    def status(candidate, own:, attached:)
+      if attached.any? { |a| a.name == candidate.name || (candidate.url && a.source.hint == candidate.url) }
+        return "attached"
+      end
+      return "declined" if own.declined?(candidate.name) || (candidate.url && own.declined_hints.include?(candidate.url))
+
+      "proposed"
+    end
+
+    # The session's candidates with their status, by name.
+    # @return [Array<Array(ContextSources::Candidate, String)>]
+    def with_status(session_id, project_root:, state_dir: nil)
+      own = ContextSources.session_location(session_id, state_dir: state_dir)
+      candidates = own.candidates
+      return [] if candidates.empty?
+
+      attached = ContextSources.attached(session_id, project_root: project_root, state_dir: state_dir, shadowed: true)
+      candidates.map { |candidate| [candidate, status(candidate, own: own, attached: attached)] }
+    end
+
+    # The candidates section of /context, nil for none.
+    def listing(session_id, project_root:, state_dir: nil)
+      rows = with_status(session_id, project_root: project_root, state_dir: state_dir)
+      return nil if rows.empty?
+
+      lines = rows.map { |candidate, state| "- #{candidate.name} · #{state} · #{candidate.title}" }
+      "Candidates (attached when a prompt of yours mentions one, or by /context attach NAME):\n#{lines.join("\n")}"
+    end
+
+    # The words in +text+ that name +candidate+: its first mention found,
+    # or nil.
+    def mention_in(text, candidate)
+      plain = without_fences(text.to_s)
+      return nil if plain.strip.empty?
+
+      candidate.mentions.find { |mention| (pattern = pattern_for(mention)) && plain.match?(pattern) }
+    end
+
+    # The regexp a mention matches by, nil for one that never matches (a
+    # short or plain word).
+    def pattern_for(mention)
+      mention = mention.to_s.strip
+      if (number = mention[/\A#(\d+)\z/, 1])
+        return /(?<![\w&#])##{number}(?!\w)/ if number.to_i >= NUMBER_MIN
+
+        return /\b(?:pr|pull(?:\s+request)?)\s*##{number}(?!\w)/i
+      end
+      return %r{(?<![\w/.:-])#{Regexp.escape(mention)}(?![\w/#?=&%-])} if mention.match?(%r{\Ahttps?://}i)
+      return nil if mention.length < BRANCH_MIN_CHARS || !mention.match?(%r{[/_-]})
+
+      /#{WORD_BEFORE}#{Regexp.escape(mention)}#{WORD_AFTER}/i
+    end
+
+    # +text+ with its fenced code blocks blanked out.
+    def without_fences(text)
+      out = +""
+      open = nil
+      text.each_line do |line|
+        marker = line[FENCE_OPEN, 1]
+        if open.nil? && marker
+          open = marker
+        elsif open && marker && marker[0] == open[0] && marker.length >= open.length && line.strip == marker
+          open = nil
+        elsif open.nil?
+          out << line
+        end
+      end
+      out
+    end
+
+    # The owner's own prompts in +messages+ (OwnerPrompt.message?), as text.
+    def owner_texts(messages)
+      Array(messages).filter_map do |message|
+        next unless OwnerPrompt.message?(message)
+
+        content = message.is_a?(Hash) ? (message[:content] || message["content"]) : nil
+        content.is_a?(String) ? content : nil
+      end
+    end
+
+    # The proposed candidates +texts+ mention (the first text that does,
+    # newest first), one hit each.
+    # @return [Array<Hit>]
+    def hits(texts, candidates)
+      candidates.filter_map do |candidate|
+        mention = texts.reverse_each.lazy.filter_map { |text| mention_in(text, candidate) }.first
+        mention && Hit.new(candidate: candidate, mention: mention)
+      end
+    end
+
+    # Attaches +hit+'s candidate to the session's own folder, its why naming
+    # the mention (a mentioned line in ContextCandidatesLog, in +state_dir+'s
+    # log). A source of its name there already stays.
+    # @return [String, nil] the name, nil when it couldn't be attached
+    def attach(hit, own:, state_dir: nil)
+      candidate = hit.candidate
+      own.add(source_for(candidate, why: "you mentioned #{hit.mention}"))
+      Log.info(:context, "candidate_attached", name: candidate.name, trigger: "mention")
+      ContextCandidatesLog.event("mentioned", session_id: own.key, name: candidate.name, state_dir: state_dir,
+                                              mention: hit.mention)
+      candidate.name
+    rescue ContextSources::Invalid, ContextProviders::Invalid => e
+      return candidate.name if own.source(candidate.name)
+
+      Log.warn(:context, "candidate_not_attached", name: candidate.name, error: e.message.to_s[0, 200])
+      nil
+    end
+
+    # The Source a candidate becomes: through its URL's provider, else its
+    # own command.
+    # @raise [ContextProviders::Invalid] no installed bundle resolves its URL
+    def source_for(candidate, why:)
+      fields = { name: candidate.name, why: why, scope: "session", added_by: candidate.proposed_by,
+                 created_at: Time.now.utc.iso8601, title: candidate.title }
+      if candidate.url
+        resolved = ContextProviders.resolve(candidate.url) or
+          raise ContextProviders::Invalid, "no installed bundle resolves #{candidate.url}"
+        return ContextSources::Source.new(cmd: resolved.cmd, hint: resolved.hint, every_seconds: resolved.every_seconds,
+                                          provider: resolved.bundle, **fields)
+      end
+      ContextSources::Source.new(cmd: candidate.cmd, hint: nil, every_seconds: nil, provider: nil, **fields)
+    end
+
+    # The proposed candidates (no source of theirs attached, not declined).
+    def proposed(session_id, project_root:, state_dir: nil)
+      with_status(session_id, project_root: project_root, state_dir: state_dir)
+        .filter_map { |candidate, state| candidate if state == "proposed" }
+    end
+
+    # Turn start (Worker#run_prompt before its absorb; the REPL's turn):
+    # the proposed candidates +prompt+ (or an earlier owner prompt: a late
+    # proposal) mentions are attached, then each gets one first fetch
+    # (together within +seconds+), so the note reaches this turn. Only an
+    # owner's turn (OwnerPrompt.turn?). Also fetches a candidate attached
+    # since the last turn whose source has never been tried.
+    # @param session [Session]
+    # @param cancelled [#call] true: stop waiting (the session was stopped)
+    # @return [Array<String>] the names attached now
+    def before_turn(session:, prompt:, author:, state_dir: nil, seconds: FIRST_FETCH_SECONDS, cancelled: -> { false })
+      return [] unless session&.id
+
+      own = ContextSources.session_location(session.id, state_dir: state_dir)
+      return [] if own.candidates.empty? || !OwnerPrompt.turn?(session: session, author: author)
+
+      # The earlier owner prompts too: a proposal that came while one ran
+      # (the REPL's plugins never see a running turn's prompt).
+      texts = owner_texts(session.messages) + (prompt.is_a?(String) ? [prompt] : [])
+      found = hits(texts, proposed(session.id, project_root: session.project_root, state_dir: state_dir))
+      names = found.filter_map { |hit| attach(hit, own: own, state_dir: state_dir) }
+      first_fetch(own, unfetched(own, names), cwd: session.working_directory, seconds: seconds, cancelled: cancelled)
+      names
+    rescue StandardError => e
+      Log.warn(:context, "candidates_turn_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      []
+    end
+
+    # The REPL's turn start (it has no ContextAbsorber running): the notes
+    # of the sources attached from candidates, as the worker's absorb gives
+    # them, added to +engine+'s session and marked delivered.
+    # @return [Integer] how many notes were added
+    def deliver_notes(engine, session, state_dir: nil)
+      own = ContextSources.session_location(session.id, state_dir: state_dir)
+      names = own.candidates.map(&:name)
+      return 0 if names.empty?
+
+      absorber = ContextAbsorber.new(session_id: session.id, state_dir: state_dir, project_root: session.project_root)
+      batch = absorber.pending or return 0
+      picked = batch.deliveries.select { |delivery| names.include?(delivery.name) }
+      picked.each { |delivery| engine.add_context_note(session, delivery.note) if delivery.note }
+      absorber.commit(batch.with(deliveries: picked))
+      picked.count(&:note)
+    end
+
+    # A late proposal (ctx.context.propose, after the owner's prompts):
+    # attached now when one of them mentions it; the session's next turn
+    # delivers its note.
+    # @return [String, nil] the name attached
+    def after_propose(candidate, own:, messages:, state_dir: nil)
+      hit = hits(owner_texts(messages), [candidate]).first or return nil
+
+      attach(hit, own: own, state_dir: state_dir)
+    end
+
+    # The session sources from candidates (+names+, and any other
+    # candidate's source) never tried yet.
+    def unfetched(own, names)
+      wanted = (names + own.candidates.map(&:name)).uniq
+      wanted.filter_map do |name|
+        source = own.source(name) or next
+        next if source.push? || own.snapshot(name).checked_at
+
+        ContextSources::Attached.new(source: source, location: own, shadowed: false)
+      end
+    end
+
+    # Runs each source's first fetch, all within +seconds+; one a poller
+    # fetches meanwhile (:busy) is waited for. Cut short, a fetch records
+    # nothing (the poller tries it soon); the note then comes later.
+    def first_fetch(own, list, cwd:, seconds:, cancelled:)
+      return if list.empty?
+
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
+      over = -> { cancelled.call || Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline }
+      list.each do |attached|
+        outcome = ContextFetch.fetch(attached, cwd: cwd, cancelled: over)
+        sleep(0.05) while outcome.status == :busy && !own.snapshot(attached.name).checked_at && !over.call
+        next unless over.call && !own.snapshot(attached.name).text?
+
+        Log.info(:context, "candidate_first_fetch_late", name: attached.name, seconds: seconds)
+      end
+    end
+  end
+end

data/lib/samagotchi/context_candidates_log.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "log"
+require_relative "session"
+require_relative "side_judgments"
+
+module Samagotchi
+  # The candidates' record, `context_candidates.jsonl` in the state dir
+  # (beside the sessions folder; SideJudgments.log: 0600, one line under a
+  # lock, the oldest half dropped past 5 MB): what happened to each
+  # session's candidates, for `chi context report` (ContextReportCommand).
+  # Local only: nothing here leaves the machine, so it is written in every
+  # context.candidates.mode, off too.
+  #
+  # Kinds (every line has session_id, name and at):
+  # - proposed: a plugin's ctx.context.propose recorded it (title, by)
+  # - mentioned: an owner prompt named it and it was attached (mention)
+  # - judged: System 1's ask (ContextJudge.ask: p, task_p, stated, would, …)
+  # - judge_attached: on mode attached it (p ≥ threshold; p)
+  # - carded: on mode showed its card (the middle band; p): once per
+  #   candidate, read back by ContextCandidateChoice.carded?
+  # - attached / declined with by "command": /context attach|decline NAME
+  #   (the card's buttons)
+  # - attached / declined / detached with by "user": the derived status
+  #   changed since the last line said otherwise, seen at an owner turn's
+  #   start (#look): the user's own doing (chi context add, chi web's chip
+  #   ×, chi context rm; a removed source is declined)
+  # - withdrawn: the plugin took the candidate back
+  module ContextCandidatesLog
+    FILE = "context_candidates.jsonl"
+    # What a logged prompt keeps of its text.
+    PROMPT_MAX = 200
+    # The status each kind leaves a candidate in (#statuses).
+    STATUS_OF = { "proposed" => "proposed", "mentioned" => "attached", "judge_attached" => "attached", "attached" => "attached",
+                  "declined" => "declined", "detached" => "proposed", "withdrawn" => nil }.freeze
+
+    module_function
+
+    # @param state_dir [String, nil] the sessions folder (Session.default_state_dir)
+    def path(state_dir = nil) = File.join(File.dirname(state_dir || Session.default_state_dir), FILE)
+
+    # @return [SystemOne::Log]
+    def log_for(state_dir = nil) = SideJudgments.log(path(state_dir), tag: :context, event: "context_candidates_log_failed")
+
+    # One line; never raises.
+    # @return [Boolean] whether it was written
+    def event(kind, session_id:, name:, state_dir: nil, log: nil, **fields)
+      (log || log_for(state_dir)).entry(kind, { "session_id" => session_id.to_s, "name" => name.to_s }.merge(fields.compact))
+    rescue StandardError => e
+      Log.warn(:context, "context_candidates_log_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      false
+    end
+
+    # +session_id+'s lines, oldest first.
+    def records_for(log, session_id) = log.records.select { |line| line["session_id"] == session_id.to_s }
+
+    # The status the lines last left each candidate in, by name (a
+    # withdrawn one is gone).
+    # @return [Hash{String => String}]
+    def statuses(records)
+      records.each_with_object({}) do |line, known|
+        next unless STATUS_OF.key?(line["kind"])
+
+        status = STATUS_OF[line["kind"]]
+        status ? known[line["name"]] = status : known.delete(line["name"])
+      end
+    end
+
+    # The derived statuses now (+rows+: ContextCandidates.with_status)
+    # against the last ones logged: each change is a line (attached,
+    # declined, detached). A candidate never logged counts as proposed.
+    # @return [Array<String>] the kinds written
+    def look(log, session_id, rows, records)
+      known = statuses(records)
+      rows.filter_map do |candidate, status|
+        next if status == (known[candidate.name] || "proposed")
+
+        kind = status == "proposed" ? "detached" : status
+        event(kind, session_id: session_id, name: candidate.name, log: log, by: "user")
+        kind
+      end
+    end
+
+    # +text+ as a log line keeps it: one line, at most PROMPT_MAX chars.
+    def short(text)
+      line = text.to_s.gsub(/\s+/, " ").strip
+      line.length > PROMPT_MAX ? "#{line[0, PROMPT_MAX - 1]}…" : line
+    end
+  end
+end

data/lib/samagotchi/context_command.rb

@@ -5,6 +5,7 @@ require "time"
 require_relative "context_sources"
 require_relative "context_fetch"
 require_relative "context_providers"
+require_relative "context_report_command"
 require_relative "memory_paths"
 require_relative "session"
 require_relative "cli/command"
@@ -23,25 +24,28 @@ module Samagotchi
     include RedactedInspect
 
     USAGE = <<~TEXT
-      Usage: chi context <add|push|ls|show|refresh|rm|mute|unmute> [options] [TARGET]
-        add NAME (--cmd CMD | --push) [--every SECONDS] [--why TEXT] [--hint TEXT] TARGET
-        add URL [--why TEXT] [--hint TEXT] TARGET   a URL an installed bundle's provider knows (github-pr: a PR)
+      Usage: chi context <add|push|ls|show|refresh|rm|mute|unmute|report> [options] [TARGET]
+        add NAME (--cmd CMD | --push) [--every SECONDS] [--why TEXT] [--hint TEXT] [--[no-]movable] TARGET
+        add URL [--why TEXT] [--hint TEXT] [--[no-]movable] TARGET   a URL an installed bundle's provider knows (github-pr: a PR)
               a source: CMD prints its text (plain, or JSON {"text", "summary", "wake", "hint"});
               --push: text comes from chi context push. --every: how often CMD runs
               (seconds, at least 30; default context.every_seconds). --why: why it's attached;
               --hint: one line, often its URL. NAME: a-z, 0-9 and -, up to 40.
+              --movable / --no-movable: whether a continue or a fork takes it to the new
+              session (default: a --cmd or URL source moves, a --push one stays).
         push NAME [-m TEXT] [TARGET]        new text for a --push source (stdin without -m; text or JSON)
-        ls [TARGET] [--format json]         the sources, their age and state
+        ls [TARGET] [--format json]         the sources, their age and state; a session's candidates
         show NAME [--json] [TARGET]         the text (--json: the source and its snapshot)
         refresh NAME [TARGET]               run NAME's command now, here (a live worker absorbs the result)
         rm NAME TARGET                      detach a source
         mute|unmute NAME ID...              a project's source, ignored by one session
+        report [--days N]                   the candidate judge's counts (this machine's log)
       TARGET: session ids or unique prefixes, or --project (this git repository's
         sessions, all of them). Inside a chi session (its execute) the default is that
         session. Find ids with: chi sessions list [--live]
     TEXT
 
-    SUBCOMMANDS = %w[add push ls show refresh rm mute unmute].freeze
+    SUBCOMMANDS = %w[add push ls show refresh rm mute unmute report].freeze
 
     FLAGS = {
       "add" => CLI::Flags.new(help: HELP_WORDS) do |f|
@@ -50,6 +54,8 @@ module Samagotchi
         f.value "--every"
         f.value "--why"
         f.value "--hint"
+        f.switch "--movable"
+        f.switch "--no-movable", key: :movable, set: false
         f.switch "--project"
       end,
       "push" => CLI::Flags.new(help: HELP_WORDS) do |f|
@@ -67,7 +73,8 @@ module Samagotchi
       "refresh" => CLI::Flags.new(help: HELP_WORDS) { |f| f.switch "--project" },
       "rm" => CLI::Flags.new(help: HELP_WORDS) { |f| f.switch "--project" },
       "mute" => CLI::Flags.new(help: HELP_WORDS),
-      "unmute" => CLI::Flags.new(help: HELP_WORDS)
+      "unmute" => CLI::Flags.new(help: HELP_WORDS),
+      "report" => ContextReportCommand::FLAGS
     }.freeze
 
     # Where a command acts: a session (its own sources, then its project's)
@@ -106,6 +113,10 @@ module Samagotchi
         return 0
       end
       return usage_error("unknown subcommand #{@sub}") unless SUBCOMMANDS.include?(@sub)
+      # Its own command (its own flags and usage): this machine's log.
+      if @sub == "report"
+        return ContextReportCommand.new(@argv[1..], stdout: @stdout, stderr: @stderr, state_dir: @state_dir).run
+      end
 
       parsed = parse_flags(FLAGS.fetch(@sub), @argv[1..])
       return parsed if parsed.is_a?(Integer)
@@ -135,15 +146,27 @@ module Samagotchi
         name: name, cmd: options[:cmd], every_seconds: ContextSources.check_every!(options[:every]),
         why: ContextSources.one_line(options[:why], ContextSources::LINE_MAX_CHARS),
         hint: ContextSources.one_line(options[:hint], ContextSources::LINE_MAX_CHARS),
-        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601
+        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601, movable: options[:movable]
       )
       each_target(options, args) do |target|
-        @access.context_add(target, source)
+        add_to(target, source)
         @stdout.puts("#{target.label}  attached #{name}")
         true
       end
     end
 
+    # Attaches +source+ to +target+; a movable flag an older chi web
+    # dropped (its answer has no movable) is a warning: the source is
+    # attached with the default.
+    def add_to(target, source)
+      warn_movable_dropped(target, source.name) if @access.context_add(target, source).movable_dropped
+    end
+
+    def warn_movable_dropped(target, name)
+      error_line("#{command_name}: warning: the remote's chi web is too old for --movable/--no-movable: " \
+                 "#{name} on #{target.label} has the default (update chi there)")
+    end
+
     # A URL through the installed bundles' providers (ContextProviders):
     # the provider gives the name, command, hint and interval. Not gated
     # like --cmd (chi-context-cmd): the command is the bundle's.
@@ -160,10 +183,11 @@ module Samagotchi
         name: resolved.name, cmd: resolved.cmd, every_seconds: resolved.every_seconds,
         why: ContextSources.one_line(options[:why] || resolved.why, ContextSources::LINE_MAX_CHARS),
         hint: ContextSources.one_line(options[:hint] || resolved.hint, ContextSources::LINE_MAX_CHARS),
-        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601, provider: resolved.bundle
+        scope: nil, added_by: added_by, created_at: Time.now.utc.iso8601, provider: resolved.bundle,
+        movable: options[:movable]
       )
       each_target(options, args) do |target|
-        @access.context_add(target, source)
+        add_to(target, source)
         @stdout.puts("#{target.label}  attached #{source.name}")
         true
       end
@@ -176,8 +200,9 @@ module Samagotchi
       why = ContextSources.one_line(options[:why], ContextSources::LINE_MAX_CHARS)
       hint = ContextSources.one_line(options[:hint], ContextSources::LINE_MAX_CHARS)
       each_target(options, args) do |target|
-        name = @access.context_add_url(target, url, why: why, hint: hint, added_by: added_by)
-        @stdout.puts("#{target.label}  attached #{name}")
+        added = @access.context_add_url(target, url, why: why, hint: hint, added_by: added_by, movable: options[:movable])
+        warn_movable_dropped(target, added.name) if added.movable_dropped
+        @stdout.puts("#{target.label}  attached #{added.name}")
         true
       end
     rescue ContextProviders::Invalid => e
@@ -203,6 +228,9 @@ module Samagotchi
           # two fetches would read as a change and then vanish.
           error_line("#{command_name}: #{SessionAccess::ContextPush.not_push_message(name)}")
           next false
+        when :continued
+          error_line("#{command_name}: #{SessionAccess::ContextPush.continued_message(name, target.session_id, pushed.next_id)}")
+          next false
         end
 
         @stdout.puts("#{target.label}  #{name}: #{pushed.revision == pushed.before ? "unchanged" : "new text"} " \
@@ -217,16 +245,34 @@ module Samagotchi
 
       targets = targets(options, args) or return CLI::Exit::FAILED
       rows = targets.flat_map { |target| @access.context_entries(target).map { |entry| row(target, entry) } }
+      candidates = targets.flat_map { |target| @access.context_candidates(target).map { |entry| candidate_row(target, entry) } }
       if format == "json"
-        @stdout.puts(JSON.pretty_generate(rows))
-      elsif rows.empty?
-        @stdout.puts("no attached context")
+        @stdout.puts(JSON.pretty_generate(rows + candidates))
       else
-        print_rows(rows, labels: targets.size > 1)
+        rows.empty? ? @stdout.puts("no attached context") : print_rows(rows, labels: targets.size > 1)
+        print_candidates(candidates, labels: targets.size > 1)
       end
       0
     end
 
+    # A candidate's line of ls (its --format json object, marked candidate).
+    # @param entry [SessionAccess::ContextCandidate]
+    def candidate_row(target, entry)
+      candidate = entry.candidate
+      { "target" => target.label, "session_id" => target.session_id, "candidate" => true, "name" => candidate.name,
+        "status" => entry.status, "title" => candidate.title, "url" => candidate.url, "cmd" => candidate.cmd,
+        "mentions" => candidate.mentions, "proposed_by" => candidate.proposed_by, "at" => candidate.at }.compact
+    end
+
+    def print_candidates(rows, labels:)
+      return if rows.empty?
+
+      @stdout.puts("candidates (attached when the session's owner mentions one):")
+      lines = rows.map { |r| [*(labels ? [r["target"]] : []), r["name"], r["status"], r["title"].to_s] }
+      widths = lines.transpose.map { |column| column.map(&:length).max }
+      lines.each { |line| @stdout.puts("  #{line.zip(widths).map { |cell, w| cell.ljust(w) }.join("  ").rstrip}") }
+    end
+
     def run_show(options, args)
       name = args.shift
       return usage_error("give the source's NAME") unless name
@@ -427,7 +473,8 @@ module Samagotchi
         "cmd" => source.cmd, "every_seconds" => source.every_seconds, "why" => source.why, "hint" => source.hint,
         "added_by" => source.added_by, "created_at" => source.created_at, "fetched_at" => snapshot.fetched_at,
         "revision" => snapshot.revision, "summary" => snapshot.summary, "error" => snapshot.error,
-        "muted" => entry.muted, "shadowed" => entry.shadowed, "unread" => entry.unread }.compact
+        "muted" => entry.muted, "shadowed" => entry.shadowed, "unread" => entry.unread,
+        "movable" => (source.movable? if source.scope == "session") }.compact
     end
 
     def print_rows(rows, labels:)
@@ -440,6 +487,7 @@ module Samagotchi
                 else
                   "ok"
                 end
+        state = "#{state} · stays" if r["movable"] == false
         [*(labels ? [r["target"]] : []), r["name"], r["scope"], kind, age(r["fetched_at"]), state, r["why"].to_s]
       end
       widths = lines.transpose.map { |column| column.map(&:length).max }