samagotchi 0.156.0 → 0.158.0

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.displayed_status(owner: Samagotchi::SessionManager.session_owner(s.id, state_dir: state_dir))
-                 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/steer.rb

@@ -364,6 +364,16 @@ module Samagotchi
       turn_prompt?(message) && !shell_line?(message)
     end
 
+    # An opening's stamp: its turn_id (a prompt's, a wake note's), else its
+    # own opening_id (/continue no's reason line); nil for neither (a line
+    # an older chi wrote). Where a card (Bridge::CardPlaces) and the recap
+    # (RecapPlace) sit.
+    # @return [String, nil]
+    def opening_stamp(message)
+      id = message[:turn_id] || message["turn_id"] || message[:opening_id] || message["opening_id"]
+      id.is_a?(String) && !id.empty? ? id : nil
+    end
+
     # Call a loop's drain: +at_answer+ goes only to a drain that takes it
     # (the Engine's); a caller's own drain (a queue's #drain) is called bare.
     # A failing drain drains nothing (the loop keeps going).

data/lib/samagotchi/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] ModelSettings.all (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
-        ModelSettings.all
-      rescue StandardError
-        {}
-      end
-      setting = ModelSettings.find(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
 

data/lib/samagotchi/system_prompt.rb

@@ -291,7 +291,7 @@ module Samagotchi
           6. Use write for full-file rewrites or creating new files.
 
         Memory convention:
-          Project scope: one folder per git repository, shared by its worktrees and subdirectories (its path is on the "Project memories folder" line below)
+          Project scope: one folder per project (a git repository, shared by its worktrees and subdirectories, or a folder marked by `chi project init` and its subfolders; its path is on the "Project memories folder" line below)
           System scope:  ~/.config/samagotchi/memories/ (cross-project)
           memory_read accepts optional scope (project|system).
           memory_write requires explicit scope and entry name.
@@ -623,10 +623,20 @@ module Samagotchi
       File.expand_path(path)
     end
 
+    # The project_location line over its top, for a checkout (git) or a
+    # marked project: [below the top, at the top].
+    TOP_LINES = {
+      git: ["Top of this checkout (where the project's commands run from; stay inside it):",
+            "This checkout (the project's files; its commands run here):"],
+      marker: ["Top of this project (where its commands run from; stay inside it):",
+               "This project (its files; its commands run here):"]
+    }.freeze
+
     # Where the session runs and which project memory folder it uses. Only
-    # this checkout is named: its top (at its root too, so a model doesn't
-    # take the memories folder for the project and cd there, Qwen
-    # 2026-10-06), and in a linked worktree a line that work stays in it. The repository's main
+    # this checkout (or marked project, MemoryPaths.lookup) is named: its
+    # top (at its root too, so a model doesn't take the memories folder for
+    # the project and cd there, Qwen 2026-10-06), and in a linked worktree
+    # a line that work stays in it. The repository's main
     # checkout (MemoryPaths.project_root, which scopes memories and session
     # lists) is never shown: a model told its path went to work there
     # (a worktree child committed onto main, 2026-10-03 and 2026-10-06).
@@ -635,16 +645,15 @@ module Samagotchi
     def project_location
       Degrade.call(:prompt, "location_failed") do
         cwd = Dir.pwd
-        top = MemoryPaths.work_tree_root(cwd)
+        found = MemoryPaths.lookup(cwd)
+        top = found.top
         lines = ["Current working directory:", cwd]
-        if top && top != cwd
-          lines << "Top of this checkout (where the project's commands run from; stay inside it):"
-          lines << top
-        elsif top
-          lines << "This checkout (the project's files; its commands run here):"
+        if top
+          below, at = TOP_LINES.fetch(found.kind)
+          lines << (top == cwd ? at : below)
           lines << top
         end
-        if top && MemoryPaths.project_root(cwd) != top
+        if found.git? && found.root != top
           lines << "This checkout is a linked git worktree: read, edit, run and commit only in it, never in the " \
                    "repository's other checkouts."
         end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -613,39 +613,19 @@ module Samagotchi
                                         lane = :writing
           when :generation_chunk
             tail, lane = event[:thinking].to_s.empty? ? [event[:text], :writing] : [event[:thinking], :thinking]
-          when :tool_call_started
-            running_tool = event[:tool]
-            @renderer.call(event)
-          when :tool_call_completed
-            running_tool = nil
-            replay_tool_completed(event)
-          when :merged_input then @screen.commit("input> #{event[:content]}")
-          when :reminder_injected then @screen.commit(reminder_line(event[:reminders]))
-          # The turn's start (its images), a plugin's steer, and its rows (a
-          # hook's notice, a retry's line), as they were drawn live.
-          # Questions are left out: the pending one is asked after the
-          # replay, answered ones showed no line.
+          # The turn's start (its images), as it was drawn live.
           when :turn_started then @renderer.call(without_named_images(event, turn[:prompt]))
-          when :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut, :llm_context_edited
-            @renderer.call(event)
+          # Its rows, as a drawn turn's (JoinReplay#replay_row).
+          else
+            running_tool = event[:tool] if event[:type] == :tool_call_started
+            running_tool = nil if event[:type] == :tool_call_completed
+            @join_replay.replay_row(event)
           end
         end
         @view.resume(tail: tail, lane: lane, tool: running_tool, parts: turn[:parts])
         ask(turn[:pending_question]) if turn[:pending_question]
       end
 
-      # A finished tool call of the joined turn: the live row (action,
-      # duration). A snapshot from an older worker has no action: its row
-      # names the tool only.
-      def replay_tool_completed(event)
-        return @renderer.call({ duration_ms: nil }.merge(event)) if event.dig(:activity, :action)
-
-        activity = EventRenderer.described(event) || {}
-        @screen.commit(snapshot_tool_line({ tool: event[:tool], params: activity[:params], status: activity[:status],
-                                            description: activity[:description], output_truncated: event[:output_truncated],
-                                            images: event[:images], diff: event[:diff] }))
-      end
-
       def start_turn(event)
         @running = true
         @joined_mid_turn = false