samagotchi 0.50.0 → 0.52.0

data/lib/samagotchi/bootstrap/config_writer.rb

@@ -6,6 +6,7 @@ require "fileutils"
 require "ipaddr"
 require_relative "../atomic_file"
 require_relative "../config"
+require_relative "../yaml_lines"
 
 module Samagotchi
   module Bootstrap
@@ -15,6 +16,8 @@ module Samagotchi
     # comments), after a backup, and is checked by parsing it again: every
     # other key must be unchanged, or the backup goes back.
     class ConfigWriter
+      include YAMLLines
+
       class Error < StandardError
       end
 
@@ -33,7 +36,6 @@ module Samagotchi
       end
 
       HOSTS_LINE_RE = /\Ahosts:[ \t]*(#.*)?\z/
-      DEFAULT_INDENT = 2
       SERVER_TRANSPORTS = ConfigFile::VALID_TRANSPORTS_FOR_CONFIG
 
       # The host part of a name: localhost/127.x → local, another IP → lan,
@@ -157,9 +159,7 @@ module Samagotchi
         original = File.binread(@path).force_encoding(Encoding::UTF_8)
         return snippet(name, fields) unless data.is_a?(Hash) && !anchors?(original)
 
-        eol = original.include?("\r\n") ? "\r\n" : "\n"
-        lines = original.split(/(?<=\n)/)
-        lines[-1] = "#{lines[-1]}#{eol}" if lines.any? && !lines[-1].end_with?("\n")
+        lines, eol = lines_of(original)
         hosts_at = lines.index { |line| line.chomp.match?(HOSTS_LINE_RE) }
         return snippet(name, fields) if hosts_at.nil? && data.key?("hosts")
 
@@ -207,28 +207,14 @@ module Samagotchi
       # before trailing blank lines and comments shallower than an entry.
       # @return [index, entry indent, field indent step]
       def block_end(lines, hosts_at)
-        stop = hosts_at + 1
-        stop += 1 while stop < lines.length && inside_block?(lines[stop])
+        stop = block_stop(lines, hosts_at)
         children = lines[(hosts_at + 1)...stop].reject { |line| blank_or_comment?(line) }
         child = children.first ? indent(children.first) : DEFAULT_INDENT
         field = children.find { |line| indent(line) > child }
         step = field ? indent(field) - child : child
-        at = stop
-        at -= 1 while at > hosts_at + 1 && (lines[at - 1].strip.empty? || (comment?(lines[at - 1]) && indent(lines[at - 1]) < child))
-        [at, child, step]
-      end
-
-      def inside_block?(line)
-        return true if line.strip.empty?
-        return false if line.start_with?("---", "...")
-
-        line.start_with?(" ", "\t") || comment?(line)
+        [insert_at(lines, hosts_at, stop, child), child, step]
       end
 
-      def blank_or_comment?(line) = line.strip.empty? || comment?(line)
-      def comment?(line) = line.lstrip.start_with?("#")
-      def indent(line) = line[/\A */].length
-
       def entry_lines(name, fields, child, step)
         ["#{" " * child}#{name}:\n", *fields.map { |key, value| "#{" " * (child + step)}#{key}: #{scalar(value)}\n" }]
       end
@@ -316,23 +302,6 @@ module Samagotchi
         false
       end
 
-      def parse(text) = YAML.safe_load(text, permitted_classes: [], aliases: false)
-
-      # Anchors and aliases: chi's reader refuses aliases, and an insert
-      # can't know what an anchor shares.
-      def anchors?(text)
-        stack = [Psych.parse_stream(text)]
-        until stack.empty?
-          node = stack.pop
-          return true if node.is_a?(Psych::Nodes::Alias) || (node.respond_to?(:anchor) && node.anchor)
-
-          stack.concat(Array(node.children)) if node.respond_to?(:children)
-        end
-        false
-      rescue Psych::Exception
-        true
-      end
-
       def backup_path(real)
         stamp = @now.call.utc.strftime("%Y%m%dT%H%M%SZ")
         candidate = "#{real}.bak-#{stamp}"

data/lib/samagotchi/bridge/ring_buffer.rb

@@ -40,11 +40,6 @@ module Samagotchi
         end
       end
 
-      # Whether any buffered event could satisfy a reconnect from +from_seq+.
-      def has_any_after?(from_seq:)
-        @mutex.synchronize { @events.any? { |e| e[:seq] > from_seq } }
-      end
-
       # @return [Integer, nil] the highest seq buffered so far.
       def last_seq
         @mutex.synchronize { @events.last&.[](:seq) }

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -158,7 +158,8 @@ module Samagotchi
       def self.tool_replay_events(part)
         call = { iteration: part[:iteration], call_index: part[:call_index], tool: part[:tool] }
         call[:label] = part[:label] if part[:label]
-        title = part[:title] ? { title: part[:title] } : {}
+        # Its title and, for an alias's call, the name the model used.
+        title = part.slice(:title, :called_as).compact
         view = part[:view] ? { view: part[:view] } : {}
         events = [{ type: :tool_call_started, **call, params: part[:params], **title, **view }]
         if part[:status] == "running"
@@ -274,6 +275,7 @@ module Samagotchi
                    tool: event[:tool], params: event[:params], status: "running" }
           part[:label] = event[:label] if event[:label]
           part[:title] = event[:title] if event[:title]
+          part[:called_as] = event[:called_as] if event[:called_as]
           part[:view] = event[:view] if event[:view]
           parts << part
           @tool_started_at[[event[:iteration], event[:call_index]]] = @clock.call

data/lib/samagotchi/bridge.rb

@@ -7,6 +7,7 @@ require "fileutils"
 require "securerandom"
 require "time"
 require_relative "atomic_file"
+require_relative "delivery"
 require_relative "session_inbox"
 
 require_relative "bridge/bounded_queue"
@@ -20,6 +21,7 @@ require_relative "session"
 require_relative "engine"
 require_relative "guardrails/parent_approvals"
 require_relative "session_commands"
+require_relative "queued_command"
 require_relative "steer"
 require_relative "image_store"
 require_relative "log"
@@ -285,12 +287,11 @@ module Samagotchi
     #   basename): it runs once that file is taken (Worker#on_command)
     # @return [String] its command_id
     def queue_command(line, client_id: nil, card: false, after_file: nil)
-      command = { command_id: SecureRandom.uuid, client_id: client_id, line: line.to_s.strip }
       # A card's action (the step-limit question's answer): the UIs leave
       # its line out.
-      command[:card] = true if card
+      command = QueuedCommand.mint(line.to_s.strip, client_id: client_id, card: card)
       @engine.synchronize_events { queue_command_locked(command, after_file: after_file) }
-      command[:command_id]
+      command.command_id
     end
 
     private
@@ -721,18 +722,17 @@ module Samagotchi
     # :command_queued, unless +deadline+ has passed. Returns [headers,
     # status, body]: 202 with its command_id, or 408.
     def queue_command_request(session_id, line, client_id:, deadline: nil, card: false)
-      command = { command_id: SecureRandom.uuid, client_id: client_id, line: line }
       # A card's action: the UIs leave its line out (the card is the echo).
-      command[:card] = true if card
+      command = QueuedCommand.mint(line, client_id: client_id, card: card)
       queued = @engine.synchronize_events do
-        next false if expired?("command_expired", deadline, sid: session_id, client_id: command[:client_id])
+        next false if expired?("command_expired", deadline, sid: session_id, client_id: command.client_id)
 
         queue_command_locked(command)
         true
       end
       return deadline_passed("command") unless queued
 
-      [{}, 202, { status: "accepted", command_id: command[:command_id], session_id: @session_id }]
+      [{}, 202, { status: "accepted", command_id: command.command_id, session_id: @session_id }]
     end
 
     # With the event log held. +on_command+ answers what it did with the
@@ -747,7 +747,7 @@ module Samagotchi
               when :queue then { waits: "turn_end" }
               else {}
               end
-      @engine.announce(type: :command_queued, **command, **marks)
+      @engine.announce(type: :command_queued, **command.event_fields, **marks)
     end
 
     # A client asks the worker to exit now (`/exit` in the attached TUI), or
@@ -826,6 +826,13 @@ module Samagotchi
       deadline = fetched(parsed, "deadline")
       return BAD_DEADLINE unless deadline_valid?(deadline)
 
+      raw_delivery = fetched(parsed, "delivery")
+      if (refused = Delivery.refusal(raw_delivery))
+        return [{ "Allow" => "POST" }, 400, refused]
+      end
+
+      delivery = Delivery.parse(raw_delivery)
+
       # A session command sent as a message (chi send -m "/model x", chi -p,
       # a UI whose command list lags) runs as the command, as typed in a
       # TUI; an unknown /word stays a prompt. Not with images: those are
@@ -844,7 +851,7 @@ module Samagotchi
         next :expired if expired?("turn_expired", deadline, sid: sid, client_id: client_id)
 
         enqueue_turn(prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,
-                     no_interrupt: no_interrupt, images: images).tap do |ok|
+                     no_interrupt: no_interrupt, images: images, delivery: delivery).tap do |ok|
           next unless ok
 
           enqueued_event = { type: :turn_enqueued, enqueued_id: enqueued_id, client_id: client_id, prompt: prompt.to_s }
@@ -856,12 +863,17 @@ module Samagotchi
       return deadline_passed("turn") if enqueued == :expired
       return [{}, 500, { error: "enqueue_failed", detail: "could not write turn input" }] unless enqueued
 
-      # Queued (outside the event lock): a running generation that has only
-      # been thinking for long is cut for it, unless a plugin or a client
-      # chi doesn't know sent it. An image input never merges mid-turn, so
-      # it never cuts.
-      @engine.cut_for_steer(Steer.source_for_client(client_id), epoch: epoch) if images.empty?
-      [{}, 202, { status: "accepted", enqueued_id: enqueued_id, session_id: @session_id }]
+      # Queued (outside the event lock): a message sent as +cut+ cuts a
+      # running generation that has only been thinking for long, unless a
+      # plugin or a client chi doesn't know sent it. An image input never
+      # merges mid-turn, so it never cuts. Nothing else cuts: a message
+      # that says nothing (an older client, the web composer) goes in at
+      # the running turn's next step.
+      cut = nil
+      cut = @engine.cut_for_steer(Steer.source_for_client(client_id), epoch: epoch) if images.empty? && Delivery.cut?(delivery)
+      ack = { status: "accepted", enqueued_id: enqueued_id, session_id: @session_id, delivery: delivery }
+      ack[:cut] = cut.to_s if cut
+      [{}, 202, ack]
     end
 
     # Read-only snapshot surface. AC #4: too-old reconnects re-derive state
@@ -933,9 +945,9 @@ module Samagotchi
 
     # Write a turn into this session's input dir, reusing the file IPC the
     # worker polls. Never calls run_turn across the boundary.
-    def enqueue_turn(prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, images: [])
+    def enqueue_turn(prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, images: [], delivery: nil)
       SessionInbox.write_input(session_dir, prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,
-                                            no_interrupt: no_interrupt, images: images)
+                                            no_interrupt: no_interrupt, images: images, delivery: delivery)
     end
 
     # ── HTTP plumbing ────────────────────────────────────────────────────────

data/lib/samagotchi/bridge_client.rb

@@ -4,6 +4,7 @@ require "json"
 require "socket"
 
 require_relative "worker_sidecar"
+require_relative "delivery"
 require_relative "bridge_client/sse_parser"
 require_relative "bridge_client/event_stream"
 
@@ -139,10 +140,11 @@ module Samagotchi
     # @param no_interrupt [Boolean] run the turn with the raised iteration limit
     # @param images [Array<Hash>] refs ({file:, name:}) to images already in
     #   the session's images/
-    def post_turn(prompt:, client_id: nil, no_interrupt: false, images: nil)
+    def post_turn(prompt:, client_id: nil, no_interrupt: false, images: nil, delivery: nil)
       body = { session_id: @session_id, prompt: prompt, client_id: client_id }
       body[:no_interrupt] = true if no_interrupt
       body[:images] = images if images && !images.empty?
+      body[:delivery] = delivery unless delivery.nil? || Delivery.next_step?(delivery)
       body[:deadline] = deadline
       post("turn", body, read_body: true)
     end

data/lib/samagotchi/broadcast/recipients.rb

@@ -46,8 +46,7 @@ module Samagotchi
         return false unless (time(row[:updated_at]) || Time.at(0)) >= cutoff
 
         session = Session.summary_from_file(Session.session_file(row[:id], state_dir: state_dir))
-        last_turn = session&.last_turn
-        ended = last_turn.is_a?(Hash) ? time(last_turn["ended_at"] || last_turn[:ended_at]) : nil
+        ended = time(session&.last_turn&.ended_at)
         (ended || time(row[:updated_at])) >= cutoff
       end
       private_class_method :active_since?

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

@@ -58,7 +58,7 @@ Only the nested form is read. An env name used as a top-level key (`SAMAGOTCHI_D
 
 - `model_aliases:` map of alias → model id (`ModelRef.parse`, through `HostRegistry#resolve`). Keys lowercased on write (`ConfigFile.write_model_alias!`). Values may be bare `model` or qualified `host:model` (hybrid; only `:` names a host, `org/model` is an id). Aliases apply once: never point an alias at another alias.
 - `hosts:` map of `name → {host, port | url, transport, api, api_key_env, profile, first_token_timeout, vision, sampling, thinking, enabled, models}` (`ConfigFile.hosts_config`, `host_registry.rb` `HostEntry`). Names lowercased; `url:` (http/https, optional path) replaces host/port, never both; `api_key_env:` names the env var holding the API key (never write a key into config.yml); `transport` overrides `server.transport`; `first_token_timeout` (seconds, `0` = off; a negative or non-number warns and is ignored) overrides `server.first_token_timeout` for that host; `models:` (a map of model ids, or a plain list) declares ids the host serves whatever its `/v1/models` lists: no "doesn't list" warning, and a bare id routes there as if listed (`HostModel`); an entry may hold `price: {input, output, cache_read?, cache_write?}` in USD per 1M tokens (`ModelPrice`; an unset cache rate is the input rate), which estimates a cost the provider doesn't report or reports as 0 (`cost_estimate`, shown as `~$`), and `served: [ids] | any`, the models a gateway may answer that id with (no served-model warning for them); model settings stay in the root `models:`; workers inherit via `SAMAGOTCHI_HOSTS_JSON` (`hosts_json_for_env`, `session_manager.rb`).
-- `models:` map of model id or alias → `{profile, vision, sampling, thinking}` (`ConfigFile.model_settings`). `thinking:` (here, on a host, or `thinking.level` for every model) is `off|low|medium|high|default` (`Thinking`; unquoted `off` works, `on` is not a level; `default` = send nothing). Precedence: `--thinking`/`SAMAGOTCHI_THINKING_LEVEL` > `models:` > `hosts.<name>.thinking` > `thinking.level` in config.yml > `default`. A `sampling:` key wins over the fields a level sends (`null` drops one); `docs/configuration.md` "Thinking". `sampling:` (here or on a host) is a map of request fields passed to the provider as written (`temperature`, `top_p`, `presence_penalty`, `repeat_penalty`, …; a model's fields win over its host's per field; `null` = don't send; chi's own fields like `max_tokens`/`stream` are refused with a warning; `docs/configuration.md` "Sampling"). Keys match case-insensitively. `profile` (here or on a host) is `qwen36|gemma4`: the raw prompt format for native hosts. Precedence: `--profile`/`SAMAGOTCHI_MODEL_PROFILE` > `models:` > `hosts.<name>.profile` > the llama.cpp server's chat template > the name (`qwen`/`gemma`) > `qwen36` (`ModelProfile.resolve`). Set one when a model's name hides its family (e.g. a Qwen fine-tune under another name on mlx, which has no template to read).
+- `models:` map of model id or alias → `{profile, vision, sampling, thinking}` (`ConfigFile.model_settings`). `thinking:` (here, on a host, or `thinking.level` for every model) is `off|low|medium|high|default` (`Thinking`; unquoted `off` works, `on` is not a level; `default` = send nothing). Precedence: the session's own level (`/thinking LEVEL`, saved in the session; `chi --thinking` on a session run, `chi send --new --thinking`) > `chi web --thinking`/`SAMAGOTCHI_THINKING_LEVEL` > `models:` > `hosts.<name>.thinking` > `thinking.level` in config.yml > `default`. A `sampling:` key wins over the fields a level sends (`null` drops one); `docs/configuration.md` "Thinking". `sampling:` (here or on a host) is a map of request fields passed to the provider as written (`temperature`, `top_p`, `presence_penalty`, `repeat_penalty`, …; a model's fields win over its host's per field; `null` = don't send; chi's own fields like `max_tokens`/`stream` are refused with a warning; `docs/configuration.md` "Sampling"). Keys match case-insensitively. `profile` (here or on a host) is `qwen36|gemma4`: the raw prompt format for native hosts. Precedence: `--profile`/`SAMAGOTCHI_MODEL_PROFILE` > `models:` > `hosts.<name>.profile` > the llama.cpp server's chat template > the name (`qwen`/`gemma`) > `qwen36` (`ModelProfile.resolve`). Set one when a model's name hides its family (e.g. a Qwen fine-tune under another name on mlx, which has no template to read).
 - `hooks:` map of `hooks_dir` + per-event lists `{path, on_error}` (`Hooks::Loader.load`). `hooks_dir` may start with `~`.
 - `guardrails:` tool-call rules (`docs/guardrails.md`; read in `Engine#guardrail_rules`, parsed by `Guardrails::Rules.parse`): `enabled` (bool, default true; `false` drops rules and hooks' asks, a deny still applies; config.yml only, like every `guardrails` setting: no env variable), `parent_approvals` (`off`, the default: a parent agent's `chi answer` can only deny an approval; `once`: it may give "Allow once" too; a convention for an honest parent, not a security boundary, and the user's choice: set it only when the user asks), `rules:` (list), `disable:` (a rule id or a list of them, `id` or `bundle:id`, switching off a bundle's or config rule without editing it), `small_models` (`auto`, the default: small = 32B or less read from the name; a glob or list of globs; `[]` for none). A rule takes only `id`, `tool`, `command`, `path`, `git`, `models`, `verdict`, `reason`, `scopes`: `id` required; at least one of `tool` (a name, `shell` = execute + task_create, a `File.fnmatch` glob like `"mcp_*"`, or a list), `command` (a Ruby regex on the shell command), `path` (a glob, or `outside_repo`: outside the session's repo, tmp folders and memory files excepted), `git` (only `outside_repo`: a shell call runs commit/add/reset/… in another checkout); `models` (optional: `small`, a model-name glob, or a list; without it the rule is for every model); `verdict` `ask|deny`; `scopes` (for `ask`) a subset of `once, session, repo, rule`. **Any parse error (an unknown key, a bad regex, no verdict) makes chi deny every tool call** until fixed, so validate with `YAML.safe_load` and keep the list shape. Rules are read again on the next tool call after config.yml or a bundle's rules change: no restart needed. Installed bundles' rule files (`chi bundle install guardrails`) add to them; `/guardrails` lists what loaded.
 

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.50.0
+version: 0.52.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
   self_map.md: sha256:dfc19266259a9af1e0d769b7e0f67996b740b0c9921fdf3dadad973f6e5c144a
-  config_modification_protocol.md: sha256:337ad1b4cc9308dc5abb47b13f51a76df4691ba80fe41648f391687b5b929b65
+  config_modification_protocol.md: sha256:a7a6352c03979db69d98955bee8f36eb468a6cf68904d418b7f3ddb788c83e7b
   memory_guide.md: sha256:15cd3b24eda853cc458371c6c75809a2d4b5352311d075aaa4384926b5221c27
   delegated.md: sha256:aedaa1e756a244904c5560fff0424e06fb468bbdcb0358bccefe321d67cd2614

data/lib/samagotchi/children_status.rb

@@ -95,7 +95,7 @@ module Samagotchi
       return "running" if Tools::Delegate.running?(row)
       return "stopped" if session.status == Session::STATUS_STOPPED
 
-      outcome = session.last_turn.is_a?(Hash) ? session.last_turn["outcome"] : nil
+      outcome = session.last_turn&.outcome
       return "failed" if session.status == Session::STATUS_ERROR || outcome == "failed"
       return "done" if outcome == "completed" && reply
 

data/lib/samagotchi/commands/registry.rb

@@ -21,7 +21,8 @@ module Samagotchi
       #   turn runs (MID_TURN): a symbol, or a lambda line (stripped) → one
       # @!attribute local [Boolean] the UI runs it; completion and help only
       # @!attribute uis [Array<Symbol>, nil] a local entry's UIs (:repl,
-      #   :attached) for completion; nil means every UI
+      #   :attached, :web) for completion and /help; nil means every UI
+      #   (for a local entry, every terminal)
       # @!attribute match [#call] line (stripped) → whether it is this command
       # @!attribute handler [Proc, nil] runs it; SessionCommands instance_execs
       #   a built-in's with the line, and calls a bundle's with the text