samagotchi 0.82.0 → 0.84.0

data/lib/samagotchi/bundle_session_settings.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "version"
+
+module Samagotchi
+  # A session's own bundle settings (chi --set BUNDLE.KEY=VALUE, chi send
+  # --new --set, POST /api/sessions bundle_settings): {bundle => {key =>
+  # value}}, string keys, scalar values (.typed). A bundle offers the keys a
+  # session may set in its manifest's session_settings: (recorded at install,
+  # InstalledBundle#session_settings); any other bundle or key is refused, so
+  # a typo isn't saved. The session keeps them (Session#bundle_settings,
+  # SessionSetup) and Plugin::Context#settings lays them over config.yml's
+  # bundles: <name>:.
+  module BundleSessionSettings
+    # A refused --set (or request field): the message says why.
+    class Error < ArgumentError; end
+
+    # A bundle name (MemoryBundle::Manifest::BUNDLE_NAME) and a setting key.
+    BUNDLE = /\A[A-Za-z0-9][A-Za-z0-9_-]*\z/
+    KEY = /\A[A-Za-z0-9_][A-Za-z0-9_-]*\z/
+    # The values a setting may take.
+    SCALARS = [String, Integer, Float, TrueClass, FalseClass].freeze
+    REQUEST_SHAPE = "bundle_settings is an object of bundle => {key => scalar}"
+    # What .typed reads as a number: no leading zero, no exponent, no _.
+    INTEGER = /\A-?(?:0|[1-9]\d*)\z/
+    DECIMAL = /\A-?(?:0|[1-9]\d*)\.\d+\z/
+    # The shipped bundles' sources (a stale record's hint reads them).
+    SHIPPED_DIR = File.expand_path("bundles", __dir__)
+
+    # The installed bundles a session may set settings of: +offered+ the
+    # keys of each bundle whose plugin loads ({name => keys}), +notes+ what
+    # a refusal adds for a bundle ({name => text}): why its plugin doesn't
+    # load, or how to refresh a record from before session_settings.
+    Availability = Data.define(:offered, :notes)
+
+    module_function
+
+    # --set's values as typed, in order: a later one of the same key wins.
+    # @param args [Array<String>] "BUNDLE.KEY=VALUE" each
+    # @return [Hash{String => Hash{String => Object}}] frozen
+    # @raise [Error] a value of another shape
+    def parse(args)
+      settings = {}
+      Array(args).each do |arg|
+        target, sep, raw = arg.to_s.partition("=")
+        bundle, *keys = target.split(".", -1)
+        if sep.empty? || keys.empty? || !BUNDLE.match?(bundle.to_s) || keys.any? { |key| !KEY.match?(key) }
+          raise Error, "--set takes BUNDLE.KEY=VALUE, not #{arg}"
+        end
+        raise Error, "--set #{arg}: one key under the bundle (BUNDLE.KEY), no nested path" if keys.size > 1
+        raise Error, "--set #{arg}: give a value" if raw.strip.empty?
+
+        (settings[bundle] ||= {})[keys.first] = typed(raw)
+      end
+      deep_freeze(settings)
+    end
+
+    # +settings+ when every bundle is installed and offers each key.
+    # @param bundles [Hash{String => Array<String>}] the installed bundles'
+    #   offered keys (.offered)
+    # @param notes [Hash{String => String}] Availability#notes
+    # @param flag [String] what a refusal names ("--set", a request field)
+    # @return [Hash] +settings+
+    # @raise [Error]
+    def check!(settings, bundles: offered, notes: {}, flag: "--set")
+      settings.each do |bundle, values|
+        keys = bundles[bundle]
+        note = notes[bundle]
+        values.each_key do |key|
+          where = "#{flag} #{bundle}.#{key}"
+          raise Error, "#{where}: #{note || "no installed bundle #{bundle} (#{takers(bundles)})"}" if keys.nil?
+          raise Error, "#{where}: #{bundle} takes no session settings#{" #{note}" if note}" if keys.empty?
+          raise Error, "#{where}: #{bundle} takes #{keys.join(", ")}" unless keys.include?(key)
+        end
+      end
+      settings
+    end
+
+    # --set's values parsed and checked (.parse, .check!) against the
+    # installed bundles (.availability).
+    def from_flags(args, available: availability)
+      check!(parse(args), bundles: available.offered, notes: available.notes)
+    end
+
+    # A value as --set (and a request's string) gives it: an integer
+    # ("3", "-1"), a decimal ("2.5"), true, false or off (false); any other
+    # string stays as given ("010", "0x10", "3:30", "No", "null"). A value
+    # that isn't a String (a JSON number or boolean) is kept.
+    def typed(value)
+      return value unless value.is_a?(String)
+
+      case value
+      when INTEGER then Integer(value, 10)
+      when DECIMAL then Float(value)
+      when "true" then true
+      when "false", "off" then false
+      else value
+      end
+    end
+
+    # POST /api/sessions bundle_settings: nil for none, else an object of
+    # objects of scalars (a string typed as --set's, .typed), checked like
+    # --set; an empty bundle entry is dropped.
+    # @param bundles [Hash, nil] the offered keys (.availability's by default)
+    # @return [Hash] frozen
+    # @raise [Error]
+    def from_request(raw, bundles: nil)
+      return {} if raw.nil?
+      raise Error, REQUEST_SHAPE unless raw.is_a?(Hash) && raw.all? { |_, values| scalar_map?(values) }
+
+      settings = normalize(raw.transform_values { |values| values.transform_values { |value| typed(value) } })
+      return settings if settings.empty?
+
+      available = bundles ? Availability.new(offered: bundles, notes: {}) : availability
+      check!(settings, bundles: available.offered, notes: available.notes, flag: "bundle_settings")
+    end
+
+    # Each installed bundle's offered keys, by name (Availability#offered).
+    # @return [Hash{String => Array<String>}]
+    def offered(dir: nil) = availability(dir: dir).offered
+
+    # The installed bundles a session may set settings of: a record that
+    # doesn't read is left out, and so is one whose plugin doesn't load as
+    # chi's loader decides (Plugin::Loader#unloadable_reason: requires_chi,
+    # the file, its sha256), with a note saying why. A record with no
+    # session_settings whose shipped bundle lists some (installed before
+    # them) gets a note on refreshing it.
+    # @return [Availability]
+    def availability(dir: nil, shipped_dir: SHIPPED_DIR)
+      require_relative "memory_bundle/provenance"
+      require_relative "memory_bundle/manifest"
+      dir ||= MemoryBundle::Provenance.bundles_dir
+      offered = {}
+      notes = {}
+      MemoryBundle::Provenance.each_installed(dir: dir) do |name, bundle|
+        next if bundle.error?
+
+        if (reason = unloadable(dir, name, bundle))
+          notes[name] = "#{name} is installed but its plugin doesn't load: #{reason}"
+          next
+        end
+        offered[name] = bundle.session_settings
+        if bundle.session_settings.empty? && shipped_settings?(shipped_dir, name)
+          notes[name] = "(run `chi update` or `chi bundle upgrade #{name}` to refresh it)"
+        end
+      end
+      Availability.new(offered: offered, notes: notes)
+    end
+
+    # A session file's value, read tolerantly: the bundles that map to
+    # settings, the scalar ones of those, string keys, frozen; {} for
+    # anything else.
+    # @return [Hash{String => Hash{String => Object}}]
+    def normalize(raw)
+      return {}.freeze unless raw.is_a?(Hash)
+
+      deep_freeze(raw.each_with_object({}) do |(bundle, values), acc|
+        next unless values.is_a?(Hash)
+
+        kept = values.each_with_object({}) do |(key, value), scalars|
+          scalars[key.to_s] = value if SCALARS.any? { |kind| value.is_a?(kind) }
+        end
+        acc[bundle.to_s] = kept unless kept.empty?
+      end)
+    end
+
+    # Why +bundle+'s plugin doesn't load (as Plugin::Loader checks it), nil
+    # when it does or has none.
+    def unloadable(dir, name, bundle)
+      return nil unless bundle.plugin
+
+      failure = MemoryBundle::Manifest.requires_chi_failure(bundle.requires_chi, Samagotchi::VERSION)
+      return failure if failure
+
+      file = File.join(dir, name, "plugin", bundle.plugin.file.to_s)
+      return "the file is missing" unless File.file?(file)
+
+      expected = MemoryBundle::Provenance.recorded_sha(bundle.plugin.sha256)
+      return "no sha256 recorded for it (reinstall the bundle)" if expected.empty?
+
+      actual = MemoryBundle::Provenance.file_sha(file)
+      "its sha256 differs from the installed one (edited after install? reinstall the bundle)" unless actual == expected
+    end
+
+    # Whether chi ships a bundle +name+ whose manifest lists session_settings.
+    def shipped_settings?(shipped_dir, name)
+      path = File.join(shipped_dir, name, "manifest.yml")
+      return false unless File.file?(path)
+
+      raw = YAML.safe_load_file(path)
+      raw.is_a?(Hash) && raw["session_settings"].is_a?(Array) && !raw["session_settings"].empty?
+    rescue StandardError
+      false
+    end
+
+    def scalar_map?(values)
+      values.is_a?(Hash) && values.values.all? { |value| SCALARS.any? { |kind| value.is_a?(kind) } }
+    end
+
+    def takers(bundles)
+      names = bundles.reject { |_, keys| keys.empty? }.keys.sort
+      names.empty? ? "no installed bundle takes --set" : "bundles that take --set: #{names.join(", ")}"
+    end
+
+    def deep_freeze(settings)
+      settings.to_h { |bundle, values| [bundle.dup.freeze, values.to_h { |k, v| [k.dup.freeze, v.frozen? ? v : v.dup.freeze] }.freeze] }.freeze
+    end
+
+    private_class_method :unloadable, :shipped_settings?, :scalar_map?, :takers, :deep_freeze
+  end
+end

data/lib/samagotchi/bundles/core/manifest.yml

@@ -1,13 +1,15 @@
 ---
 name: core
-version: 0.3.1
+version: 0.3.2
 scope: system
 description: "Recommended safety set"
 trust_level: reviewed
-requires_chi: ">= 0.60.0"
+# Its members' highest floor (cost-cap's)
+requires_chi: ">= 0.83.0"
 includes:
 - loop-guard
 - check-in
 - guardrails
 - slow-commands
 - agents-md
+- cost-cap

data/lib/samagotchi/bundles/cost-cap/manifest.yml

@@ -0,0 +1,13 @@
+---
+name: cost-cap
+version: 0.1.1
+scope: system
+description: "A per-session $ cap: at the cap the turn pauses on Continue (another cap's worth) / Stop, a warning at 80% goes to the user only; /cap shows or sets it"
+trust_level: reviewed
+plugin:
+  file: plugin.rb
+  sha256: sha256:2ea7f76af1ea1c1b0a9a8b0b4b11d6e85a4a816fae224ef5b220cfd20fb48f42
+# ctx.cost is new in chi 0.83.0
+requires_chi: ">= 0.83.0"
+# chi --set cost-cap.cap=3: a session's own cap (ctx.settings["cap"])
+session_settings: [cap]

data/lib/samagotchi/bundles/cost-cap/plugin.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+# The cost-cap bundle (docs/plugins.md, The cost-cap bundle): a per-session
+# cap on what the session spends (ctx.cost: reported + estimated, side
+# requests included). Before each generation it compares the spend with
+# the cap: at warn_at of it the user (only) gets one notice, at the cap the
+# turn pauses on a question, Continue (the cap goes up by a step) or Stop
+# (the turn stops, with a card). With no one to ask it stops. The model
+# never sees any of it: no tool, no steer, no prompt text.
+#
+# Settings (config.yml, bundles: cost-cap:), read at each use from
+# ctx.settings, never at load:
+#   cap: 3.00       this session's own cap, set with chi --set cost-cap.cap=3
+#                   (session_settings: in the manifest); 0/off: none
+#   default: 5.00   USD cap for a session with none set; absent/0/off: none
+#   child: 2.00     for delegate children (ctx.delegate?); absent: default
+#   warn_at: 0.8    the share of the cap that warns; 0/off: no warning
+#
+# State: <data_dir>/sessions/<session id>.json, {"cap": 3.0, "step": 3.0},
+# written by /cap and by Continue; "cap": null (or false) is off for the
+# session, over the config. Without a file the cap comes from the settings:
+# cap:, else child: for a delegate, else default:.
+# The cap is resolved once per session id (ctx.delegate? parses the session
+# file) and kept until /cap or Continue writes a new one.
+require "json"
+require "fileutils"
+
+class Plugin
+  USAGE = "usage: /cap [N | $N | off] (USD; /cap alone shows the spend)"
+  OPTIONS = %w[Continue Stop].freeze
+  WARN_AT = 0.8
+
+  def initialize(_settings)
+    @mutex = Mutex.new
+    @resolved = nil        # {session:, cap:, step:}
+    @warned = nil          # [session id, cap] the share warning was given for
+    @unknown_warned = nil  # the session id the "can't be enforced" notice was given for
+  end
+
+  def register(chi)
+    chi.on(:before_generation) { |_event, ctx| check(ctx) }
+    # Only the "can't be enforced" notice: a turn of one generation (or a
+    # session's last) has no next before_generation to give it.
+    chi.on(:after_generation) { |_event, ctx| check_known(ctx) }
+    chi.command("/cap", "see or set this session's cost cap: /cap, /cap 5, /cap off", anytime: true) do |args, ctx|
+      command(args, ctx)
+    end
+  end
+
+  # The cap in USD (a positive Float) or nil (none, 0, off, false).
+  def self.amount(value)
+    number = case value
+             when Numeric then value.to_f
+             when String then value.strip.delete_prefix("$").then { |s| s.match?(/\A\d+(\.\d+)?\z/) ? s.to_f : nil }
+             end
+    number&.positive? ? number : nil
+  end
+
+  # Cents, or up to four decimals under $0.10, so a small cap (/cap 0.003)
+  # doesn't read "$0.00 spent of $0.00".
+  def self.money(value)
+    return format("$%.2f", value) if value.zero? || value.abs >= 0.1
+
+    format("$%.4f", value).sub(/(\.\d\d\d*?)0+\z/, '\1')
+  end
+
+  private
+
+  def check(ctx)
+    resolved = resolve(ctx)
+    cap = resolved[:cap]
+    return unless cap
+
+    cost = ctx.cost
+    return unenforceable(ctx, resolved[:session], cap) unless cost.known?
+
+    total = cost.total
+    return at_cap(ctx, resolved, cost) if total >= cap
+
+    share = warn_share(ctx)
+    return unless share && total >= share * cap
+    return unless first_time?(:@warned, [resolved[:session], cap])
+
+    ctx.notify("#{money(total)} of #{money(cap)} spent (#{(total / cap * 100).floor}%)", level: :warn)
+  end
+
+  def check_known(ctx)
+    resolved = resolve(ctx)
+    return unless resolved[:cap]
+
+    unenforceable(ctx, resolved[:session], resolved[:cap]) unless ctx.cost.known?
+  end
+
+  def unenforceable(ctx, session, cap)
+    return unless first_time?(:@unknown_warned, session)
+
+    ctx.notify("the #{money(cap)} cap can't be enforced: #{ctx.model || "the model"} reports no cost and has no price",
+               level: :warn)
+  end
+
+  def at_cap(ctx, resolved, cost)
+    cap = resolved[:cap]
+    raised = raised_cap(cap, resolved[:step] || cap, cost.total)
+    answer = ctx.ask_user(question: "Cost cap reached: #{money(cost.total)} spent of #{money(cap)}. " \
+                                    "Continue raises it to #{money(raised)}.",
+                          header: "Cost cap", options: OPTIONS)
+    if continue?(answer)
+      save(ctx, resolved[:session], "cap" => raised, "step" => resolved[:step] || cap)
+      ctx.notify("cap raised to #{money(raised)}")
+    else
+      stop(ctx, cap, cost)
+    end
+  end
+
+  # Another step on the cap, as many steps as it takes to pass the spend
+  # (a turn that overshot by more than a step asks once, not each step).
+  def raised_cap(cap, step, total)
+    raised = cap + step
+    raised += step while raised <= total
+    raised.round(6)
+  end
+
+  def continue?(answer)
+    return false unless answer
+
+    Array(answer[:selected]).first == "Continue" || Array(answer[:selected_indices]).first&.zero?
+  end
+
+  def stop(ctx, cap, cost)
+    return unless ctx.stop_turn("cost cap reached (#{money(cost.total)} of #{money(cap)})")
+
+    ctx.card(title: "cost-cap stopped the turn",
+             body: "Spent #{breakdown(cost)} of a #{money(cap)} cap.\n\n`/cap N` raises it, `/cap off` removes it.",
+             level: :warn)
+  end
+
+  def command(args, ctx)
+    arg = args.to_s.strip.downcase
+    return show(ctx) if arg.empty?
+
+    session = ctx.session_id
+    return "cost-cap: no session yet" unless session
+
+    if %w[off 0].include?(arg)
+      save(ctx, session, "cap" => nil)
+      return "cost-cap: no cap for this session"
+    end
+    value = arg.match?(/\A\$?\d+(\.\d+)?\z/) ? self.class.amount(arg) : nil
+    return USAGE unless value
+
+    save(ctx, session, "cap" => value, "step" => value)
+    "cost-cap: cap set to #{money(value)} (#{money(ctx.cost.total)} spent)"
+  rescue StandardError => e
+    "cost-cap: #{e.message}"
+  end
+
+  def show(ctx)
+    cost = ctx.cost
+    cap = resolve(ctx)[:cap]
+    return "cost-cap: no cap (#{money(cost.total)} spent)" unless cap
+
+    line = "cost-cap: #{money(cost.total)} spent of #{money(cap)} (#{parts(cost)})"
+    cost.known? ? line : "#{line} (can't be enforced: no cost reported or priced)"
+  end
+
+  def parts(cost) = "reported #{money(cost.reported)}, estimated #{money(cost.estimated)}, side #{money(cost.side)}"
+
+  def breakdown(cost) = "#{money(cost.total)} (#{parts(cost)})"
+
+  # The session's cap and step now: the state file's, else the session's
+  # own cap: (--set), else child: for a delegate, else default:. Cached per
+  # session id.
+  def resolve(ctx)
+    session = ctx.session_id
+    cached = @mutex.synchronize { @resolved }
+    return cached if cached && cached[:session] == session
+
+    resolved = { session: session, **(state(ctx, session) || configured(ctx)) }
+    @mutex.synchronize { @resolved = resolved }
+  end
+
+  def state(ctx, session)
+    return nil unless session
+
+    saved = JSON.parse(File.read(state_path(ctx, session)))
+    return nil unless saved.is_a?(Hash) && saved.key?("cap")
+
+    cap = self.class.amount(saved["cap"])
+    { cap: cap, step: self.class.amount(saved["step"]) || cap }
+  rescue Errno::ENOENT, JSON::ParserError
+    nil
+  end
+
+  def configured(ctx)
+    settings = ctx.settings
+    return { cap: nil, step: nil } unless %w[cap default child].any? { |key| settings.key?(key) }
+
+    key = if settings.key?("cap") then "cap"
+          elsif settings.key?("child") && ctx.delegate? then "child"
+          else "default"
+          end
+    cap = self.class.amount(settings[key])
+    { cap: cap, step: cap }
+  end
+
+  def warn_share(ctx)
+    settings = ctx.settings
+    return WARN_AT unless settings.key?("warn_at")
+
+    share = settings["warn_at"]
+    share.is_a?(Numeric) && share.positive? ? share : nil
+  end
+
+  def save(ctx, session, data)
+    path = state_path(ctx, session)
+    FileUtils.mkdir_p(File.dirname(path))
+    Samagotchi::AtomicFile.write(path, "#{JSON.generate(data)}\n")
+    cap = self.class.amount(data["cap"])
+    @mutex.synchronize { @resolved = { session: session, cap: cap, step: self.class.amount(data["step"]) || cap } }
+  end
+
+  def state_path(ctx, session) = File.join(ctx.data_dir, "sessions", "#{session.gsub(/[^A-Za-z0-9_.-]/, "_")}.json")
+
+  def money(value) = self.class.money(value)
+
+  # Whether +key+ is new for the once-only notice kept in +ivar+ (and keep it).
+  def first_time?(ivar, key)
+    @mutex.synchronize do
+      next false if instance_variable_get(ivar) == key
+
+      instance_variable_set(ivar, key)
+      true
+    end
+  end
+end

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.82.0
+version: 0.84.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/child_reports.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "securerandom"
 require_relative "client_id"
 require_relative "session"
 require_relative "session_inbox"
@@ -129,7 +130,7 @@ module Samagotchi
     # (DelegateWait.finish, its report variant), the cursor it moves the child to,
     # and the cursor it was read from (a commit after the model moved it
     # itself, with delegate_result, leaves it alone).
-    Report = Data.define(:child_id, :text, :before, :after, :rings) do
+    Report = Data.define(:child_id, :text, :before, :after, :rings, :claim_id) do
       def line(mark: nil) = Steer::Line.new(text: text, source: ChildReports::SOURCE, mark: mark)
       def origin = { client_id: "#{ClientId::CHILD_PREFIX}#{child_id[0, 8]}" }
     end
@@ -142,6 +143,7 @@ module Samagotchi
       @state_dir = state_dir
       @session_dir = Session.session_dir(session_id, state_dir: state_dir)
       @predecessor_dir = Session.valid_id?(predecessor) ? Session.session_dir(predecessor, state_dir: state_dir) : nil
+      Tools::DelegateCursors.clear_report_claims(@session_id, state_dir: @state_dir)
       # child id → the Report this turn took for it (rings merged).
       @taken = {}
     end
@@ -177,12 +179,16 @@ module Samagotchi
     end
 
     # The turn that took the reports was kept: move each child's cursor on
-    # (unless something else moved it since: the model's own
-    # delegate_result), then delete the rings.
+    # and delete the rings.
     def commit
       @taken.each_value do |report|
         Tools::DelegateCursors.update(@session_id, report.child_id, state_dir: @state_dir) do |cursor|
-          cursor == report.before ? report.after : cursor
+          next cursor unless cursor.report_claim&.fetch("id", nil) == report.claim_id
+
+          before = report.before.with(report_claim: nil)
+          after = report.after.with(report_claim: nil)
+          current = cursor.with(report_claim: nil)
+          current == before ? after : current
         end
         delete_rings(report.rings)
       rescue StandardError => e
@@ -193,6 +199,11 @@ module Samagotchi
 
     # The turn was rolled back: its rings stay for the next one.
     def release
+      @taken.each_value do |report|
+        Tools::DelegateCursors.update(@session_id, report.child_id, state_dir: @state_dir) do |cursor|
+          cursor.report_claim&.fetch("id", nil) == report.claim_id ? cursor.with(report_claim: nil) : cursor
+        end
+      end
       @taken = {}
     end
 
@@ -237,13 +248,19 @@ module Samagotchi
                                       timeout: 0, turn: before.turn)
       return nil unless reportable?(wait)
 
-      # A reported end is the follow-up turn's too (DelegateCursor#turn):
-      # a later wait on it would repeat its reply.
+      claim_id = before.report_claim&.fetch("id", nil) || SecureRandom.hex(16)
       after = before.with(reply_file: wait.status == :done ? wait.file : before.reply_file,
-                          turn: wait.status == :waiting_for_answer ? before.turn : nil)
+                          turn: wait.status == :waiting_for_answer ? before.turn : nil, report_claim: nil)
                     .with_baseline(ReplyWait.baseline_of(wait.session))
+      claim = { "id" => claim_id, "file" => wait.file, "cursor" => after.to_json_hash }
+      return nil unless Tools::DelegateCursors.claim_report(@session_id, child_id, expected: before, claim: claim,
+                                                            state_dir: @state_dir)
+
+      # A reported end is the follow-up turn's too (DelegateCursor#turn):
+      # a later wait on it would repeat its reply.
+      after = after.with(report_claim: claim)
       text = Tools::DelegateWait.finish(wait, child_id, timeout: 0, report: true)
-      Report.new(child_id: child_id, text: text, before: before, after: after, rings: rings)
+      Report.new(child_id: child_id, text: text, before: before, after: after, rings: rings, claim_id: claim_id)
     rescue ArgumentError
       nil # the child is gone
     end

data/lib/samagotchi/engine.rb

@@ -2581,7 +2581,8 @@ module Samagotchi
         # build and after a rebuild that drops them (SystemPrompt#prompt_files
         # returns [] itself: the || keeps a nil builder safe).
         prompt_files: -> { @prompt_builder&.prompt_files || [] },
-        frontend: -> { interface }
+        frontend: -> { interface },
+        cost: -> { @metrics.cost }
       )
     end
 

data/lib/samagotchi/memory_bundle/builder.rb

@@ -202,7 +202,7 @@ module Samagotchi
         parts.scripts.each_value { |src| FileUtils.cp(src, File.join(staging, "scripts", File.basename(src))) }
       end
 
-      # manifest.yml for the staged bundle: requires_chi, needs and the
+      # manifest.yml for the staged bundle: requires_chi, needs, session_settings and the
       # file descriptions come from the installed bundle's record, the
       # trust_level from the CLI else the record.
       def write_manifest(staging, name, version, files_map, parts)
@@ -223,7 +223,8 @@ module Samagotchi
           needs: record&.needs,
           scripts: parts.scripts.transform_values { |src| "sha256:#{Digest::SHA256.hexdigest(File.binread(src))}" },
           context_providers: parts.context_providers,
-          file_descriptions: file_descriptions(record, files_map)
+          file_descriptions: file_descriptions(record, files_map),
+          session_settings: record&.session_settings || []
         )
       end
 

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -20,13 +20,15 @@ module Samagotchi
     #               the lists as recorded (nil when absent): Manifest.parse_needs
     #               and ContextProviders.parse_list check them
     #   includes    a profile's recorded members, nil for a plain bundle
+    #   session_settings
+    #               the keys a session may set (chi --set), [] when none
     #   error       why manifest.json couldn't be read (the rest empty), else nil
     class InstalledBundle < Data.define(:name, :version, :scope, :source, :installed_at, :trust_level, :source_commit,
                                         :requires_chi, :files, :hooks, :guardrails, :scripts, :plugin, :needs,
-                                        :includes, :context_providers, :error)
+                                        :includes, :context_providers, :session_settings, :error)
       OPTIONAL = { version: nil, scope: nil, source: nil, installed_at: nil, trust_level: nil, source_commit: nil,
                    requires_chi: nil, files: {}, hooks: {}, guardrails: {}, scripts: {}, plugin: nil, needs: nil,
-                   includes: nil, context_providers: nil, error: nil }.freeze
+                   includes: nil, context_providers: nil, session_settings: [], error: nil }.freeze
 
       def initialize(name:, **fields)
         super(name: name, **OPTIONAL, **fields)
@@ -57,7 +59,8 @@ module Samagotchi
             guardrails: mapping(h["guardrails"]) { |meta| sha(meta) },
             scripts: mapping(h["scripts"]) { |meta| sha(meta) },
             plugin: PluginRef.parse(h["plugin"]), needs: h["needs"], context_providers: h["context_providers"],
-            includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil)
+            includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil,
+            session_settings: h["session_settings"].is_a?(Array) ? h["session_settings"].map(&:to_s) : [])
       end
 
       def self.string(value) = value&.to_s

data/lib/samagotchi/memory_bundle/installer.rb

@@ -420,7 +420,8 @@ module Samagotchi
           conflicts: @conflicts.keys,
           scripts_files: installed.script_files,
           context_providers: @manifest.context_providers,
-          file_descriptions: @manifest.file_descriptions
+          file_descriptions: @manifest.file_descriptions,
+          session_settings: @manifest.session_settings
         )
       end