samagotchi 0.96.0 → 0.97.0

data/lib/samagotchi/memory_bundle/profile.rb

@@ -80,7 +80,7 @@ module Samagotchi
       # "Shipped notes").
       def kept_own_line(member, file)
         "#{member}: kept your own #{file} (not the bundle's; to take the bundle's, remove yours with " \
-          "memory_write remove: true, then chi bundle install #{member})"
+          "chi memory rm #{file.delete_suffix(".md")} --scope system, then chi bundle install #{member})"
       end
 
       # The one rule.
@@ -121,19 +121,29 @@ module Samagotchi
         member_dir = File.join(shipped_dir, member)
         failure = Manifest.requires_chi_failure(Manifest.read(dir: member_dir).requires_chi, chi_version)
         return result.skipped[member] = failure if failure
-        return result.installed << member if dry_run
 
+        # A dry run runs the Installer's too, which writes nothing, so it
+        # names the files the real run would keep as the user's own.
         installer = Installer.new(source: member_dir, name: member, scope: "system", force: force, strict: true,
-                                  shipped_dir: shipped_dir)
+                                  shipped_dir: shipped_dir, dry_run: dry_run)
         installer.run
         result.installed << member
-        kept = installer.results.select { |_, entry| entry[:status] == "skipped" && entry[:reason] == "already exists" }.keys
+        kept = installer.results.select { |_, entry| kept_own?(entry) }.keys
         result.kept_own[member] = kept.sort unless kept.empty?
       rescue StandardError => e
         result.failed[member] = e.message.lines.first.to_s.strip
       end
       private_class_method :install_member
 
+      # An Installer result for a file the user already had, with other
+      # bytes: skipped ("already exists"), or a dry run's would_skip. One
+      # with the bundle's bytes ("already up to date") isn't named: nothing
+      # of the bundle's is missing (it stays the user's all the same).
+      def kept_own?(entry)
+        entry[:status] == "would_skip" || (entry[:status] == "skipped" && entry[:reason] == "already exists")
+      end
+      private_class_method :kept_own?
+
       # Uninstalls each recorded member still installed, then the meta. A
       # member that won't go (an edited .md file, without +force+) is
       # reported and the rest carry on; the meta then stays, still

data/lib/samagotchi/memory_command.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "cli/command"
+require_relative "cli/exit"
+require_relative "cli/flags"
+require_relative "memory_paths"
+require_relative "tools/memory"
+require_relative "memory_bundle/index_updater"
+require_relative "memory_bundle/provenance"
+
+module Samagotchi
+  # `chi memory`: the user's side of the memories (docs/memory.md). ls lists
+  # both scopes' entries from their index.md lines and files, as memory_read
+  # and the prompt see them; rm removes one as memory_write remove: true does
+  # (Tools::MemoryWrite.remove: the file and its model overlays into the
+  # bundle trash, the index line dropped, a bundle's memory refused).
+  class MemoryCommand
+    include CLI::Command
+
+    USAGE = <<~TEXT
+      Usage: chi memory <ls|rm> [options]
+        ls [--scope project|system] [--format text|json]   the memories: both scopes (this folder's project
+             first), or one; each with its size, date, the bundle it came from and its index description
+        rm NAME [--scope project|system]   remove a memory: its file and its model overlays (NAME.<key>.md)
+             move to the bundle trash (chi bundle trash lists and empties it) and its index line is dropped.
+             Without --scope NAME must be in one scope only. A bundle's memory is refused: chi bundle
+             uninstall removes it. NAME.<key> removes one model overlay alone.
+    TEXT
+
+    SUBCOMMANDS = %w[ls rm].freeze
+    SCOPES = Tools::VALID_SCOPES
+    # The description column's width in ls's text form (json has it all).
+    DESCRIPTION_WIDTH = 60
+    # ls's size column, right-aligned.
+    SIZE_COLUMN = 2
+
+    FLAGS = {
+      "ls" => CLI::Flags.new(help: HELP_WORDS) do |f|
+        f.value "--scope"
+        f.value "--format"
+      end,
+      "rm" => CLI::Flags.new(help: HELP_WORDS) { |f| f.value "--scope" }
+    }.freeze
+
+    # One memory of a scope. +date+ is the index line's (the file's mtime
+    # when it has none); +source+ the bundle that owns it; +overlays+ the
+    # model keys of its overlays; +indexed+ / +file+: whether it has an
+    # index line / a file (a line whose file was deleted by hand has none).
+    Entry = Data.define(:name, :scope, :path, :bytes, :date, :source, :description, :overlays, :indexed, :file) do
+      def to_h = super.transform_keys(&:to_s)
+    end
+
+    # A managed index line: "- **name** · scope · date · size[ · from b][ — desc]"
+    # or a legacy "- **name**: desc" (MemoryWrite.managed_pattern).
+    LINE = /^- \*\*([^*\n]+)\*\*[ \t]*(?:[·•][^\n]*|:[^\n]*)?$/
+
+    # @param argv [Array<String>] the arguments after "memory"
+    # The project scope is the cwd's project, as for the memory tools.
+    def initialize(argv, stdout: $stdout, stderr: $stderr)
+      @argv = argv.dup
+      @stdout = stdout
+      @stderr = stderr
+    end
+
+    # @return [Integer] exit status: 0 done, 1 refused or failed, 2 usage
+    def run
+      @sub = @argv[0]
+      if @sub.nil? || HELP_WORDS.include?(@sub)
+        @stdout.puts(USAGE)
+        return CLI::Exit::OK
+      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)
+
+      scope = parsed.options[:scope]
+      return usage_error("unknown scope #{scope.inspect}: use --scope project|system") if scope && !SCOPES.include?(scope)
+
+      send(:"run_#{@sub}", parsed.options, parsed.args)
+    end
+
+    # The memories of +scope+ (project first, then system, when nil), by
+    # name within a scope.
+    # @return [Array<Entry>]
+    def self.entries(scope = nil)
+      owners = MemoryBundle::Provenance.each_installed.reject { |_, bundle| bundle.error? }
+      (scope ? [scope] : SCOPES).flat_map { |s| scope_entries(s, owners) }
+    end
+
+    def self.scope_entries(scope, owners)
+      dir = MemoryPaths.scope_dir(scope)
+      return [] unless File.directory?(dir)
+
+      index_path = File.join(dir, "#{Tools::MEMORY_INDEX}.md")
+      index_text = File.file?(index_path) ? File.read(index_path, encoding: "UTF-8") : ""
+      # name => its line; the first one when a name has two. A name rm
+      # would refuse (a path: "../x") isn't listed.
+      lines = {}
+      index_text.each_line do |l|
+        (m = l.chomp.match(LINE)) or next
+        lines[m[1]] ||= m[0] unless Tools::MemoryRead.invalid_name?(m[1])
+      end
+      stems = Dir.children(dir).filter_map { |f| f.delete_suffix(".md") if f.end_with?(".md") && File.file?(File.join(dir, f)) }.to_set
+      overlays = overlays_by_base(stems, lines)
+      overlay_stems = overlays.values.flatten(1).to_set { |_key, stem| stem }
+      names = (lines.keys + stems.to_a).uniq - [Tools::MEMORY_INDEX]
+      names.filter_map do |name|
+        next if overlay_stems.include?(name)
+
+        path = File.join(dir, "#{name}.md")
+        line = lines[name]
+        file = stems.include?(name)
+        # A bold line of prose ("- **Important**") isn't a memory: only a
+        # managed line ("· …") counts without a file.
+        next unless file || line&.include?(" · ")
+
+        entry(name, scope, path, line, file, overlays.fetch(name, []).map(&:first), owners)
+      end.sort_by(&:name)
+    end
+
+    # base name => [[key, stem]...] of its model overlays, in one pass over
+    # the files (+stems+, a Set): <base>.<key>.md with a key ModelOverlay
+    # makes, whose base is a file and whose stem has no index line of its
+    # own (MemoryWrite.overlay_files' rule, for every base at once).
+    def self.overlays_by_base(stems, lines)
+      stems.sort.each_with_object({}) do |stem, by_base|
+        base, dot, key = stem.rpartition(".")
+        next if dot.empty? || base.empty? || !key.match?(/\A[a-z0-9-]+\z/)
+        next unless stems.include?(base) && !lines.key?(stem)
+
+        (by_base[base] ||= []) << [key, stem]
+      end
+    end
+
+    def self.entry(name, scope, path, line, file, overlay_keys, owners)
+      source = line && MemoryBundle::IndexUpdater.extract_source(line)
+      source ||= owners.find { |_, bundle| bundle.effective_scope == scope && bundle.owns?("#{name}.md") }&.first
+      Entry.new(
+        name: name, scope: scope, path: path, bytes: file ? File.size(path) : nil,
+        date: line.to_s[/ · (\d{4}-\d{2}-\d{2})\b/, 1] || (file ? File.mtime(path).strftime("%Y-%m-%d") : nil),
+        source: source, description: line && line.include?(" · ") ? line.split(" — ", 2)[1]&.strip : legacy(line),
+        overlays: overlay_keys,
+        indexed: !line.nil?, file: file
+      )
+    end
+
+    # A legacy "- **name**: desc" line's description.
+    def self.legacy(line) = line&.split("**:", 2)&.[](1)&.strip&.then { |d| d.empty? ? nil : d }
+    private_class_method :scope_entries, :overlays_by_base, :entry, :legacy
+
+    private
+
+    def command_name = @sub && SUBCOMMANDS.include?(@sub) ? "chi memory #{@sub}" : "chi memory"
+    def usage_on_error = nil
+
+    def run_ls(options, args)
+      return usage_error("ls takes no NAME (unexpected #{args.first})") unless args.empty?
+
+      format = options[:format]
+      return usage_error("unknown format #{format.inspect}: use --format text|json") unless [nil, "text", "json"].include?(format)
+
+      rows = self.class.entries(options[:scope])
+      if format == "json"
+        @stdout.puts(JSON.pretty_generate(rows.map(&:to_h)))
+      elsif rows.empty?
+        @stdout.puts("no memories#{" in #{options[:scope]} scope" if options[:scope]}")
+      else
+        print_rows(rows)
+      end
+      CLI::Exit::OK
+    end
+
+    def print_rows(rows)
+      table = rows.map do |r|
+        notes = []
+        notes << "overlays: #{r.overlays.join(", ")}" unless r.overlays.empty?
+        notes << "no file" unless r.file
+        notes << "no index line" unless r.indexed
+        [r.scope, r.name, r.bytes.to_s, r.date.to_s, r.source ? "from #{r.source}" : "",
+         [clip(r.description.to_s), *notes.map { |n| "[#{n}]" }].reject(&:empty?).join(" ")]
+      end
+      widths = table.transpose.map { |column| column.map(&:length).max }
+      # A column no row fills (no memory from a bundle) takes no room.
+      table.each do |line|
+        cells = line.each_with_index.map { |cell, i| i == SIZE_COLUMN ? cell.rjust(widths[i]) : cell.ljust(widths[i]) }
+        @stdout.puts(cells.reject.with_index { |_, i| widths[i].zero? }.join("  ").rstrip)
+      end
+    end
+
+    def clip(text) = text.length > DESCRIPTION_WIDTH ? "#{text[0, DESCRIPTION_WIDTH - 1]}…" : text
+
+    def run_rm(options, args)
+      name = args.shift
+      return usage_error("give the memory's NAME") unless name
+      return usage_error("rm takes one NAME (unexpected #{args.first})") unless args.empty?
+
+      scope = options[:scope] || only_scope(name)
+      return scope if scope.is_a?(Integer)
+
+      result = Tools::MemoryWrite.call(nil, path: name, scope: scope, remove: true)
+      if result.start_with?("Error: ")
+        error_line("#{command_name}: #{result.delete_prefix("Error: ")}")
+        return CLI::Exit::FAILED
+      end
+
+      @stdout.puts(result)
+      CLI::Exit::OK
+    end
+
+    # The one scope +name+ is in (a file or an index line), else the exit
+    # status: a usage error when it is in both, a failure in neither (an
+    # invalid name goes on to remove's own error).
+    # @return [String, Integer]
+    def only_scope(name)
+      return "project" if Tools::MemoryRead.invalid_name?(name) || name == Tools::MEMORY_INDEX
+
+      found = SCOPES.select { |scope| present?(name, scope) }
+      case found.size
+      when 1 then found.first
+      when 0
+        error_line("#{command_name}: no memory '#{name}' in project or system scope")
+        CLI::Exit::FAILED
+      else
+        usage_error("#{name} is in both scopes: chi memory rm #{name} --scope project, or --scope system")
+      end
+    end
+
+    def present?(name, scope)
+      dir = MemoryPaths.scope_dir(scope)
+      index = File.join(dir, "#{Tools::MEMORY_INDEX}.md")
+      File.file?(File.join(dir, "#{name}.md")) ||
+        (File.file?(index) && File.read(index, encoding: "UTF-8").match?(Tools::MemoryWrite.managed_pattern(name)))
+    end
+  end
+end

data/lib/samagotchi/plugin/api.rb

@@ -21,8 +21,12 @@ module Samagotchi
       # The first chi release with each call a plugin may make (from git:
       # the first release tag holding it), for `chi bundle check`'s
       # requires-chi-floor: a bundle whose requires_chi admits an older chi.
-      # A call not listed gets no floor check: it came before the first tag
-      # (v0.2.0), or isn't listed yet. Keys have no "?" (API_CALL drops it).
+      # A call not listed gets no floor check: it is in the first tag (v0.2.0:
+      # chi.command/tool/on/service/init, ctx.settings, ctx.sessions,
+      # ctx.ask_model, ctx.notify, ctx.card, ctx.messages…). A member of
+      # one (ctx.sessions.children) is listed when it came later. Keys have
+      # no "?" (API_CALL drops it). A keyword added later (ctx.ask_model's
+      # model: in 0.80.0, ctx.sessions.send's delivery: in 0.64.0) has none.
       SINCE = {
         "ctx.steer" => "0.3.0", "ctx.stop_turn" => "0.3.0", "ctx.stop_generation" => "0.6.0",
         "Samagotchi::AtomicFile" => "0.8.0", "ctx.model" => "0.17.0", "ctx.model_key" => "0.17.0",
@@ -31,7 +35,7 @@ module Samagotchi
         "ctx.prompt_files" => "0.60.0", "chi.annotation" => "0.66.0", "chi.toolkit" => "0.66.0",
         "ctx.use_toolkit" => "0.66.0", "ctx.toolkit" => "0.66.0", "ctx.declared_tools" => "0.66.0",
         "chi.tool_source" => "0.67.0", "chi.peer_source" => "0.67.0", "ctx.http" => "0.80.0",
-        "ctx.cost" => "0.83.0"
+        "ctx.cost" => "0.83.0", "ctx.sessions.children" => "0.34.0"
       }.freeze
 
       # @param bundle [String]

data/lib/samagotchi/send_command.rb

@@ -685,13 +685,12 @@ module Samagotchi
         return true
       end
 
-      ack = result.ack
       @delivered = result
       # What the worker applied, for --format json: its ack's delivery
       # (next_step for an idle session) and a cut's outcome.
-      @sent_delivery = ack["delivery"] || delivery
-      @sent_cut = ack["cut"]
-      @info.puts("#{short}  sent#{with_images}#{delivery_note(ack, delivery: delivery, running: running, owner: owner)}")
+      @sent_delivery = result.delivery || delivery
+      @sent_cut = result.cut
+      @info.puts("#{short}  sent#{with_images}#{delivery_note(result, delivery: delivery, running: running, owner: owner)}")
       true
     rescue SessionManager::OwnedByTUI
       @info.puts("#{short}  refused: it is open in a chi REPL; messages need attached mode")
@@ -706,11 +705,12 @@ module Samagotchi
     # the outcome from the ack (now, waits, off); a --queue one runs after
     # the turn (or now, when the turn ended before it went in); images keep
     # their own wording; an idle session's turn simply runs.
-    # @param ack [Hash] the Bridge's 202 body ({} for the input file)
+    # @param result [SessionManager::DeliverResult] the accepted delivery
+    #   (its ack is {} for the input file)
     # @return [String] "" or " (...)"
-    def delivery_note(ack, delivery:, running:, owner:)
+    def delivery_note(result, delivery:, running:, owner:)
       return " (started its worker)" if owner.nil?
-      return queue_note(ack, running: running) if Delivery.queue?(delivery)
+      return queue_note(result, running: running) if Delivery.queue?(delivery)
       return "" unless running
 
       # A busy worker runs a message with images as its own next turn
@@ -720,18 +720,18 @@ module Samagotchi
       # The TUIs' words for a cut's outcome. No outcome: a plain message,
       # or the input file (the Bridge went away), which the next step's
       # drain takes.
-      outcome = Delivery.cut?(delivery) ? ack["cut"].to_s : ""
+      outcome = Delivery.cut?(delivery) ? result.cut.to_s : ""
       return " (goes in at the running turn's next step)" unless CUT_OUTCOMES.include?(outcome)
 
-      " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym, ack["cut_after"])}"
+      " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym, result.cut_after)}"
     end
 
     # A --queue, worded from the Bridge's ack: queue when a turn ran as it
     # went in (one another client started too), next_step when none did
     # (it runs now). The input file (no Bridge) carries the queue to
     # whichever turn runs: worded from the session as chi read it.
-    def queue_note(ack, running:)
-      queued = ack.key?("delivery") ? ack["delivery"] == Delivery::QUEUE : running
+    def queue_note(result, running:)
+      queued = result.delivery.nil? ? running : result.delivery == Delivery::QUEUE
       return " (queued: runs after the current turn)" if queued
 
       running ? " (the running turn had ended: it runs now)" : " (nothing running: it runs now)"

data/lib/samagotchi/session_inbox.rb

@@ -359,6 +359,35 @@ module Samagotchi
     end
     private_class_method :unmark_removed
 
+    # How old a per-input tombstone (input/removed/, TurnCheckpoint's
+    # input/settled/) gets before a worker's start prunes it (#prune_old).
+    # A wait reads one at its next poll (ReplyWait::POLL_INTERVAL) and a
+    # later `chi send --wait --turn` reads a settled one at its start, so
+    # only a wait whose process slept (a closed laptop) or one started long
+    # after needs it to stay. A removed one gone under a live wait would
+    # read as a merge (the wrong reply), so the age is generous: a week,
+    # half the session retention (14 days), for one small file per
+    # file-delivered command or dequeue.
+    TOMBSTONE_MAX_AGE = 7 * 24 * 3600
+
+    # Deletes the files in input/<+subdir+> last written more than
+    # +max_age+ seconds ago; one that can't be read or deleted stays.
+    # @return [Integer] how many went
+    def self.prune_old(session_dir, subdir, max_age: TOMBSTONE_MAX_AGE)
+      cutoff = Time.now - max_age
+      Dir.glob(File.join(session_dir, INPUT_DIR, subdir, "*")).count do |file|
+        next false unless File.mtime(file) < cutoff
+
+        File.delete(file)
+        true
+      rescue SystemCallError
+        false
+      end
+    end
+
+    # The removed tombstones past +max_age+ (#prune_old).
+    def self.prune_removed(session_dir, max_age: TOMBSTONE_MAX_AGE) = prune_old(session_dir, REMOVED_DIR, max_age: max_age)
+
     # @return [Boolean] whether the queued input +enqueued_id+ was removed
     #   before it ran (#take_queued_input's tombstone), or is being removed:
     #   the tombstone goes first, so while its claimed file is still there

data/lib/samagotchi/session_manager.rb

@@ -1177,6 +1177,17 @@ module Samagotchi
       def error = ack["error"]
 
       def detail = ack["detail"]
+
+      # What the worker applied (a Bridge ack only): the delivery asked for,
+      # or next_step for a --queue that found no turn running; nil from the
+      # input file or a worker older than delivery.
+      def delivery = ack["delivery"]
+
+      # A --cut's outcome ("now", "waits", "off"), nil when nothing was cut.
+      def cut = ack["cut"]
+
+      # The steer cut-after seconds, with a cut that waits only.
+      def cut_after = ack["cut_after"]
     end
 
     # Hand a user message to the session the way a UI does, for the web

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -727,6 +727,8 @@ module Samagotchi
           @screen.commit("#{paint("model>", 36)} #{output}")
         end
         prefill_confirm(event)
+        # /title from any client: the row's title follows.
+        @status.update(title: event[:title]) if Array(event[:changed]).include?("title")
         return unless event[:model_name]
 
         # After the output, so the status row changes with the line saying why.

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -5,7 +5,7 @@ require_relative "formatting"
 module Samagotchi
   class TerminalUI
     # The status row under the prompt, the same for both TUIs:
-    # `status> model=… | ↳ parent | ⑂ 2 running · 1 waiting | ctx=12.3% (under20) | mem: … | muted: …`.
+    # `status> Title | model=… | ↳ parent | ⑂ 2 running · 1 waiting | ctx=12.3% (under20) | mem: … | muted: …`.
     # A UI feeds it what it learns (attached mode from the Bridge's events,
     # the REPL from its Engine's) through #update, and the row is redrawn in
     # the surface's status slot only when its text changes.
@@ -15,6 +15,8 @@ module Samagotchi
       # Memory names shown before ", +N".
       MEMORY_LIMIT = 8
       # What the row shows:
+      #   title                 the session's own title (Session#title; not
+      #                         the first message's preview), or nil
       #   model, default_model  the model in use, and the config's default
       #                         (named beside another model)
       #   served                [served, asked, expected]: what the server said it
@@ -29,12 +31,17 @@ module Samagotchi
       #                         records them as used)
       #   muted                 its --mute list
       #   running               a turn runs: the row trails STEER_HINT
-      FIELDS = %i[model default_model served parent_id children context used_memories preloaded muted running].freeze
+      FIELDS = %i[title model default_model served parent_id children context used_memories preloaded muted running].freeze
 
       # The tail while a turn runs: where a typed line goes (the next step)
       # and the two other choices. Dropped whole first when the row is cut.
       STEER_HINT = " · typing goes in at the next step (/cut, /queue)"
 
+      # The longest title shown, and the share of the row it may take on a
+      # narrow terminal: the rest of the row still fits.
+      TITLE_MAX = 32
+      TITLE_SHARE = 3
+
       # The turn events that end a turn (the hint goes).
       TURN_END_EVENTS = %i[turn_completed turn_canceled turn_failed].freeze
 
@@ -74,6 +81,7 @@ module Samagotchi
         fields.merge!(model: state[:model_name], default_model: default_model) if state[:model_name]
         STATE_LISTS.each { |field, key| fields[field] = Array(state[key]) if state.key?(key) }
         fields[:parent_id] = state[:parent_id] if state.key?(:parent_id)
+        fields[:title] = state[:title] if state.key?(:title)
         # The last turn's ctx, so it shows before the next turn's.
         fields[:context] = state[:context_status] if state[:context_status].is_a?(Hash)
         update(**fields)
@@ -126,7 +134,8 @@ module Samagotchi
           model_text = status_model_text(model, @values[:default_model], served: served, served_for: served_for,
                                                                          expected: expected.is_a?(String))
         end
-        segments = [model_text,
+        segments = [title_text(@values[:title], width),
+                    model_text,
                     parent ? "↳ #{parent.to_s[0, 8]}" : "",
                     children_text(@values[:children]),
                     status_context_text(estimate: @values[:context]),
@@ -147,6 +156,18 @@ module Samagotchi
         segments[0..-2] + ["#{segments.last}#{STEER_HINT}"]
       end
 
+      # The title cut to TITLE_MAX, and to a TITLE_SHARE-th of +width+
+      # (the row's other segments come after it); "" without one.
+      def title_text(title, width)
+        title = title.to_s.strip
+        return "" if title.empty?
+
+        max = [TITLE_MAX, width / TITLE_SHARE].min
+        return title if title.length <= max
+
+        max > 1 ? "#{title[0, max - 1]}…" : ""
+      end
+
       # `⑂ 2 running · 1 waiting`, the counts there are; "" with neither (no
       # children, or all ended). Not "not reported": a REPL parent is never
       # given its children's replies (no wakes there), and a worker moves

data/lib/samagotchi/terminal_ui.rb

@@ -889,6 +889,7 @@ module Samagotchi
         if command
           show_command_result(command)
           refresh_status_row(clear_unknown_context: true) if command.changed.include?(:model)
+          refresh_status_row if command.changed.include?(:title)
           persist_recent_history(input) if command.shell
           return
         end

data/lib/samagotchi/tools/memory.rb

@@ -356,7 +356,7 @@ module Samagotchi
         ([file] + overlay_files(dir, entry_name, index_text)).each { |path| trash.move(path) }
         Samagotchi::MemoryBundle::IndexUpdater.remove_index(resolved_scope, entry_name)
         "Memory '#{entry_name}' removed from #{resolved_scope} scope: moved to #{trash.dir} " \
-          "(`chi bundle trash` lists and empties it); index line dropped."
+          "(`chi bundle trash` lists and empties it)#{"; index line dropped" if line}."
       end
 
       # The entry's model overlays: <name>.<key>.md with a key ModelOverlay

data/lib/samagotchi/turn_checkpoint.rb

@@ -86,6 +86,12 @@ module Samagotchi
       settled_record(id)
     end
 
+    # The settled outcomes past +max_age+ (SessionInbox.prune_old).
+    # @return [Integer] how many went
+    def self.prune_settled(session_dir, max_age: SessionInbox::TOMBSTONE_MAX_AGE)
+      SessionInbox.prune_old(session_dir, SETTLED_DIR, max_age: max_age)
+    end
+
     def self.settled_record(id, ended_at: nil, seconds: nil)
       LastTurn.new(outcome: "canceled", cancel_reason: WORKER_STOPPED, ended_at: ended_at, seconds: seconds, enqueued_id: id)
     end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/worker.rb

@@ -237,6 +237,7 @@ module Samagotchi
       @config_restart_unsubscribe = ConfigFile.watch_restart_settings!(process: :worker) do |message|
         @engine.announce(type: :hook_notice, hook: "config", text: message, level: :warn, between_turns: true)
       end
+      prune_tombstones
       settle_interrupted_turn
       # Before the Bridge serves anything: a UI joining a resumed worker's
       # stream gets the session's history and status in its snapshot, not
@@ -491,6 +492,15 @@ module Samagotchi
       save_or_log(:interrupted_turn) { save_session }
     end
 
+    # The per-input tombstones (removed, settled) older than
+    # SessionInbox::TOMBSTONE_MAX_AGE, once per worker start: they only go
+    # with the session dir otherwise.
+    def prune_tombstones
+      removed = SessionInbox.prune_removed(@session_dir)
+      settled = TurnCheckpoint.prune_settled(@session_dir)
+      Log.info(:worker, "tombstones_pruned", removed: removed, settled: settled) if (removed + settled).positive?
+    end
+
     # A saved parent_answers that isn't a level reads as hard on every
     # answer without a word; said once here, as the session loads.
     def announce_session_warnings
@@ -958,6 +968,8 @@ module Samagotchi
       event = { type: :command_ran, **command.event_fields, status: status, output: text[0, COMMAND_OUTPUT_LIMIT],
                 changed: changed.map(&:to_s), model_name: @engine.effective_model_name }
       event[:anytime] = true if anytime
+      # The session's title after /title (nil: cleared), for the TUIs' row.
+      event[:title] = @engine.session&.title if changed.include?(:title)
       # Its line was shown at its command_queued (waits: turn_end).
       event[:queued] = true if command.waits_for_turn_end?
       # The chips the command moved (SessionSetting#changed_by): what the next
@@ -1259,12 +1271,14 @@ module Samagotchi
       # The Bridge serves before the idle-exit policy exists.
       return WorkerIdleExit::Hold.new(reason: :starting) unless @idle_exit
 
-      hold = restart ? @idle_exit.hold_for_restart : @idle_exit.hold_for_request(requester: client_id)
-      if hold == :background_tasks && !restart
-        # /exit names the tasks it waits for (D3).
-        return WorkerIdleExit::Hold.new(reason: hold, tasks: @task_wakes.watch.running, hint: TASK_STOP_HINT)
+      if restart
+        hold = @idle_exit.hold_for_restart
+        return WorkerIdleExit::Hold.new(reason: hold) if hold
+      else
+        # /exit names the tasks it waits for (D3), from the one look that found them.
+        hold = @idle_exit.request_hold(requester: client_id, hint: TASK_STOP_HINT)
+        return hold if hold
       end
-      return WorkerIdleExit::Hold.new(reason: hold) if hold
 
       @exit_requested = true
       @exit_requested_by = client_id

data/lib/samagotchi/worker_idle_exit.rb

@@ -94,15 +94,23 @@ module Samagotchi
     #   still be open, untagged)
     # @return [Symbol, nil] :turn_running, :input_queued, :continue_offered,
     #   :client_connected, :reminders or :background_tasks
-    def hold_for_request(requester:, streams: true)
-      return :turn_running if @engine.turn_running?
-      return :input_queued if @input_pending.call
-      return :continue_offered if @awaiting_continue.call
-      return :client_connected if streams && @bridge && @bridge.open_streams_except(requester).positive?
-      return :reminders if @engine.reminder_store&.any?
-      return :background_tasks if @watched_running.call.any?
+    def hold_for_request(requester:, streams: true) = request_hold(requester: requester, streams: streams)&.reason
 
-      nil
+    # #hold_for_request as a Hold: for :background_tasks, the watched tasks
+    # still running, read once (TaskWatch#running looks at each task's
+    # process), with +hint+.
+    # @return [Hold, nil]
+    def request_hold(requester:, streams: true, hint: nil)
+      reason = if @engine.turn_running? then :turn_running
+               elsif @input_pending.call then :input_queued
+               elsif @awaiting_continue.call then :continue_offered
+               elsif streams && @bridge && @bridge.open_streams_except(requester).positive? then :client_connected
+               elsif @engine.reminder_store&.any? then :reminders
+               end
+      return Hold.new(reason: reason) if reason
+
+      running = @watched_running.call
+      running.any? ? Hold.new(reason: :background_tasks, tasks: running, hint: hint) : nil
     end
 
     # What keeps the worker from restarting now (a client asked: POST /exit

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.96.0
+  version: 0.97.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -437,6 +437,7 @@ files:
 - lib/samagotchi/memory_bundle/system_bundle.rb
 - lib/samagotchi/memory_bundle/trash.rb
 - lib/samagotchi/memory_bundle/uninstaller.rb
+- lib/samagotchi/memory_command.rb
 - lib/samagotchi/memory_paths.rb
 - lib/samagotchi/message_parts.rb
 - lib/samagotchi/model_catalog.rb