samagotchi 0.155.0 → 0.157.0

data/lib/samagotchi/bundles/system/memory_guide.md

@@ -114,7 +114,7 @@ Bundles are versioned directories/zips/tar.gz/git URLs with a `manifest.yml` and
 | Command | Purpose |
 |---------|---------|
 | `install <source> [--scope system\|project] [--force]` | Install from dir/zip/tar.gz/git URL. `--force` overwrites existing entries, otherwise skips them; a skipped file stays the user's (not recorded, never upgraded or removed by the bundle). It also installs a bundle whose `requires_chi` this chi doesn't meet: without `--force` that install is refused (`NAME can't be installed: it requires chi …`). Writes provenance to `.bundles/<name>/` (base snapshots + `manifest.json`) and updates `index.md`. Warns on double-brace placeholders and checksum mismatches (strict mode). |
-| `upgrade <source\|name> [--force] [--dry-run] [--agent]` | A bare `name` is an installed bundle: chi upgrades it from the source its record keeps (its git URL with the `#ref` it recorded, its folder, or the archive it came from) — a dev install is refused, and a record whose source is gone says so and asks for the path or URL. Otherwise 3-way merge upgrade (base vs current vs incoming) per `Merger::Upgrade#outcome` (`Merger.classify`, then a text merge where both sides changed): `install` (new file), `noop` (current==incoming), `fast_forward` (current==base, not edited → auto-update), `keep` (incoming==base → preserve local edits), `merged` (both edited, a text merge with `git` comes out clean → the file takes it, the old one goes to the bundle trash, and entries both sides added under a `Changelog` heading are kept), `conflict` (both edited, a real conflict, or no `git` or base → the file stays untouched and marked, reported as `X stays behind 0.8.0: …` with why and what it missed, needs a retry, `--force`, which copies it to the trash first, or interactive `memory_write` resolution). A marked file is retried at the same version: the system bundle's at each chi start and on `chi update`, another shipped bundle's on `chi update`, any other bundle's on `chi bundle upgrade`. A file marked by an older chi merges normally when its recorded base is a version chi shipped (an installed samagotchi gem still has it); otherwise it merges only if the bundle takes out or rewords no line it still holds, and if it does, it stays behind until resolved by hand, with `--agent` or with `--force`, and the retry can't fix that. Pruned files (removed from new bundle) are kept if locally edited, otherwise warned. |
+| `upgrade <source\|name> [--force] [--dry-run] [--agent]` | A bare `name` is an installed bundle: chi upgrades it from the source its record keeps (its git URL with the `#ref` it recorded, its folder, or the archive it came from) — a dev install is refused, and a record whose source is gone says so and asks for the path or URL. Otherwise 3-way merge upgrade (base vs current vs incoming) per `Merger::Upgrade#decision` (the file's `FileState` and its `FileActions` row, then a text merge where both sides changed): `install` (new file), `noop` (current==incoming), `fast_forward` (current==base, not edited → auto-update), `keep` (incoming==base → preserve local edits), `merged` (both edited, a text merge with `git` comes out clean → the file takes it, the old one goes to the bundle trash, and entries both sides added under a `Changelog` heading are kept), `conflict` (both edited, a real conflict, or no `git` or base → the file stays untouched and marked, reported as `X stays behind 0.8.0: …` with why and what it missed, needs a retry, `--force`, which copies it to the trash first, or interactive `memory_write` resolution). A marked file is retried at the same version: the system bundle's at each chi start and on `chi update`, another shipped bundle's on `chi update`, any other bundle's on `chi bundle upgrade`. A file marked by an older chi merges normally when its recorded base is a version chi shipped (an installed samagotchi gem still has it); otherwise it merges only if the bundle takes out or rewords no line it still holds, and if it does, it stays behind until resolved by hand, with `--agent` or with `--force`, and the retry can't fix that. Pruned files (removed from new bundle) are kept if locally edited, otherwise warned. |
 | `uninstall <bundle> [--force]` | Moves the bundle's memory files to `.bundles/.trash/<bundle>-<time>/` (refuses locally edited ones unless `--force`; keeps a file another installed bundle also lists), removes their `index.md` lines, deletes the provenance dir. |
 | `status [<bundle>]` | Provenance + per-file `ok|modified|missing|unreadable|no-index` vs stored checksum and base snapshot, and what stays behind or merged at a chi start; `issues=` counts files behind, missing or unreadable, not edits; a model overlay (`<name>.<key>.md`) has no index line and reads `ok (model overlay)`. |
 | `diff <bundle> [file]` | Prints `base` (provenance snapshot) vs `current` (on-disk) for each file. |

data/lib/samagotchi/child_move.rb

@@ -18,27 +18,22 @@ module Samagotchi
   autoload :SessionContinue, File.expand_path("session_continue", __dir__)
 
   # A continue moving the previous link's open delegates to the chain's new
-  # link (SessionManager.continue_session), instead of archiving them with
+  # link (SessionContinue.run), instead of archiving them with
   # it. A moved child gets a parent override (Session::PARENT_FILE), never a
   # rewritten session file, so its live worker saving a stale copy changes
   # nothing; its worker reads the override for its rings and at each turn's
   # start (Bridge::FEATURES "reparent").
   #
   # #apply runs between the new link's save and its worker's spawn, while
-  # the link is #mark_starting (a ring from a moved child must not spawn a
-  # second worker from the child's process until the link's own holds it).
-  # Each step is idempotent,
-  # and an intent file (INTENT_FILE) in the new link's folder names the move
-  # until it is done: a worker that starts and finds one finishes the move
-  # (#adopt), and a failed continue moves the same children back.
+  # the link is marked starting (StartingMarker): a ring from a moved child
+  # must not spawn a second worker from the child's process until the link's
+  # own holds it. Each step is idempotent, and an intent file (INTENT_FILE)
+  # in the new link's folder names the move until it is done: a worker that
+  # starts and finds one finishes the move (#adopt), and a failed continue
+  # moves the same children back.
   module ChildMove
     # <new link dir>/move.json: {from, ids, noted}, while a move is under way.
     INTENT_FILE = "move.json"
-    # <new link dir>/starting: {pid, at}, from the move to the worker's spawn.
-    STARTING_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.
-    STARTING_STALE = 60.0
     # Who the note to a moved child is from (ContextNote's label).
     NOTE_SOURCE = "session chain"
     # What a live child's worker must name in its sidecar to be moved.
@@ -65,23 +60,23 @@ module Samagotchi
       move = []
       refuse = []
       SessionManager.children_of(prev_id, state_dir: state_dir).each do |row|
-        subtree = [row[:id], *SessionManager.descendant_ids(row[:id], state_dir)]
+        subtree = [row.id, *SessionManager.descendant_ids(row.id, state_dir)]
         next if (subtree & open_ids).empty?
 
-        if row[:archived]
+        if row.archived
           # An open delegate below an archived one: the archive's cascade
           # would take it, the move doesn't (only unarchived ones move).
           refuse.concat(open.select { |c| subtree.include?(c.id) }.map do |c|
-            c.with(why: "under archived #{row[:id][0, 8]}; unarchive that one or archive this one")
+            c.with(why: "under archived #{row.short_id}; unarchive that one or archive this one")
           end)
           next
         end
 
-        why = unmovable(row[:id], state_dir: state_dir)
+        why = unmovable(row.id, state_dir: state_dir)
         if why
-          refuse << SessionContinue::OpenChild.new(id: row[:id], short_id: row[:id][0, 8], why: why)
+          refuse << SessionContinue::OpenChild.new(id: row.id, short_id: row.short_id, why: why)
         else
-          move << row[:id]
+          move << row.id
         end
       end
       Plan.new(move: move, refuse: refuse)
@@ -206,44 +201,5 @@ module Samagotchi
              end
       SessionInbox.write_note(child_id, text: text, source: NOTE_SOURCE, state_dir: state_dir)
     end
-
-    # Hold off a worker for the continue's new link (#starting?) until its
-    # own worker holds it: written before the move, removed by that worker
-    # once it has the owner lock (Worker#start).
-    def mark_starting(session_id, state_dir:)
-      dir = Session.session_dir(session_id, state_dir: state_dir)
-      FileUtils.mkdir_p(dir)
-      AtomicFile.write(File.join(dir, STARTING_FILE), JSON.generate({ "pid" => Process.pid, "at" => Time.now.iso8601(3) }))
-    end
-
-    def clear_starting(session_id, state_dir:)
-      FileUtils.rm_f(File.join(Session.session_dir(session_id, state_dir: state_dir), STARTING_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 starting?(session_id, state_dir:)
-      file = File.join(Session.session_dir(session_id, state_dir: state_dir), STARTING_FILE)
-      return false unless File.exist?(file)
-
-      data = JSON.parse(File.read(file))
-      return false if Time.now - Time.iso8601(data["at"].to_s) > STARTING_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/child_reports.rb

@@ -335,8 +335,8 @@ module Samagotchi
       before = kept ? kept.after : current
       # A follow-up's turn (DelegateCursor#turn) is reported by its own
       # reply, as delegate_result takes it, not a newer queued turn's.
-      wait = ReplyWait.call(child_id, state_dir: @state_dir, cursor: before.reply_file, baseline: before.baseline,
-                                      timeout: 0, turn: before.turn)
+      wait = ReplyWait.call(child_id, state_dir: @state_dir, **ReplyWait::Target.from_cursor(before, child: child).to_h,
+                                      timeout: 0)
       return nil unless reportable?(wait)
 
       claim_id = before.report_claim&.id || SecureRandom.hex(16)

data/lib/samagotchi/children_status.rb

@@ -5,7 +5,8 @@ require_relative "session"
 require_relative "archive_store"
 require_relative "git_head"
 require_relative "reply_wait"
-require_relative "worker_link"
+require_relative "owner_lock"
+require_relative "session_row"
 require_relative "tools/delegate"
 require_relative "tools/delegate_cursor"
 
@@ -50,44 +51,47 @@ module Samagotchi
     def of(parent_id, state_dir:, include_archived: false)
       cursors = Tools::DelegateCursors.read(parent_id, state_dir: state_dir)
       SessionManager.children_of(parent_id, state_dir: state_dir).filter_map do |row|
-        next if row[:archived] && !include_archived
+        next if row.archived && !include_archived
 
-        session = load(row[:id], state_dir: state_dir)
+        session = load(row.id, state_dir: state_dir)
         session && child(session, row, cursors, state_dir: state_dir)
       end
     end
 
     # The cheap path for the glance views: only the children in the
-    # parent's delegates.json (one Session.load and an owner check each, no
+    # parent's delegates.json (one Session.load and a SessionRow each, no
     # scan). Its keys can also name a fork the model passed to delegate
     # session: or a deleted child: only live delegates of this parent count,
     # archived ones don't.
     # @return [Counts]
     def counts(parent_id, state_dir:)
       cursors = Tools::DelegateCursors.read(parent_id, state_dir: state_dir)
+      budgets = SessionRow.budgets
       children = cursors.keys.filter_map do |id|
         session = load(id, state_dir: state_dir)
         next unless session&.delegate? && session.parent_id == parent_id
         next if ArchiveStore.archived?(Session.session_dir(id, state_dir: state_dir))
 
-        child(session, summary_of(session, state_dir: state_dir), cursors, state_dir: state_dir)
+        dir = Session.session_dir(id, state_dir: state_dir)
+        child(session, SessionRow.build(session, session_dir: dir, owner: OwnerLock.owner(dir), budgets: budgets), cursors,
+              state_dir: state_dir)
       end
       Counts.new(running: children.count { |c| c.state == "running" },
                  waiting: children.count { |c| c.state == "waiting" },
                  unreported: children.count { |c| c.last_reply && !c.reported })
     end
 
-    # @param row [Hash] a children_of row, or summary_of's keys
+    # @param row [SessionRow] the child's row
     # @param cursors [Hash] the parent's delegates.json
     def child(session, row, cursors, state_dir:)
       reply = ReplyWait.newest_reply(session.id, state_dir: state_dir)
       cursor = Tools::DelegateCursors.get_from(cursors, session.id)
-      Child.new(id: session.id, short_id: session.id[0, 8], title: (session.title || row[:preview]).to_s,
-                state: state_of(session, row, reply), waiting: row[:waiting], live: !!row[:live],
+      Child.new(id: session.id, short_id: session.id[0, 8], title: (session.title || row.preview).to_s,
+                state: state_of(session, row, reply), waiting: row.waiting, live: !!row.live,
                 delegate: session.delegate?, cwd: session.working_directory, branch: GitHead.branch(session.working_directory),
                 last_reply: reply && first_line(session.id, reply, state_dir: state_dir),
                 last_reply_at: reply && reply_time(reply), reported: !reply.nil? && reported?(session, cursor, reply),
-                updated_at: session.updated_at, archived: !!row[:archived])
+                updated_at: session.updated_at, archived: !!row.archived)
     end
     private_class_method :child
 
@@ -97,8 +101,8 @@ module Samagotchi
     private_class_method :reported?
 
     def state_of(session, row, reply)
-      return "waiting" if row[:waiting]
-      return "running" if Tools::Delegate.running?(row)
+      return "waiting" if row.waiting
+      return "running" if row.running_or_starting?
       return "stopped" if session.status == Session::STATUS_STOPPED
 
       outcome = session.last_turn&.outcome
@@ -109,16 +113,6 @@ module Samagotchi
     end
     private_class_method :state_of
 
-    # The keys of a children_of row that state_of and child read, for a
-    # session counts loaded itself.
-    def summary_of(session, state_dir:)
-      live = WorkerLink.resolve(Session.session_dir(session.id, state_dir: state_dir), unlink: false).worker_owned?
-      { live: live, busy: live && session.status == Session::STATUS_RUNNING, status: session.status,
-        updated_at: session.updated_at, waiting: session.waiting_question(live: live)&.dig(:kind),
-        preview: session.last_prompt.to_s }
-    end
-    private_class_method :summary_of
-
     def first_line(id, file, state_dir:)
       text = File.read(File.join(ReplyWait.reply_dir(id, state_dir: state_dir), file), 4096)
       text.each_line.map(&:strip).find { |line| !line.empty? }.to_s

data/lib/samagotchi/cli/parent_wait.rb

@@ -17,9 +17,6 @@ module Samagotchi
     # override the constants (specs stub them on the class).
     module ParentWait
       POLL_INTERVAL = ReplyWait::POLL_INTERVAL
-      # No live worker this long while waiting: it died before it could mark
-      # the session (a worker takes well under a second to start).
-      WORKER_GONE_AFTER = 5
       FORMATS = %w[text json].freeze
 
       # @return [Integer] the exit status
@@ -55,30 +52,19 @@ module Samagotchi
       def resolve(given)
         @session_id = @access.resolve(given)
       rescue ArgumentError => e
-        error_line("#{command_name}: #{e.is_a?(Session::AmbiguousId) ? e.message : "no session #{given}"}")
+        error_line("#{command_name}: #{e.message}")
         nil
       end
 
-      # Wait for the session's next reply past +cursor+ (ReplyWait) and
-      # report it. Ctrl-C leaves the turn running (130).
-      # @param owner_grace [Numeric, nil] seconds with no live worker before
-      #   it counts as gone; nil waits for whatever wakes one
-      # @param turn [String, nil] the enqueued_id of the turn waited for
-      #   (ReplyWait's turn:): a queued message's, or the turn an answer or
-      #   a --wait with no message is about (ReplyWait.own_turn)
-      # @param queued [Boolean] +turn+ is a queued message's (ReplyWait's
-      #   queued:)
-      # @param ended_before [Boolean] a last_turn that ended before the
-      #   baseline is the answer (ReplyWait's ended_before:) — the
-      #   --wait-with-no-message's settled session
-      # @param report_turn_id [String, nil] the turn id to include in the
-      #   report, even when ReplyWait uses the next-reply path
+      # Wait for what +target+ binds (ReplyWait) and report it. Ctrl-C
+      # leaves the turn running (130).
+      # @param target [ReplyWait::Target] which turn, from the cursor and
+      #   baseline prepare_wait read; its report_turn_id is the turn id the
+      #   report names, even when ReplyWait takes the next reply
       # @return [Integer] the exit status
-      def wait_for_reply(id, cursor:, baseline:, timeout:, owner_grace: self.class::WORKER_GONE_AFTER, turn: nil,
-                         queued: false, ended_before: false, report_turn_id: turn)
-        result = @access.wait_reply(id, cursor: cursor, timeout: timeout, baseline: baseline, owner_grace: owner_grace,
-                                        poll_interval: self.class::POLL_INTERVAL, turn: turn, queued: queued,
-                                        ended_before: ended_before)
+      def wait_for_reply(id, target:, timeout:)
+        report_turn_id = target.report_turn_id
+        result = @access.wait_reply(id, **target.to_h, timeout: timeout, poll_interval: self.class::POLL_INTERVAL)
         result.turn_id = report_turn_id if report_turn_id && !report_turn_id.to_s.empty?
         result.text = result.text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
         @reported = true

data/lib/samagotchi/config.rb

@@ -8,11 +8,14 @@ require_relative "config_text_edit"
 require_relative "log"
 require_relative "model_ref"
 require_relative "paths"
-require_relative "llm_context_strategy"
-require_relative "host_model"
 require_relative "config/restart_watch"
 
 module Samagotchi
+  # Which LLM context strategy a turn runs under; it reads Config.
+  autoload :LLMContextStrategy, File.expand_path("llm_context_strategy", __dir__)
+  # A hosts.<name>.models entry and its price; they read ConfigFile.
+  autoload :HostModel, File.expand_path("host_model", __dir__)
+  autoload :ModelPrice, File.expand_path("model_price", __dir__)
   # Parses the thinking: levels of host and model entries (it needs Config).
   autoload :Thinking, File.expand_path("thinking", __dir__)
   # One hosts: entry; it needs ConfigFile's readers.
@@ -89,6 +92,12 @@ module Samagotchi
       next_history_access next_matching_turn_display_poll_write
     ].freeze
 
+    # llm_context.policy's default: the sentence forget_outputs' description
+    # carries (ToolDeclarations::FORGET_OUTPUTS_POLICY), the plan's D7 line,
+    # adapted from CLM's steering example.
+    DEFAULT_LLM_CONTEXT_POLICY = "Tidy at subtask boundaries: once a subtask is done, forget its tool outputs and note " \
+                                 "what it established; keep anything you'll still edit against."
+
     ENTRIES = [
       # universal – env+config+cli
       Entry.new(key: "default.model",            yaml_path: %w[default model],            type: :string, default: nil,              expose: %i[env config cli], lifecycle: :new_session),
@@ -261,7 +270,7 @@ module Samagotchi
       # and hosts.<name>.llm_context_budget_tokens come first. Kept as written: LLMContextStrategy.parse_budget reads it.
       Entry.new(key: "llm_context.budget_tokens", yaml_path: %w[llm_context budget_tokens], type: :string, default: nil,           expose: %i[env config], lifecycle: :next_matching_turn_display_poll_write),
       # The policy sentence forget_outputs' description carries (the forget layer); blank: none.
-      Entry.new(key: "llm_context.policy",       yaml_path: %w[llm_context policy],       type: :string, default: LLMContextStrategy::DEFAULT_POLICY, expose: %i[env config], lifecycle: :worker_start),
+      Entry.new(key: "llm_context.policy",       yaml_path: %w[llm_context policy],       type: :string, default: DEFAULT_LLM_CONTEXT_POLICY, expose: %i[env config], lifecycle: :worker_start),
 
       # How much models think: off|low|medium|high|default, parsed by Thinking
       # (a :string, since YAML reads an unquoted off as false). The CLI flag
@@ -364,6 +373,9 @@ module Samagotchi
       # The stage view's working set (files, memories and URLs the turn brought into context): a rail in the stage, a
       # footprint under each finished turn and a "set N" chip in place of the mem chip; ?working_set=1|0 overrides it per page load.
       Entry.new(key: "web.working_set",          yaml_path: %w[web working_set],          type: :bool,    default: true,            expose: %i[env config cli], lifecycle: :web_start),
+      # Opt-in: the page checks each finished turn against a reload of it (one full read per turn end) and chi web logs
+      # reload_checked, with reload_mismatch and the kinds that differed (counts only, no content).
+      Entry.new(key: "web.reload_check",         yaml_path: %w[web reload_check],         type: :bool,    default: false,           expose: %i[env config cli], lifecycle: :web_start),
       # Quick replies next to Annotate in the page's selection bubble, "|"-separated (a YAML list works too); "" leaves only Annotate.
       Entry.new(key: "web.annotate_presets",     yaml_path: %w[web annotate_presets],     type: :string, default: "Agreed|Could you please elaborate?", expose: %i[env config cli], lifecycle: :web_start),
       # What a file ref (a tool row's file, a diff line) opens on this machine: a preset (vscode, vscode-insiders, cursor, zed, none) or a URL template with {path} and an optional {line} (Web::Editor).
@@ -399,7 +411,7 @@ module Samagotchi
     # appended_prompt_files, Hooks::Loader, ConfigFile.bundle_settings.
     FREE_FORM_MAPS = %w[model_aliases hooks bundles memories append_system_prompt].freeze
     # Maps of named entries and the keys an entry may hold
-    # (ConfigFile.hosts_config, ConfigFile.model_settings).
+    # (HostConfig.all, ModelSettings.all).
     MAP_ENTRY_KEYS = {
       "hosts" => %w[host port url api api_key_env auth dialect profile first_token_timeout vision sampling thinking
                     reasoning_history enabled remote window_tokens steer_cut_after llm_context_strategy llm_context_apply llm_context_budget_tokens models].freeze,
@@ -408,6 +420,8 @@ module Samagotchi
     }.freeze
     # The keys a hosts.<name>.models entry may hold (HostModel.parse_map).
     HOST_MODEL_KEYS = %w[price served].freeze
+    # The keys a hosts.<name>.models.<id>.price may hold (ModelPrice.parse).
+    MODEL_PRICE_KEYS = %w[input cache_read cache_write output].freeze
     # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
     # And toolkit's kits (Toolkit.kits), and bundles' judgments' settings (SystemOne::JudgmentSettings).
     SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze, "toolkit" => %w[kits].freeze, "system_one" => %w[judgments].freeze }.freeze
@@ -887,9 +901,9 @@ module Samagotchi
       def price_key_problems(prefix, price)
         return [] unless price.is_a?(Hash)
 
-        (price.keys.map(&:to_s) - ModelPrice::KEYS).map do |k|
+        (price.keys.map(&:to_s) - MODEL_PRICE_KEYS).map do |k|
           # A renamed key is compared by its new name, so that name is the hint.
-          unknown_key_message("#{prefix}#{k}", RENAMED_PRICE_KEYS.fetch(k, k), ModelPrice::KEYS, prefix: prefix)
+          unknown_key_message("#{prefix}#{k}", RENAMED_PRICE_KEYS.fetch(k, k), MODEL_PRICE_KEYS, prefix: prefix)
         end
       end
 
@@ -1172,71 +1186,6 @@ module Samagotchi
     HOST_NAME_RE = /\A[a-z0-9][a-z0-9._-]*\z/i
     ENV_NAME_RE = /\A[A-Za-z_][A-Za-z0-9_]*\z/
 
-    # config.yml's hosts: by lowercased name; an entry that is disabled or
-    # invalid (warned) is left out. No entry left: "default", from
-    # server.host/port.
-    # @return [Hash{String => HostConfig}]
-    def hosts_config(env: ENV, path: global_path(env: env))
-      data = read_yaml(env: env, path: path)
-      raw_hosts = data[HOSTS_KEY] if data.is_a?(Hash)
-
-      normalized = {}
-      if raw_hosts.is_a?(Hash)
-        raw_hosts.each do |raw_name, raw_cfg|
-          host = HostConfig.parse(raw_name, raw_cfg)
-          normalized[host.name] = host if host
-        end
-        warn_duplicate_host_models(normalized)
-      end
-      normalized["default"] = default_host_config(data, env) if normalized.empty?
-      normalized
-    rescue StandardError => e
-      Log.error(:config, "hosts_config_failed", error: e.class.name, message: e.message)
-      {}
-    end
-
-    # The host chi uses when hosts: names none: server.host/port.
-    def default_host_config(data, env)
-      opts = { file_data: data, env: env, cli_overrides: Samagotchi::Config.cli_overrides }
-      host = Samagotchi::Config.resolve("server.host", **opts).to_s.strip
-      host = "localhost" if host.empty?
-      port = Samagotchi::Config.resolve("server.port", **opts).to_i
-      port = 8080 if port <= 0 || port > 65_535
-      HostConfig.new(name: "default", host: host, port: port)
-    end
-    private_class_method :default_host_config
-
-    # Two hosts declaring one id under hosts.<name>.models: a bare id goes
-    # where HostRegistry#host_for_model sends it (the default host when it
-    # declares the id, else the first in hosts: order); say so once.
-    def warn_duplicate_host_models(hosts)
-      declared = Hash.new { |h, k| h[k] = [] }
-      hosts.each { |name, cfg| cfg.models.each { |down, model| declared[down] << [name, model.id] } }
-      declared.each_value do |owners|
-        next if owners.size < 2
-
-        names = owners.map(&:first)
-        id = owners.first.last
-        goes = names.include?("default") ? "default" : "#{names.first} unless the default host lists it"
-        warn_once "Warning: #{names.map { |n| "hosts.#{n}.models" }.join(" and ")} #{names.size == 2 ? "both" : "all"} declare #{id}; " \
-                  "a bare #{id} goes to #{goes}"
-      end
-    end
-    private_class_method :warn_duplicate_host_models
-
-    # The names (lowercased) of the hosts entries with enabled: false, which
-    # hosts_config leaves out, from config.yml's hosts:.
-    # @return [Array<String>]
-    def disabled_host_names(env: ENV, path: global_path(env: env))
-      data = read_yaml(env: env, path: path)
-      raw = data[HOSTS_KEY] if data.is_a?(Hash)
-      return [] unless raw.is_a?(Hash)
-
-      raw.filter_map { |name, cfg| name.to_s.strip.downcase if cfg.is_a?(Hash) && HostConfig.disabled?(cfg) }
-    rescue StandardError # degrade-ok: Config↔Log: Log resolves its file and level through Config
-      []
-    end
-
     # Resolve the `recap:` section through the Config registry so scalar
     # recap settings share the single precedence path (CLI > ENV > file >
     # default). Returns false when explicitly disabled (file `recap: false`
@@ -1420,47 +1369,6 @@ module Samagotchi
       {}
     end
 
-    # The top-level `models:` map: per-model settings keyed by model id or
-    # alias (downcased), e.g. `models: {my-alias: {profile: qwen36}}`, each a
-    # ModelSettings; an entry that is not a map is skipped.
-    # @return [Hash{String => ModelSettings}]
-    def model_settings(env: ENV, path: global_path(env: env))
-      data = read_yaml(env: env, path: path)
-      raw = data[MODELS_KEY] if data.is_a?(Hash)
-      return {} unless raw.is_a?(Hash)
-
-      raw.each_with_object({}) do |(k, v), result|
-        key = k.to_s.strip.downcase
-        settings = ModelSettings.parse(key, v)
-        result[key] = settings if settings
-      end
-    rescue StandardError # degrade-ok: Config↔Log: Log resolves its file and level through Config
-      {}
-    end
-
-    # The first +names+ (model as typed, alias-resolved, bare, …) whose
-    # models: entry sets +field+ (a ModelSettings member; another name
-    # raises ArgumentError): a ModelSetting (key, value), or nil.
-    # VisionSupport and SamplingSettings look a model up the same way.
-    # @param models [Hash{String => ModelSettings}, nil] model_settings by default
-    # @return [ModelSetting, nil]
-    def model_setting(names, field, models: nil)
-      raise ArgumentError, "unknown models: field #{field.inspect}" unless ModelSettings.members.include?(field)
-
-      models ||= model_settings
-      Array(names).map { |name| name.to_s.strip.downcase }.reject(&:empty?).uniq.each do |key|
-        value = models[key]&.public_send(field)
-        return ModelSetting.new(key: key, value: value) unless value.nil?
-      end
-      nil
-    end
-
-    # +raw+ parsed against config.yml's hosts (or +hosts+) and aliases.
-    # @return [ModelRef]
-    def model_ref(raw, env: ENV, path: global_path(env: env), hosts: nil)
-      ModelRef.parse(raw, hosts: hosts || hosts_config(env: env, path: path), aliases: model_aliases(env: env, path: path))
-    end
-
     # Words /model takes as arguments (clear/default/none/off reset the
     # runtime model), so no alias may be named after one.
     RESERVED_MODEL_ALIASES = %w[clear default none off].freeze

data/lib/samagotchi/context_command.rb

@@ -428,8 +428,7 @@ module Samagotchi
       session = @access.show(id)
       Target.new(session_id: id, project_root: session.project_root, cwd: session.working_directory, label: id[0, 8])
     rescue ArgumentError => e
-      message = e.is_a?(Session::AmbiguousId) ? e.message : "no session #{given}"
-      error_line("#{command_name}: #{message}")
+      error_line("#{command_name}: #{e.message}")
       nil
     end
 

data/lib/samagotchi/context_sources.rb

@@ -7,6 +7,7 @@ require "time"
 require_relative "atomic_file"
 require_relative "memory_paths"
 require_relative "paths"
+require_relative "session_paths"
 require_relative "session"
 
 module Samagotchi
@@ -617,13 +618,13 @@ module Samagotchi
       nil
     end
 
-    # <state dir>/context; +state_dir+ is the sessions dir (Session.default_state_dir).
+    # <state dir>/context; +state_dir+ is the sessions dir (SessionPaths.default_state_dir).
     def root(state_dir: nil)
-      File.join(File.dirname(state_dir || Session.default_state_dir), DIR)
+      File.join(File.dirname(state_dir || SessionPaths.default_state_dir), DIR)
     end
 
     def session_location(session_id, state_dir: nil)
-      Location.new(scope: "session", dir: File.join(root(state_dir: state_dir), "sessions", Session.check_id!(session_id)),
+      Location.new(scope: "session", dir: File.join(root(state_dir: state_dir), "sessions", SessionPaths.check_id!(session_id)),
                    key: session_id)
     end
 
@@ -669,7 +670,7 @@ module Samagotchi
     # A deleted session's sources, snapshots, subscriptions and markers.
     # @return [Array<String>] the paths removed
     def remove_session(session_id, state_dir: nil)
-      return [] unless Session.valid_id?(session_id.to_s)
+      return [] unless SessionPaths.valid_id?(session_id.to_s)
 
       dir = session_location(session_id, state_dir: state_dir).dir
       return [] unless Dir.exist?(dir)

data/lib/samagotchi/context_window.rb

@@ -11,14 +11,14 @@ module Samagotchi
   #      provider's context_length)
   #   3. models.<key>.window_tokens, else hosts.<name>.window_tokens
   #      (#setting: the most specific wins)
-  #   4. context.window_tokens (CLI, SAMAGOTCHI_CONTEXT_WINDOW_TOKENS or the
-  #      config file)
+  #   4. context.window_tokens (--context-window-tokens,
+  #      SAMAGOTCHI_CONTEXT_WINDOW_TOKENS or the config file)
   #   5. DEFAULT_TOKENS
   # Settings (3 and 4) only fill in when the server and its list report
   # nothing.
   #
-  # Sources: :server, :model_list, :model_setting, :host_setting, :config
-  # (CLI or file), :env, :default.
+  # Sources: :server, :model_list, :model_setting, :host_setting, :cli,
+  # :env, :config (the file), :default.
   module ContextWindow
     DEFAULT_TOKENS = 256_000
 
@@ -48,16 +48,13 @@ module Samagotchi
     # The window config.yml gives this model or its host:
     # models.<key>.window_tokens (by the model's lookup names, as sampling
     # and vision look a model up), else hosts.<name>.window_tokens.
-    # @param target [HostRegistry::ModelTarget]
-    # @param names [Array<String>] HostRegistry#lookup_names
-    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @param lookup [ModelLookup] the model's layers (EffectiveModel#lookup)
     # @return [Resolved, nil]
-    def setting(target, names:, models: nil)
-      models ||= ConfigFile.model_settings
-      tokens = ConfigFile.model_setting(names, :window_tokens, models: models)&.value
+    def setting(lookup)
+      tokens = lookup.model(:window_tokens)&.value
       return Resolved.new(tokens: tokens, source: :model_setting) if positive_integer?(tokens)
 
-      tokens = target&.entry&.window_tokens
+      tokens = lookup.host(:window_tokens)
       positive_integer?(tokens) ? Resolved.new(tokens: tokens, source: :host_setting) : nil
     rescue StandardError
       nil
@@ -79,7 +76,7 @@ module Samagotchi
       end
       return Resolved.new(tokens: DEFAULT_TOKENS, source: :default) unless positive_integer?(value)
 
-      Resolved.new(tokens: value, source: origin == :env ? :env : :config)
+      Resolved.new(tokens: value, source: { cli: :cli, env: :env }.fetch(origin, :config))
     end
 
     # For callers with no client at hand (tool output guardrails): the last

data/lib/samagotchi/desktop/macos.rb

@@ -335,7 +335,7 @@ module Samagotchi
       # are left out. @return [Array<Hash>] name:, hosts:, state:
       def host_keys
         config_env = { "XDG_CONFIG_HOME" => launch_config_home }
-        hosts = ConfigFile.hosts_config(env: config_env).values.select(&:api_key_env).group_by(&:api_key_env)
+        hosts = HostConfig.all(env: config_env).values.select(&:api_key_env).group_by(&:api_key_env)
         hosts.map do |name, entries|
           state = if HostKeys.from_keychain(name, env: @env) then :keychain
                   elsif !@env[name].to_s.strip.empty? then :shell_only