samagotchi 0.143.0 → 0.145.0

data/lib/samagotchi/bundles/github-pr/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: github-pr
-version: 0.6.1
+version: 0.6.2
 scope: system
 description: Proposes the branch's open GitHub pull request to a session, attached once you mention it (#N, the branch or its URL), and attaches any PR URL with chi context add or the web's "+ URL"; the agent gets a note when reviews, comments, checks or its state change; in the web, a path:line in an answer links to that line of the PR; the auto_attach setting can attach the PR at once instead, or do nothing
 trust_level: reviewed
@@ -11,7 +11,7 @@ needs:
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:558bd4191f28b7c54d4521f55e8514a63568d5e2df5a4937856821fd88de508f
+  sha256: sha256:114e999c49d4d427b7570e3f4bec8db5565ee0dd1a99f2f5ec3000748a1aec3a
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers:

data/lib/samagotchi/bundles/github-pr/plugin.rb

@@ -501,8 +501,10 @@ class LineLinker
   QUICK = /\S:\d/
   URL_SPAN = %r{[a-z][a-z0-9+.-]*://\S+}i
   MARKDOWN_LINK = /\[[^\]]*\]\([^)]*\)/
-  # A fenced code block's opening line (up to 3 spaces, then ``` or ~~~).
-  FENCE_OPEN = /\A {0,3}(`{3,}|~{3,})/
+  # A fenced code block's opening line (up to 3 spaces, then ``` or ~~~). A
+  # backtick fence's info string carries no backtick: "```foo``` first" is
+  # inline code, and as a fence it would stay open over the rest of the text.
+  FENCE_OPEN = /\A {0,3}(`{3,}(?![^\n]*`)|~{3,})/
 
   # The content of the last model message, or nil (string or symbol keys).
   def self.last_model_text(messages)

data/lib/samagotchi/bundles/source-links/hooks/source_links.rb

@@ -86,8 +86,10 @@ class SourceLinks
   URL_SPAN = %r{[a-z][a-z0-9+.-]*://\S+}i
   TRAILING_URL_PUNCTUATION = /[.,;:!?'"]+\z/
   MARKDOWN_LINK = /\[([^\]]*)\]\(([^)]*)\)/
-  # A fenced code block's opening line (up to 3 spaces, then ``` or ~~~).
-  FENCE_OPEN = /\A {0,3}(`{3,}|~{3,})/
+  # A fenced code block's opening line (up to 3 spaces, then ``` or ~~~). A
+  # backtick fence's info string carries no backtick: "```foo``` first" is
+  # inline code, and as a fence it would stay open over the rest of the text.
+  FENCE_OPEN = /\A {0,3}(`{3,}(?![^\n]*`)|~{3,})/
   # A `{word}` or `{N}` placeholder in a `url:` template.
   PLACEHOLDER = /\{(\w+)\}/
   # Placeholders every pattern has: {match} (group 1, else the whole ref),

data/lib/samagotchi/bundles/source-links/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: source-links
-version: 0.6.1
+version: 0.6.2
 scope: system
 description: Links source refs (JIRA tickets, GitHub issues, …) in the model's answer — inline links in the web, refs in a waiting question's reply, and a one-line note after the turn (note false turns it off); sources are configured patterns
 trust_level: reviewed
@@ -9,7 +9,7 @@ files:
   source_links.md: sha256:ace01a0f7c308a0ae54ece714c31c0e6d7a49c372d98111030e6d268320bed3a
 hooks:
   source_links.rb:
-    sha256: sha256:84c0bef064fb1ea76749a61e758eba612662aaf0f05f18a18ab4228497078fa2
+    sha256: sha256:7e3fafb843f1a9006b1a42f4ec647b41a358d814515cd0be73b60eb08b898992
     events: [after_turn, question_asked]
     on_error: log
     priority: 90

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

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

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

@@ -1,15 +1,15 @@
 ---
 name: work-cap
-version: 0.1.4
+version: 0.1.5
 scope: system
 description: "A per-session work cap (tool calls, active minutes) across turns: at a cap the turn pauses on Continue (another cap's worth) / Stop with the session's totals, a warning at 80% goes to the user only; /workcap shows or sets it"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:d2c61b0aa26775c7b9783681fec4e5759766ad01e92f78ed88743a52ff5a1495
+  sha256: sha256:31cf59a518a7fe3f51efc72f3bb213a0f053d6577aa81a7f47eaac12c5caa07a
 # ask_user's effects: are in chi 0.92.0; ctx.usage is new in the next chi
-# ctx.session_dir is new in the next chi
-requires_chi: ">= 0.143.0"
+# ctx.session_dir is new in 0.143.0
+requires_chi: ">= 0.144.0"
 # chi --set work-cap.tool_calls=400 / work-cap.minutes=60: the session's own caps, a number or off
 session_settings: {tool_calls: number, minutes: number}
 # config.yml bundles: work-cap: (another key warns; an older chi ignores this)

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

@@ -142,7 +142,7 @@ class Plugin
       cap = meter_cap[:cap]
       next unless used[meter] >= share * cap && first_warning?(meter, [resolved[:session], cap])
 
-      ctx.notify("#{count(used[meter])} of #{count(cap)} #{unit(meter)} (#{(used[meter] / cap * 100).floor}%)",
+      ctx.notify("#{count(used[meter])} of #{counted(cap, meter)} (#{(used[meter] / cap * 100).floor}%)",
                  level: :warn)
     end
   end
@@ -196,7 +196,7 @@ class Plugin
         save_meter(ctx, meter, "cap" => cap, "step" => reached[meter][:step] || reached[meter][:cap])
       end
       ctx.notify("#{raised.size == 1 ? "cap" : "caps"} raised to " \
-                 "#{raised.map { |meter, cap| "#{count(cap)} #{unit(meter)}" }.join(" and ")}")
+                 "#{raised.map { |meter, cap| counted(cap, meter) }.join(" and ")}")
     else
       stop(ctx, reached, usage, used)
     end
@@ -204,21 +204,21 @@ class Plugin
 
   # "412 tool calls of 400", and "61 active minutes of 60" for the other.
   def reached_text(reached, used)
-    reached.map { |meter, meter_cap| "#{count(used[meter])} #{unit(meter)} of #{count(meter_cap[:cap])}" }.join(", ")
+    reached.map { |meter, meter_cap| "#{counted(used[meter], meter)} of #{count(meter_cap[:cap])}" }.join(", ")
   end
 
   # "it to 800", or "them to 800 tool calls and 120 active minutes".
   def raised_text(raised)
     return "it to #{count(raised.values.first)}" if raised.size == 1
 
-    "them to #{raised.map { |meter, cap| "#{count(cap)} #{unit(meter)}" }.join(" and ")}"
+    "them to #{raised.map { |meter, cap| counted(cap, meter) }.join(" and ")}"
   end
 
   # The session's totals a reader decides on, the reached meters left out
   # (already named): turns, tool calls, active minutes and the spend.
   def totals(ctx, usage, used, skip = [])
     parts = ["#{usage.turns} #{usage.turns == 1 ? "turn" : "turns"}"]
-    parts << "#{count(used["tool_calls"])} tool calls" unless skip.include?("tool_calls")
+    parts << counted(used["tool_calls"], "tool_calls") unless skip.include?("tool_calls")
     parts << "#{active_text(used["minutes"])} active" unless skip.include?("minutes")
     cost = ctx.cost
     parts << format("$%.2f", cost.total) if cost.known? && cost.total.positive?
@@ -268,7 +268,7 @@ class Plugin
     return USAGE unless value
 
     save_meter(ctx, meter, "cap" => value, "step" => value)
-    "work-cap: #{unit(meter)} cap set to #{count(value)} (#{count(used(ctx, ctx.usage)[meter])} so far)"
+    "work-cap: cap set to #{counted(value, meter)} (#{count(used(ctx, ctx.usage)[meter])} so far)"
   rescue StandardError => e
     ctx.log.warn(:workcap_command_failed, error: "#{e.class}: #{e.message}")
     "work-cap: #{e.message}"
@@ -281,12 +281,18 @@ class Plugin
     return "work-cap: no cap (#{totals(ctx, usage, used)})" if meters.values.none? { |meter_cap| meter_cap[:cap] }
 
     capped = meters.select { |_meter, meter_cap| meter_cap[:cap] }
-    caps = capped.map { |meter, meter_cap| "#{count(used[meter])} of #{count(meter_cap[:cap])} #{unit(meter)}" }
+    caps = capped.map { |meter, meter_cap| "#{count(used[meter])} of #{counted(meter_cap[:cap], meter)}" }
     "work-cap: #{caps.join(", ")} (#{totals(ctx, usage, used, capped.keys)})"
   end
 
   def unit(meter) = meter == "tool_calls" ? "tool calls" : "active minutes"
 
+  # "412 tool calls", "1 tool call".
+  def counted(value, meter)
+    number = count(value)
+    "#{number} #{number == "1" ? unit(meter).chomp("s") : unit(meter)}"
+  end
+
   # The session's caps now: per meter the state file's, else the session's
   # own value (--set), else child:'s for a delegate, else default:'s.
   # Cached per session id and settings (a config change resolves again).
@@ -310,7 +316,7 @@ class Plugin
   def state(ctx, session)
     return [{}, nil] unless session
 
-    path = state_file(ctx)
+    path = saved_file(ctx)
     saved = JSON.parse(File.read(path))
     raise JSON::ParserError, "not a JSON object" unless saved.is_a?(Hash)
 
@@ -412,6 +418,9 @@ class Plugin
 
   def state_file(ctx) = File.join(ctx.session_dir, "state.json")
 
+  # For a read: a session with nothing saved keeps no folder.
+  def saved_file(ctx) = File.join(ctx.session_dir(create: false), "state.json")
+
   def count(value) = self.class.count(value)
 
   def first_warning?(meter, key)

data/lib/samagotchi/context_status.rb

@@ -299,7 +299,7 @@ module Samagotchi
 
     def bucket_rank(bucket) = self.class.bucket_rank(bucket, @thresholds)
 
-    # A rise (never a fall or a cadence tick) into a bucket whose guidance
+    # A rise (never a fall) into a bucket whose guidance
     # asks for a change. With no previous bucket (a first turn, a resumed
     # session with no line yet), the first bucket counts as a rise from 0.
     def guidance_due?(previous, bucket)

data/lib/samagotchi/engine.rb

@@ -1288,11 +1288,21 @@ module Samagotchi
     # Hooks are turn-scoped: they are automatically cleared after each
     # `run_turn` call so that a single turn's hooks do not leak into the next.
     #
+    # A hook that raises tells the user once, as a bundle's does
+    # (HookRoutes#plugin_hook_failed); the registry logs each failure and goes on.
+    #
     # @param name [Symbol] one of the hook names (see Hooks module)
     # @param block [Proc] receives an event hash (may mutate in place)
     # @return [void]
-    def register_hook(name, &)
-      @hooks.register(name, &)
+    def register_hook(name, &block)
+      return @hooks.register(name) unless block
+
+      @hooks.register(name) do |event|
+        yield(event)
+      rescue StandardError => e
+        @hook_routes.plugin_hook_failed("#{Hooks::Registry::TURN_HOOK_LABEL} (#{name})", "#{e.class}: #{e.message}")
+        raise
+      end
     end
 
     # Unregister a previously registered hook.
@@ -2945,12 +2955,12 @@ module Samagotchi
     end
 
     # config.yml bundles: names and keys that do nothing (BundleSettingsCheck),
-    # held like the judgments' line, for the same reason.
+    # held like the judgments' line, for the same reason. Logged by every
+    # Engine; shown by the first to find them (BundleSettingsCheck.unshown).
     def warn_bundle_settings
-      BundleSettingsCheck.warnings(@extension_load.bundle_settings).each do |line|
-        Log.warn(:config, "bundle_setting_unknown", msg: line)
-        hook_notify(line, :warn, "config")
-      end
+      lines = BundleSettingsCheck.warnings(@extension_load.bundle_settings)
+      lines.each { |line| Log.warn(:config, "bundle_setting_unknown", msg: line) }
+      BundleSettingsCheck.unshown(lines).each { |line| hook_notify(line, :warn, "config") }
     end
     private :warn_bundle_settings
 

data/lib/samagotchi/kernel_loop.rb

@@ -734,6 +734,13 @@ module Samagotchi
       response = request.prefill + generation.response.to_s
       answer = -> { PromptLiteralGuard.restore(strip_thought_blocks(response), profile: @profile) }
       empty = strip_thought_blocks(response.to_s).strip.empty?
+      # A Stop that lands on an empty reply is no empty answer: the empty
+      # generation goes, as it does below, and the turn ends cancelled.
+      if empty && turn.cancel_controller&.cancelled?
+        turn.empty_steps << turn.conversation.pop
+        raise Client::RequestCancelled, turn.cancel_controller.reason
+      end
+
       retry_empty = empty && turn.empty_retry.retry_empty?(iteration: turn.iteration,
                                                            cancelled: turn.cancel_controller&.cancelled?,
                                                            finish_reason: generation.finish_reason,

data/lib/samagotchi/live_versions.rb

@@ -1,21 +1,29 @@
 # frozen_string_literal: true
 
+require_relative "config"
 require_relative "session"
 require_relative "version"
 require_relative "worker_link"
 require_relative "web/info_probe"
+require_relative "web/running"
 
 module Samagotchi
   # Which chi versions the running processes run, for `chi update`: session
   # workers (their bridge.json sidecar names the version since chi update exists; an
-  # older one names none) and a `chi web` on its port (/api/info). Read-only:
-  # a dead worker's sidecar is left for the next client to clean up.
+  # older one names none) and a `chi web` on its port (/api/info): also
+  # chi self's and chi share's lookup of that chi web. Read-only: a dead
+  # worker's sidecar is left for the next client to clean up.
   module LiveVersions
     WEB_TIMEOUT = 0.5
+    # chi web's port when config names none: Web::Server::DEFAULT_PORT,
+    # without loading chi web.
+    DEFAULT_WEB_PORT = 4567
 
     # version is nil for a sidecar written before sidecars carried one;
     # restart: the worker takes `chi sessions restart` (its "restart" feature).
     Worker = Struct.new(:session_id, :version, :restart, keyword_init: true)
+    # The port a chi web answers on and its /api/info.
+    WebAnswer = Data.define(:port, :info)
 
     module_function
 
@@ -41,5 +49,23 @@ module Samagotchi
       info = Web::InfoProbe.call(host, port, timeout: timeout)
       info.is_a?(Hash) ? info : nil
     end
+
+    # Config's web.port, or the default for none that is a port.
+    def configured_web_port
+      port = Config.get("web.port").to_s.to_i
+      port.positive? ? port : DEFAULT_WEB_PORT
+    end
+
+    # The chi web on this machine: on the port the running one recorded (a
+    # --port it was started with is not config's), else on +configured+.
+    # @param path [String] its record (Web::Running.path)
+    # @return [WebAnswer, nil] nil with none
+    def web_answering(host, configured, path:, timeout: WEB_TIMEOUT)
+      [Web::Running.port(path: path), configured].compact.uniq.each do |port|
+        info = web_info(host, port, timeout: timeout)
+        return WebAnswer.new(port: port, info: info) if info
+      end
+      nil
+    end
   end
 end

data/lib/samagotchi/llm/chat_loop.rb

@@ -677,6 +677,11 @@ module Samagotchi
                                                     "could not read, twice in a row; nothing was run", host: host)
                 end
               end
+              # A Stop that lands on an empty reply is no empty answer either:
+              # nothing more is asked because the turn is stopping. (A refusal
+              # the Stop landed on stays what the provider said.)
+              return canceled(iteration, @cancel_controller.reason) if empty && !stopped && @cancel_controller&.cancelled?
+
               # Kept before a merge too: the model answers the merged line
               # knowing what it just said.
               @conversation << with_thinking({ role: "model", content: last_text }, response) unless empty || stray

data/lib/samagotchi/llm/utf8_scrub.rb

@@ -8,8 +8,9 @@ module Samagotchi
     # `JSON#to_json` raises `JSON::GeneratorError` on such input, which would
     # abort the whole turn, so a request body is scrubbed first: only
     # offending bytes are replaced with "?", every valid UTF-8 string passes
-    # through untouched. Non-UTF-8 encodings are left alone because
-    # `#to_json` already handles them without raising.
+    # through untouched. A binary string is read as UTF-8 first (JSON raises
+    # on its high bytes too); other encodings are left alone because
+    # `#to_json` converts them without raising.
     module Utf8Scrub
       module_function
 
@@ -18,7 +19,8 @@ module Samagotchi
       def call(obj)
         case obj
         when String
-          obj.encoding == Encoding::UTF_8 && !obj.valid_encoding? ? obj.scrub("?") : obj
+          text = obj.encoding == Encoding::BINARY ? obj.dup.force_encoding(Encoding::UTF_8) : obj
+          text.encoding == Encoding::UTF_8 && !text.valid_encoding? ? text.scrub("?") : text
         when Array
           obj.map { |element| call(element) }
         when Hash

data/lib/samagotchi/plugin/api.rb

@@ -54,8 +54,8 @@ module Samagotchi
         "ctx.context.decline" => "0.43.0", "ctx.context.declined(url:)" => "0.43.0", "ctx.context.attach(force:)" => "0.43.0",
         "ctx.ask_user(effects:)" => "0.86.0", "chi.toolkit(description:)" => "0.122.0", "ctx.review" => "0.140.0",
         "ctx.context.propose" => "0.140.0", "ctx.context.candidates" => "0.140.0", "ctx.context.withdraw" => "0.140.0",
-        "ctx.continues" => "0.141.0", "ctx.context.left_behind" => "0.141.0", "ctx.context.attach(movable:)" => "0.141.0"
-        # Unreleased (moved up, with its version, at the release: docs/releasing.md): "ctx.session_dir".
+        "ctx.continues" => "0.141.0", "ctx.context.left_behind" => "0.141.0", "ctx.context.attach(movable:)" => "0.141.0",
+        "ctx.session_dir" => "0.143.0", "ctx.session_dir(create:)" => "0.144.0"
       }.freeze
 
       # @param bundle [String]

data/lib/samagotchi/plugin/context.rb

@@ -304,10 +304,11 @@ module Samagotchi
       # This session's own folder under #data_dir, created on use and read
       # now (a continue moves the id on). chi removes it with the session:
       # the layout is core's (PluginSessionState).
+      # @param create [Boolean] false for a read: the path, with no folder made
       # @return [String, nil] nil with no session yet
-      def session_dir
+      def session_dir(create: true)
         id = session_id
-        id && PluginSessionState.dir(data_dir, id)
+        id && PluginSessionState.dir(data_dir, id, create: create)
       end
 
       # The conversation so far, a frozen copy, without the system prompt.

data/lib/samagotchi/plugin/peer.rb

@@ -313,7 +313,7 @@ module Samagotchi
       end
 
       def last_send(ctx)
-        path = File.join(ctx.session_dir, LAST_SEND)
+        path = File.join(ctx.session_dir(create: false), LAST_SEND)
         File.file?(path) ? JSON.parse(File.read(path)) : nil
       rescue JSON::ParserError, SystemCallError
         nil

data/lib/samagotchi/plugin_session_state.rb

@@ -21,15 +21,18 @@ module Samagotchi
     # A session's folder under a bundle's +data_dir+, created. A
     # sessions/<id>.json there moves in as STATE_FILE, so a running session
     # keeps it when its bundle moves to ctx.session_dir.
+    # @param create [Boolean] false for a read: only names the folder, so a
+    #   session with nothing saved leaves none (the older file still moves in)
     # @return [String, nil] nil for an id that isn't a plain one (it could
     #   name a path outside the dir)
-    def dir(data_dir, session_id)
+    def dir(data_dir, session_id, create: true)
       id = session_id.to_s
       return nil unless Session.valid_id?(id)
 
       path = File.join(data_dir, "sessions", id)
-      FileUtils.mkdir_p(path)
-      adopt("#{path}.json", File.join(path, STATE_FILE))
+      older = "#{path}.json"
+      FileUtils.mkdir_p(path) if create || File.file?(older)
+      adopt(older, File.join(path, STATE_FILE))
       path
     end
 

data/lib/samagotchi/self_report.rb

@@ -25,6 +25,7 @@ require_relative "memory_bundle/entry_size"
 require_relative "desktop"
 require_relative "live_versions"
 require_relative "web/lan"
+require_relative "web/running"
 require_relative "chi_home"
 require_relative "home_notice"
 require_relative "project_env"
@@ -33,8 +34,8 @@ module Samagotchi
   # `chi self`: where this chi lives and what it is configured to use.
   #
   # Read-only and nearly offline (one short /props GET for the served model,
-  # nothing else asks a model server; one /api/info GET on this machine's
-  # chi web port), so the agent can run it via `execute`
+  # nothing else asks a model server; /api/info GETs for this machine's
+  # chi web), so the agent can run it via `execute`
   # to orient itself — source dir to rg, config path, memory dirs, sessions,
   # model/host, bundle versions — without guessing from $PATH.
   module SelfReport
@@ -77,22 +78,23 @@ module Samagotchi
         ["context window", context_window(env, model)],
         ["bundles", bundles_summary],
         ["desktop", desktop_summary(env)],
-        ["chi web", web_summary]
+        ["chi web", web_summary(env)]
       ]
     end
 
     WEB_TIMEOUT = 0.3
 
-    # Whether a chi web answers on this machine's web port, and whether a
-    # phone can reach it (LAN mode: /api/info's lan).
-    def web_summary
-      port = Config.get("web.port").to_i
-      port = 4567 unless port.positive?
-      info = LiveVersions.web_info(Web::Lan.local_host(Config.get("web.host")), port, timeout: WEB_TIMEOUT)
-      return "not running on port #{port}" unless info
-      return "LAN on #{info["lan"]}:#{port} (and 127.0.0.1)" if info["lan"]
-
-      "on 127.0.0.1:#{port} (this machine only)"
+    # Whether a chi web answers on this machine (LiveVersions.web_answering:
+    # the port it recorded, else config's), and whether a phone can reach it
+    # (LAN mode: /api/info's lan).
+    def web_summary(env = ENV)
+      configured = LiveVersions.configured_web_port
+      answer = LiveVersions.web_answering(Web::Lan.local_host(Config.get("web.host")), configured,
+                                          path: Web::Running.path(env: env), timeout: WEB_TIMEOUT)
+      return "not running on port #{configured}" unless answer
+      return "LAN on #{answer.info["lan"]}:#{answer.port} (and 127.0.0.1)" if answer.info["lan"]
+
+      "on 127.0.0.1:#{answer.port} (this machine only)"
     end
 
     # "git checkout" when running from a repo (bin/chi), "installed gem" when

data/lib/samagotchi/session_access/local.rb

@@ -22,6 +22,7 @@ require_relative "../review_start"
 require_relative "../launch_mode"
 require_relative "../participants"
 require_relative "../config"
+require_relative "../live_versions"
 require_relative "../web/grants"
 require_relative "../web/info_probe"
 require_relative "../web/public_url"
@@ -453,8 +454,6 @@ module Samagotchi
 
       def grants = @grants ||= Web::Grants.new(Web::Grants.path(state_dir: state_dir!))
 
-      # Web::Server::DEFAULT_PORT, without loading chi web.
-      WEB_PORT = 4567
       LOCAL_PROBE_TIMEOUT = 1.0
 
       # Where this machine's chi web answers (GET /api/info): its LAN ip
@@ -491,14 +490,12 @@ module Samagotchi
       end
 
       def local_web
-        configured = Config.get("web.port").to_s.to_i
-        configured = WEB_PORT unless configured.positive?
-        recorded = Web::Running.port(path: Web::Running.path(state_dir: state_dir!))
-        [recorded, configured].compact.uniq.each do |port|
-          info = Web::InfoProbe.call("127.0.0.1", port, timeout: LOCAL_PROBE_TIMEOUT)
-          return LocalWeb.new(ip: own_address(info["lan"]), port: port) if info.is_a?(Hash)
-        end
-        LocalWeb.new(ip: nil, port: configured)
+        configured = LiveVersions.configured_web_port
+        answer = LiveVersions.web_answering("127.0.0.1", configured, path: Web::Running.path(state_dir: state_dir!),
+                                                                     timeout: LOCAL_PROBE_TIMEOUT)
+        return LocalWeb.new(ip: nil, port: configured) unless answer
+
+        LocalWeb.new(ip: own_address(answer.info["lan"]), port: answer.port)
       end
 
       def dir = @state_dir ? { state_dir: @state_dir } : {}

data/lib/samagotchi/session_commands.rb

@@ -512,7 +512,8 @@ module Samagotchi
       mode = Config.get("guardrails.system_one.mode").to_s
       return if mode == "off" && entries.empty?
 
-      lines << "System 1 (#{mode}):"
+      no_judgment = SystemOne::Client.no_judgment_reason(host_registry: @engine.host_registry, mode: mode)
+      lines << (no_judgment ? "System 1 (#{mode}, but nothing is judged: #{no_judgment}):" : "System 1 (#{mode}):")
       auto_allows = system_one_auto_allows(entries)
       lines << "  auto-allows (this session, newest first; /guardrails wrong N):"
       if auto_allows.empty?

data/lib/samagotchi/system_one/answer.rb

@@ -20,7 +20,9 @@ module Samagotchi
       # not usable: no type, a type the contract doesn't have, a noul outside
       # 0..1, a score that isn't a number or past the last level, … A nil means
       # "no judgment for this question", never a guess.
-      def self.from_wire(id, raw)
+      # @param levels [Integer, nil] how many levels the question declared: a
+      #   bare score, with no legend or probabilities, is checked against it
+      def self.from_wire(id, raw, levels: nil)
         return nil unless raw.is_a?(Hash)
 
         type = raw["type"].to_s.strip.downcase.to_sym
@@ -46,7 +48,7 @@ module Samagotchi
           legend = levels(raw["legend"])
           return nil if bad_field(raw, "legend", legend)
 
-          score = level_score(raw["score"], legend, odds)
+          score = level_score(raw["score"], legend, odds, levels)
           score.nil? ? nil : new(**answer, score: score, level: top_level(legend, odds))
         end
       end
@@ -100,14 +102,15 @@ module Samagotchi
       end
 
       # The score as sent: the weighted level index, a whole number kept whole.
-      # Not a number, or past the last level the response names, is no answer.
-      private_class_method def self.level_score(value, legend, odds)
+      # Not a number, or past the last level the response names (or else the
+      # question declared), is no answer.
+      private_class_method def self.level_score(value, legend, odds, levels)
         return nil unless value.is_a?(Numeric)
 
         score = value.to_f
         return nil if score.nan? || score.infinite? || score.negative?
 
-        count = legend&.size || (odds.is_a?(Array) ? odds.size : odds&.size)
+        count = legend&.size || (odds.is_a?(Array) ? odds.size : odds&.size) || levels
         # A hair past the last level is the probabilities' own rounding, not a
         # level out of range.
         return nil if count && score > count - 1 + 1e-9

data/lib/samagotchi/system_one/client.rb

@@ -60,6 +60,23 @@ module Samagotchi
             mode: mode, host: host, model: model.empty? ? nil : model, tag: tag)
       end
 
+      # Why an ask under +mode+ would get no judgment whatever the host does,
+      # from the settings alone (no request); nil when one would be asked for,
+      # and under off, which promises none (`/guardrails`).
+      # @return [String, nil]
+      def self.no_judgment_reason(host_registry:, mode:)
+        return nil if mode.to_s.strip.downcase == "off"
+        return "guardrails.system_one still sets a key that moved to system_one" if moved_keys_left?
+
+        client = from_config(host_registry: host_registry, mode: mode)
+        return "system_one.host is not set" unless client
+
+        client.backend.target
+        nil
+      rescue UnsupportedHost => e
+        e.message
+      end
+
       # system_one.timeout_ms, else the default: the whole
       # request's limit, and how long a turn waits for an answer (toolkit
       # suggestion's on mode).

data/lib/samagotchi/system_one/http_backend.rb

@@ -47,15 +47,7 @@ module Samagotchi
       # @raise [BackendError] the request failed, the status isn't 200, or
       #   the body isn't a usable response
       def ask(state:, questions:, cancel_controller: nil, observer: nil)
-        entry = @host_registry.find_entry(@host)
-        raise UnsupportedHost, "host #{@host.inspect} is not in hosts:" unless entry
-        unless entry.api&.to_sym == :openai
-          raise UnsupportedHost, "host #{@host} has api: #{entry.api || "llama_cpp"}; System One speaks the OpenAI-compatible API"
-        end
-
-        model = @model || host_model(entry)
-        raise UnsupportedHost, "host #{@host} names no model for System One" if model.nil? || model.empty?
-
+        entry, model = target
         observer&.call(model: model)
         url = "#{entry.openai_base_url.to_s.chomp("/")}/systemone"
         questions = SystemOne.normalize_questions(questions)
@@ -72,7 +64,28 @@ module Samagotchi
         data = reply_of(response.body)
         answers = data["answers"]
         observer&.call(served_model: data["model"], raw: answers, usage: data["usage"])
-        questions.to_h { |question| [question.id, Answer.from_wire(question.id, answers[question.id])] }
+        questions.to_h do |question|
+          levels = question.criteria.size if question.type == :score
+          [question.id, Answer.from_wire(question.id, answers[question.id], levels: levels)]
+        end
+      end
+
+      # The hosts: entry and model an ask would go to, without asking: all
+      # read from the settings, no request.
+      # @return [Array(HostRegistry::Entry, String)]
+      # @raise [UnsupportedHost] the host is unknown, not an openai host, or
+      #   names no model
+      def target
+        entry = @host_registry.find_entry(@host)
+        raise UnsupportedHost, "host #{@host.inspect} is not in hosts:" unless entry
+        unless entry.api&.to_sym == :openai
+          raise UnsupportedHost, "host #{@host} has api: #{entry.api || "llama_cpp"}; System One speaks the OpenAI-compatible API"
+        end
+
+        model = @model || host_model(entry)
+        raise UnsupportedHost, "host #{@host} names no model for System One" if model.nil? || model.empty?
+
+        [entry, model]
       end
 
       private