samagotchi 0.155.0 → 0.157.0

data/lib/samagotchi/session_metrics.rb

@@ -142,7 +142,7 @@ module Samagotchi
       :cached_sum,
       :cache_write_sum,
       # What the server prefilled again of the previous request's prompt
-      # (KernelLoop#reprefilled_tokens; an LLM context edit's cache break).
+      # (ReprefillMeter#tokens; an LLM context edit's cache break).
       :reprefill_sum,
       :reasoning_sum,
       :cost_sum,
@@ -1112,19 +1112,22 @@ module Samagotchi
         if guardrail.is_a?(Hash) && guardrail[:decided_by] == "system one"
           active[:guardrail] = { rule: guardrail[:rule], p: guardrail[:p], judgment_id: guardrail[:judgment_id] }.compact
         end
-        finish_tool_record(active, status.empty? ? "ok" : status, waited_ms: event[:waited_ms].to_i)
+        finish_tool_record(active, status.empty? ? "ok" : status, waited_ms: event[:waited_ms].to_i,
+                                                                  duration_ms: event[:duration_ms])
       end
     end
 
-    # Caller holds the mutex.
-    def finish_tool_record(active, status, waited_ms: 0)
+    # Caller holds the mutex. +duration_ms+: the event's (ToolRunner's,
+    # the figure every UI shows live); without one (a test kernel's
+    # events), timed here.
+    def finish_tool_record(active, status, waited_ms: 0, duration_ms: nil)
       record = active.slice(
         :id, :turn_id, :iteration, :call_index, :tool, :called_as, :via, :no_match, :guardrail, :started_at
       ).merge(
         status: status,
         completed_at: now.iso8601(3),
         # Less a guardrail approval wait (ToolRunner's waited_ms).
-        duration_ms: [elapsed_ms(active[:started_monotonic]) - waited_ms, 0].max
+        duration_ms: duration_ms.is_a?(Integer) ? duration_ms : [elapsed_ms(active[:started_monotonic]) - waited_ms, 0].max
       )
       @tool_records << record
       count_tool(record)

data/lib/samagotchi/session_paths.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "paths"
+
+module Samagotchi
+  # Where a session's files are and which ids name one: the sessions dir,
+  # a session's <id>.json and <id>/ dir, and the id rule every id from
+  # outside meets before it becomes a path. A leaf (Paths only), so a file
+  # that needs a session's path needs no Session: Session extends it, so
+  # Session.session_dir and the rest answer the same. `extend self`, not
+  # module_function: Session's copies must stay public.
+  module SessionPaths
+    extend self # rubocop:disable Style/ModuleFunction -- module_function would make Session's copies private
+
+    STATE_SUBDIR = File.join("samagotchi", "sessions")
+    FILE_EXT = ".json"
+
+    # An id that is not a session id: it could name a path outside the
+    # sessions dir ("../x", "/etc", "a/b", a NUL), or is empty.
+    class InvalidId < ArgumentError; end
+
+    # Ids are SecureRandom.uuid; anything made of letters, digits, "-" and
+    # "_" (up to 128, not starting with "-") is taken, so a UUID prefix the
+    # CLI resolves passes too. This is the one check every id from outside
+    # (the bridge, the web routes, chi send/note, delegate) meets before it
+    # becomes a path: session_dir and the session file path refuse others.
+    VALID_ID = /\A[A-Za-z0-9_][A-Za-z0-9_-]{0,127}\z/
+
+    def valid_id?(session_id)
+      session_id.is_a?(String) && VALID_ID.match?(session_id)
+    end
+
+    # @raise [InvalidId] unless valid_id?(session_id)
+    def check_id!(session_id)
+      return session_id if valid_id?(session_id)
+
+      raise InvalidId, "invalid session id: #{session_id.to_s[0, 80].inspect}"
+    end
+
+    # Directory for a specific session (holds IPC files alongside session.json).
+    # @raise [InvalidId] for an id that isn't one (valid_id?)
+    def session_dir(session_id, state_dir: default_state_dir)
+      File.join(state_dir, check_id!(session_id))
+    end
+
+    # A session's <id>.json.
+    # @raise [InvalidId] for an id that isn't one (valid_id?)
+    def session_file(session_id, state_dir: default_state_dir)
+      File.join(state_dir, "#{check_id!(session_id)}#{FILE_EXT}")
+    end
+
+    # XDG-aware sessions directory.
+    def default_state_dir(env: ENV)
+      File.join(Paths.state_home(env: env), STATE_SUBDIR)
+    end
+  end
+end

data/lib/samagotchi/session_retention.rb

@@ -78,7 +78,7 @@ module Samagotchi
       Dir.children(state_dir).filter_map do |name|
         dir = File.join(state_dir, name)
         next unless Session.valid_id?(name) && File.directory?(dir)
-        next if File.exist?(File.join(state_dir, "#{name}#{Session::FILE_EXT}"))
+        next if File.exist?(File.join(state_dir, "#{name}#{SessionPaths::FILE_EXT}"))
         next unless Time.now - File.mtime(dir) > EMPTY_GRACE_SECONDS && SessionManager.empty_session_dir?(dir)
         next if SessionManager.session_owner(name, state_dir: state_dir)
 
@@ -203,7 +203,7 @@ module Samagotchi
       passed_over = 0
 
       all.each_with_index do |session, idx|
-        path = File.join(state_dir, "#{session.id}#{Session::FILE_EXT}")
+        path = File.join(state_dir, "#{session.id}#{SessionPaths::FILE_EXT}")
         # Only when json present
         unless File.exist?(path)
           skipped << session.id

data/lib/samagotchi/session_row.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "session"
+require_relative "owner_lock"
+require_relative "worker_link"
+require_relative "recap_store"
+require_relative "session_metrics"
+require_relative "archive_store"
+require_relative "effective_model"
+require_relative "host_registry"
+
+module Samagotchi
+  # A session as the lists see it: the one row every listing builds and
+  # reads (SessionManager.session_rows, chi sessions list on both backends,
+  # the picker, list_sessions, a broadcast's recipients, a parent's
+  # children, chi web's summaries route and Web::SessionSummary). Only
+  # scalar facts that go on the wire: #to_summary_h is the summaries route's
+  # body (28 keys, this order) and .from_summary_h reads it back, so a
+  # remote row prints the same #cli_line as a local one.
+  #
+  # The liveness rule: +live+ is WorkerLink's worker_owned? (a worker holds
+  # the lock, its Bridge up or on its way); +busy+ and +waiting+ need it,
+  # +status+ is Session#displayed_status (a dead worker's "running" is idle).
+  SessionRow = Data.define(:id, :desc, :preview, :title, :cwd, :project, :updated_at, :status, :saved_status, :live,
+                           :busy, :owner, :recap, :auto_title, :ctx_pct, :parent_id, :continues, :delegate, :archived,
+                           :scratch, :test_run, :stopped_by, :waiting, :waiting_id, :relayed_to)
+
+  class SessionRow
+    DESC_LIMIT = 60
+    PREVIEW_LIMIT = 120
+    # Seconds a child saved "running" with no worker yet counts as one on
+    # its way (a worker boots in a few seconds): .running_or_starting?.
+    STARTING_GRACE_SECONDS = 15
+
+    # The summaries route's keys, in their order (#to_summary_h).
+    SUMMARY_KEYS = %i[id short_id desc preview title cwd project updated_at status saved_status live busy owner recap
+                      auto_title ctx_pct parent_id parent_short_id continues continues_short_id delegate archived
+                      scratch test_run stopped_by waiting waiting_id relayed_to].freeze
+    DERIVED_KEYS = %i[short_id parent_short_id continues_short_id].freeze
+    # `chi sessions list --format json`'s keys (of SUMMARY_KEYS: no status).
+    # owner: "worker", "tui" (a one-turn chi run: it takes no notes or
+    # messages) or nil; recap: the saved recap's first sentence, or nil;
+    # project: its git project's root, or nil; parent_id: the session that
+    # delegated it (the delegate tool), or nil; delegate: started by the
+    # delegate tool (a fork has a parent_id too); continues: the session it
+    # continues (its chain's previous link), or nil; archived: hidden from
+    # the lists (only with --archived can it be true); scratch: a `chi
+    # scratch` session; 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; auto_title: the one its recap gave it (RecapTitle), or
+    # nil; waiting: the kind of question it waits on (question, approval,
+    # hook), 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.
+    JSON_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].freeze
+
+    # @param session [Session] a saved session
+    # @param session_dir [String] its folder
+    # @param owner [OwnerLock::Owner, nil] the lock's holder as read
+    #   (SessionManager.session_owner)
+    # @param link [WorkerLink outcome, nil] resolved with +owner+; nil:
+    #   resolved here (one read of bridge.json)
+    # @param roots [Hash] ProjectScope.root_for's cache, shared by a listing
+    # @param budgets [#call] (session) -> its llm_context budget (.budgets:
+    #   one HostRegistry per listing)
+    # @param saved [SessionMetrics::SavedSummary, nil, :read] the saved
+    #   analytics as a caller already read it; :read reads it here
+    # @param card [RecapStore::Card, :read] the recap card, likewise
+    # @return [SessionRow]
+    def self.build(session, session_dir:, owner:, link: nil, roots: {}, budgets: SessionRow.budgets, saved: :read,
+                   card: :read)
+      link ||= WorkerLink.resolve(session_dir, unlink: false, owner: owner)
+      live = link.worker_owned?
+      card = RecapStore.card(session_dir) if card == :read
+      if saved == :read
+        saved = SessionMetrics.saved_summary(session_dir, budget_tokens: -> { budgets.call(session) })
+      end
+      waiting = session.waiting_question(live: live)
+      new(id: session.id, desc: desc_of(session), preview: cut(summary_text(session), PREVIEW_LIMIT),
+          title: session.title, cwd: session.working_directory, project: session.project_root(cache: roots),
+          updated_at: session.updated_at, status: session.displayed_status(owner: owner), saved_status: session.status,
+          live: live, busy: live && session.status == Session::STATUS_RUNNING, owner: owner&.kind,
+          recap: card.preview, auto_title: card.title, ctx_pct: saved&.ctx_pct&.round(1),
+          parent_id: session.parent_id, continues: session.continues, delegate: session.delegate?,
+          archived: ArchiveStore.archived?(session_dir), scratch: session.scratch, test_run: session.test_run,
+          stopped_by: session.stopped_by, waiting: waiting&.dig(:kind), waiting_id: waiting&.dig(:id),
+          relayed_to: waiting&.dig(:relayed_to))
+    end
+
+    # A row read back from #to_summary_h's hash (symbol keys; a remote's
+    # rows, Remote#symbolize'd). A key the hash lacks reads nil.
+    def self.from_summary_h(hash)
+      new(**members.to_h { |key| [key, hash[key]] })
+    end
+
+    # The budget resolver a listing shares: the process's HostRegistry
+    # (HostRegistry.current), taken on the first row that needs it (a saved
+    # context to count) and kept for the rest of the listing.
+    # @return [#call] (session) -> the session's budget in tokens or nil
+    def self.budgets
+      registry = nil
+      ->(session) { EffectiveModel.session_budget(session, registry: registry ||= HostRegistry.current) }
+    end
+
+    # Busy (a worker runs its turn), or saved running with no worker yet
+    # for less than STARTING_GRACE_SECONDS: a worker on its way (it counts
+    # against session.max_children; Verify fresh waits for it). The
+    # displayed status shows that one as idle, so +saved_status+ is the
+    # file's.
+    def self.running_or_starting?(saved_status:, live:, busy:, updated_at:)
+      return true if busy
+      return false unless saved_status == Session::STATUS_RUNNING && !live
+
+      Time.now - Time.iso8601(updated_at.to_s) < STARTING_GRACE_SECONDS
+    rescue ArgumentError
+      false
+    end
+
+    # A session as one line of text for the lists: its title (/title), else
+    # its last prompt, else the first message it was started with (a session
+    # command like `/model x`, or a first turn not saved yet).
+    def self.summary_text(session)
+      return one_line(session.title) unless session.title.to_s.strip.empty?
+
+      one_line(session.last_prompt.to_s.strip.empty? ? session.first_preview.to_s : session.last_prompt.to_s)
+    end
+
+    # A prompt as one line for a session list: whitespace collapsed, and a
+    # quoted or annotated message (ContextQuote, the web's annotations)
+    # without its "> " markers, so the words show.
+    def self.one_line(text)
+      text.to_s.gsub(/^[ \t]*(?:>[ \t]?)+/, "").gsub(/\s+/, " ").strip
+    end
+
+    # "<cwd basename> · <last prompt, or the first preview>", one line.
+    # The flags a list line carries: a chi scratch session, a test run, an
+    # archived one, and the turn's stopper: "[looped]" for loop-guard (the
+    # bundle's thinking watch, and the word `chi sessions stats` uses for
+    # its cuts), "[stopped by X]" for any other hook (a cut with no retry
+    # left records the same stopped_by).
+    def self.flags(scratch:, test_run:, archived:, stopped_by: nil)
+      flag = if scratch
+               " [scratch]"
+             else
+               (test_run ? " [test]" : "")
+             end
+      flag += " [archived]" if archived
+      return flag if stopped_by.to_s.empty?
+
+      flag + (stopped_by.to_s == "loop-guard" ? " [looped]" : " [stopped by #{stopped_by}]")
+    end
+
+    def self.desc_of(session)
+      desc = [File.basename(session.working_directory.to_s), summary_text(session)].reject(&:empty?).join(" · ")
+      cut(desc, DESC_LIMIT)
+    end
+    private_class_method :desc_of
+
+    def self.cut(text, limit)
+      text.length > limit ? "#{text[0, limit - 1]}…" : text
+    end
+    private_class_method :cut
+
+    def short_id = id.to_s[0, 8]
+    def parent_short_id = parent_id&.[](0, 8)
+    def continues_short_id = continues&.[](0, 8)
+
+    def running_or_starting?
+      self.class.running_or_starting?(saved_status: saved_status, live: live, busy: busy, updated_at: updated_at)
+    end
+
+    # The session as `chi sessions list` prints it, wherever it runs (the
+    # plain list, the --live/--cwd text, a remote's): its id, state (a
+    # question it waits on, else the displayed status), the context's fill,
+    # updated_at, its text (a title, else the recap's auto title or first
+    # sentence, else the last prompt; 60 characters), its flags, and the
+    # parent it was delegated from (↳) and the link it continues (↪). Reads
+    # only row fields, so a remote row prints the same line.
+    def cli_line
+      state = if relayed_to then "waiting (in parent #{relayed_to})"
+              elsif waiting then "waiting"
+              else status.to_s
+              end
+      text = (title ? preview : auto_title || recap || preview).to_s[0, DESC_LIMIT]
+      links = parent_short_id ? "  ↳ #{parent_short_id}" : ""
+      links += "  ↪ #{continues_short_id}" if continues_short_id
+      ctx = SessionMetrics.context_label(ctx_pct)
+      flag = self.class.flags(scratch: scratch, test_run: test_run, archived: archived, stopped_by: stopped_by)
+      "#{id}  #{state.ljust(8)}  #{ctx.ljust(8)}  #{updated_at}  #{text}#{flag}#{links}"
+    end
+
+    # The summaries route's row: SUMMARY_KEYS, in order.
+    # @return [Hash] symbol keys
+    def to_summary_h
+      SUMMARY_KEYS.to_h { |key| [key, public_send(key)] }
+    end
+  end
+end

data/lib/samagotchi/session_setup.rb

@@ -42,24 +42,27 @@ module Samagotchi
             working_set_pins: WorkingSetPin.list(working_set_pins))
     end
 
-    def empty?
-      llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty? && toolkit.nil? &&
-        toolkit_origin.nil? && settings.empty? && parent_answers.nil? && working_set_pins.empty?
-    end
+    # Every member at its default: none of the session's own settings.
+    def empty? = self == self.class.new
 
-    # A session's own setup, for a session that starts from it. Its
-    # toolkit always: one from before toolkits is full (Toolkit.of), not
-    # whatever config's default is now.
+    # A session's own setup, for a session that starts from it: each
+    # member is the session's field of the same name (Session.new_session
+    # applies them by name), but for SessionSetup::CARRY's. Its toolkit
+    # always: one from before toolkits is full (Toolkit.of), not whatever
+    # config's default is now.
     # @param session [Session, nil]
     # @return [SessionSetup]
     def self.of(session)
       return new if session.nil?
 
-      new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history,
-          appended_prompt_files: session.appended_prompt_files, toolkit: Toolkit.of(session.toolkit),
-          toolkit_origin: "inherited",
-          settings: session.settings, parent_answers: session.parent_answers,
-          working_set_pins: session.working_set_pins)
+      new(**members.to_h { |member| [member, self::CARRY.fetch(member) { ->(s) { s.public_send(member) } }.call(session)] })
     end
   end
+
+  # How SessionSetup.of carries a member that isn't its session's field as
+  # it is: member => (session) -> value.
+  SessionSetup::CARRY = {
+    toolkit: ->(session) { Toolkit.of(session.toolkit) },
+    toolkit_origin: ->(_session) { "inherited" }
+  }.freeze
 end

data/lib/samagotchi/sessions_command.rb

@@ -2,12 +2,12 @@
 
 require "json"
 require_relative "session"
+require_relative "session_row"
 require_relative "session_manager"
 require_relative "session_retention"
 require_relative "project_scope"
 require_relative "analytics_file"
 require_relative "session_metrics"
-require_relative "recap_store"
 require_relative "session_delete_command"
 require_relative "session_archive_command"
 require_relative "worker_link"
@@ -142,28 +142,6 @@ module Samagotchi
       options.to_h { |key, value| [key, INTEGER_OPTIONS.include?(key) ? Integer(value, 10) : value] }
     end
 
-    # The flags a list row carries: a chi scratch session, a test run, an
-    # archived one, and the turn's stopper (see #stopped_flag).
-    def session_flag(scratch:, test_run:, archived:, stopped_by: nil)
-      flag = if scratch
-               " [scratch]"
-             else
-               (test_run ? " [test]" : "")
-             end
-      flag += " [archived]" if archived
-      flag + stopped_flag(stopped_by)
-    end
-
-    # The marker for a turn a hook stopped: "[looped]" for loop-guard (the
-    # bundle's thinking watch, and the word `chi sessions stats` uses for its
-    # cuts), "[stopped by X]" for any other hook; "" otherwise. A cut with no
-    # retry left records the same stopped_by.
-    def stopped_flag(by)
-      return "" if by.to_s.empty?
-
-      by.to_s == "loop-guard" ? " [looped]" : " [stopped by #{by}]"
-    end
-
     def list
       format, scope, cwd = @opts.values_at(:format, :scope, :cwd)
       unless format.nil? || %w[text json tsv].include?(format)
@@ -175,7 +153,8 @@ module Samagotchi
       # chi web's; --scope=all, a folder in no repo or an explicit --cwd: every
       # project's. Machine-local (this cwd's project): remotely every
       # project's (D4), and --scope=project is --cwd's project there (the
-      # server finds its root). The rows are the server's (list_summaries).
+      # server finds its root). The rows are SessionRows, the server's
+      # remotely: one line wherever the list runs (SessionRow#cli_line).
       # The picker (chi note from a script): filters apply before the limit,
       # and test runs stay out, unless this is one (SAMAGOTCHI_ENV=test, CI):
       # then its own sessions are what it looks for. The plain listing shows
@@ -191,10 +170,7 @@ module Samagotchi
       end
       project = scope == "all" || cwd ? nil : Samagotchi::ProjectScope.root_for(Dir.pwd)
       scope_note = ->(count) { "#{count} session(s) in #{File.basename(project)} (--scope=all: every project)" }
-
-      return list_summaries(project, scope_note, include_tests: include_tests) if picker
-
-      list_plain(project, scope_note)
+      list_summaries(project, scope_note, include_tests: include_tests)
     end
 
     def list_summaries(project, scope_note, include_tests:)
@@ -207,117 +183,23 @@ module Samagotchi
       )
       case format
       when "json"
-        # owner: "worker", "tui" (a one-turn chi run: it takes no notes or messages)
-        # or nil; recap: the saved recap's first sentence, or nil; project:
-        # its git project's root, or nil
-        # parent_id: the session that delegated it (the delegate tool), or nil
-        # delegate: started by the delegate tool (a fork has a parent_id too)
-        # continues: the session it continues (its chain's previous link), or nil
-        # archived: hidden from the lists (only with --archived can it be true)
-        # scratch: a `chi scratch` session (deleted when its terminal leaves,
-        # 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;
-        # 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 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) })
+        # SessionRow::JSON_KEYS (its comment says what each one is).
+        @stdout.puts JSON.generate(summaries.map { |row| row.to_summary_h.slice(*Samagotchi::SessionRow::JSON_KEYS) })
       when "tsv"
-        summaries.each { |summary| @stdout.puts "#{summary[:id]}\t#{summary[:desc]}" }
+        summaries.each { |row| @stdout.puts "#{row.id}\t#{row.desc}" }
       else
-        summaries.each do |summary|
-          state = if summary[:relayed_to] then "waiting (in parent #{summary[:relayed_to]})"
-                  elsif summary[:waiting] then "waiting"
-                  elsif summary[:busy] then "running"
-                  else summary[:live] ? "live" : summary[:status].to_s
-                  end
-          # 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]
-          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.
-          child = summary[:parent_short_id] ? "  ↳ #{summary[:parent_short_id]}" : ""
-          # A chain's link points at the one it continues.
-          child += "  ↪ #{summary[:continues_short_id]}" if summary[:continues_short_id]
-          flag = session_flag(scratch: summary[:scratch], test_run: summary[:test_run], archived: summary[:archived],
-                              stopped_by: summary[:stopped_by])
-          ctx = Samagotchi::SessionMetrics.context_label(summary[:ctx_pct])
-          @stdout.puts "#{summary[:id]}  #{state.ljust(8)}  #{ctx.ljust(8)}  #{summary[:updated_at]}  #{desc}#{flag}#{child}"
-        end
+        summaries.each { |row| @stdout.puts row.cli_line }
         if project
           @stdout.puts "#{"\n" unless summaries.empty?}#{scope_note.call(summaries.size)}"
+        elsif summaries.empty?
+          @stdout.puts "No sessions."
         else
-          @stdout.puts summaries.empty? ? "No sessions." : "\n#{summaries.size} session(s)"
+          @stdout.puts "\n#{summaries.size} session(s) (sort=#{sort || "updated_at"} order=#{order || "desc"})"
         end
       end
       0
     end
 
-    def list_plain(project, scope_note)
-      sort, order, limit, include_archived = @opts.values_at(:sort, :order, :limit, :include_archived)
-      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 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|
-        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
-      # than the window, as the live meter counts it (one registry for the
-      # whole table, built when the first row has a saved context). Blank when
-      # unknown.
-      budgets = nil
-      ctx = lambda do |s|
-        Samagotchi::SessionMetrics.context_label(
-          Samagotchi::SessionMetrics.saved_context_pct(
-            Samagotchi::Session.session_dir(s.id, state_dir: state_dir),
-            budget_tokens: -> { Samagotchi::LLMContextStrategy.session_budget(s, registry: budgets ||= Samagotchi::HostRegistry.new) }
-          )
-        )
-      end
-      # A delegated session points at its parent: ↳ <parent's short id>.
-      row = lambda do |s|
-        flag = session_flag(scratch: s.scratch, test_run: s.test_run, archived: s.archived, stopped_by: s.stopped_by)
-        child = s.parent_id ? "  ↳ #{s.parent_id[0, 8]}" : ""
-        child += "  ↪ #{s.continues[0, 8]}" if s.continues
-        # A question waits for an answer (chi answer, the web, chi --attach).
-        live = s.pending_question && worker_owned?(s.id, state_dir)
-        waiting = s.waiting_question(live: !!live)
-        status = if waiting&.dig(:relayed_to) then "waiting (in parent #{waiting[:relayed_to]})"
-                 elsif waiting then "waiting"
-                 else s.status
-                 end
-        "#{s.id}  #{status.ljust(8)}  #{ctx.call(s).ljust(8)}  #{s.updated_at}  #{list_text.call(s)}#{flag}#{child}"
-      end
-      if project
-        sessions.each { |s| @stdout.puts row.call(s) }
-        @stdout.puts "#{"\n" unless sessions.empty?}#{scope_note.call(sessions.size)}"
-      elsif sessions.empty?
-        @stdout.puts "No sessions."
-      else
-        sessions.each { |s| @stdout.puts row.call(s) }
-        @stdout.puts "\n#{sessions.size} session(s) (sort=#{sort} order=#{order})"
-      end
-      0
-    end
-
     # One session's cost, tokens and progress, for a script or an agent that
     # drives sessions (chi send --wait): a live worker's GET stats, else the
     # snapshot its saved analytics.json rebuilds. Never starts a worker, and

data/lib/samagotchi/share_command.rb

@@ -101,7 +101,7 @@ module Samagotchi
       error_line("#{command_name}: #{e.message}")
       CLI::Exit::FAILED
     rescue ArgumentError => e
-      error_line("#{command_name}: #{e.is_a?(Session::AmbiguousId) ? e.message : e.message.sub(/\ASession not found: /, "no session ")}")
+      error_line("#{command_name}: #{e.message}")
       CLI::Exit::FAILED
     end
 

data/lib/samagotchi/starting_marker.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require_relative "atomic_file"
+require_relative "session"
+
+module Samagotchi
+  # A continue's "starting" marker on its new link: written before the
+  # continue moves delegates there (ChildMove) and spawns the link's worker,
+  # removed by that worker once it holds the owner lock (Worker#start). While
+  # it is #fresh?, nothing else spawns a worker for the link (SpawnPart's
+  # resume_session and wake_for_report): a ring from a moved child must not
+  # start a second one. CROSS-VERSION: the file name and its {pid, at} are
+  # read and cleared by other chi versions (spec/worker_contract_spec.rb).
+  module StartingMarker
+    # <new link dir>/starting: {pid, at}, from the move to the worker's spawn.
+    FILE = "starting"
+    # A starting marker older than this, or whose process is gone, is left
+    # over from a continue that died: it holds nothing back.
+    STALE = 60.0
+
+    module_function
+
+    # Hold off a worker for the continue's new link (#fresh?) until its
+    # own worker holds it: written before the move, removed by that worker
+    # once it has the owner lock (Worker#start).
+    def mark(session_id, state_dir:)
+      dir = Session.session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, FILE), JSON.generate({ "pid" => Process.pid, "at" => Time.now.iso8601(3) }))
+    end
+
+    def clear(session_id, state_dir:)
+      FileUtils.rm_f(File.join(Session.session_dir(session_id, state_dir: state_dir), FILE))
+    end
+
+    # Whether a continue is moving delegates to +session_id+ right now: its
+    # marker is there, fresh, and the process that wrote it runs.
+    def fresh?(session_id, state_dir:)
+      file = File.join(Session.session_dir(session_id, state_dir: state_dir), FILE)
+      return false unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      return false if Time.now - Time.iso8601(data["at"].to_s) > STALE
+
+      process_alive?(data["pid"].to_i)
+    rescue JSON::ParserError, ArgumentError, SystemCallError
+      false
+    end
+
+    # Signal 0 only asks whether the process exists.
+    def process_alive?(pid)
+      return false unless pid.positive?
+
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      true
+    end
+  end
+end

data/lib/samagotchi/steer_cut_after.rb

@@ -32,27 +32,20 @@ module Samagotchi
       nil
     end
 
-    # The seconds for +target+ and where they came from
+    # The seconds for +lookup+'s model and where they came from
     # ("SAMAGOTCHI_STEER_CUT_AFTER", "models: qwen", "hosts.splash",
     # "steer.cut_after"; nil for the default).
-    # @param target [HostRegistry::ModelTarget]
-    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
-    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @param lookup [ModelLookup] the model's layers (EffectiveModel#lookup)
     # @return [Array(Integer, String|nil)]
-    def resolve(target, names:, models: nil)
-      value, origin = Config.get_with_origin("steer.cut_after")
+    def resolve(lookup)
+      value, origin = lookup.global("steer.cut_after")
       return [value.to_i, ENV_KEY] if origin == :env
 
-      models ||= begin
-        ConfigFile.model_settings
-      rescue StandardError
-        {}
-      end
-      setting = ConfigFile.model_setting(names, :steer_cut_after, models: models)
+      setting = lookup.model(:steer_cut_after)
       return [setting.value, "models: #{setting.key}"] if setting
 
-      host = target.entry.steer_cut_after
-      return [host, "hosts.#{target.entry.name}"] unless host.nil?
+      host = lookup.host(:steer_cut_after)
+      return [host, "hosts.#{lookup.host_name}"] unless host.nil?
 
       return [value.to_i, "steer.cut_after"] if origin == :file