samagotchi 0.18.0 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c7c0dfd8a859bb4808e10128560904cac788bc6bed8ec0b9d799425c6eee2fb
-  data.tar.gz: 4263cf99ea0998c74d7ae0f4e37d3bdbed8acc0140400082eed696da58e14847
+  metadata.gz: 34f4c3e1960aa23902e27160bd1f325ba035731c283a93b2cd819676481c90a2
+  data.tar.gz: 708e58e5bfc26d10fe9f20bd1b696f6355e2a25749a36ca6503e82ca9077fa64
 SHA512:
-  metadata.gz: 16b8b6cda0d263cb6540e052d207483396a5fd4588e3e4ddd776e02bcc107fb63ef73e19835b20b44e5c95e850d30b018bf985d898c8a2b07e6ae7a7a2984034
-  data.tar.gz: ade20718b92e00ee24274d5b0cdce3ff102ae88487cb00af244168134f1f0c0d3259cb1e7f19ade71bf8fe442cba1a764bd6550c5d1911ef7cce558fabac044f
+  metadata.gz: 56c634e50c34f3fd027ca9ed7208d7edaab21a639050fe321c1d9fa5e8a0e818a31ae6c6351f8c21c0417984f3235a1a44b14aaa3d415b392a85d3bff2916aa1
+  data.tar.gz: 41862c98747027f791e4aa59b4c6d2eda092d818e3492212fbc79a24970c74734c3196c480511876aa97b95a8e1245c8bfd6fceccb73d47ade67d3f96ced89fa

data/CHANGELOG.md

@@ -8,6 +8,39 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.18.1] - 2026-10-03
+
+### Fixed
+
+- The `execute` tool no longer hangs when a command leaves a process in the background (`server &`, or
+  `cd DIR && nohup server > log 2>&1 &`) that keeps its output open: after a short grace it stops that process and
+  returns the output, with a note to start servers and long jobs with `task_create`. Stop and
+  `execute.timeout_sec` work during the wait too.
+- A running session no longer denies every tool call after an installed bundle's rules are upgraded to a version
+  that needs a newer chi (`requires_chi`): it keeps the rules it loaded before and says once to restart the session
+  (`chi sessions stop ID`, then `chi --resume ID`).
+- `chi -p … --non-interactive` keeps stdout for the answer alone: the `Session:` (or `Resumed session:`) line goes
+  to stderr, before the turn. A failed turn now says after its error that the session is kept with the prompt and
+  how to continue it (`chi --resume ID`).
+- Ctrl-C in `chi -p … --non-interactive` keeps the session: the prompt and a cancel note are saved, so
+  `chi --resume ID` has them, and stderr says so instead of a Ruby backtrace. The exit status stays 130.
+- `chi -p` shows the after_turn hooks' notices (source-links' `sources:`, any notifier), which it lost: with
+  `--non-interactive` on stderr after the answer; attached (input from a pipe) it waits for them and shows them
+  before it detaches.
+- `chi -p … --non-interactive` prints the retry lines on stderr (`↻ empty answer, asking again (1/1)`, `retrying
+  (1/5 in 0.5s): …`), as the REPL shows them, instead of nothing.
+- A native llama.cpp turn sends `GET /props` once, not twice.
+- After a failed `/props` probe, a server that then answers is probed again at the next turn, instead of the
+  failure being reused for 30 s.
+- A request to a model server is sent only as many times as chi's own retries say: Ruby's hidden extra retry is off.
+- The served-model notice no longer treats `gpt-4` and `gpt-4o` as the same model: a served name counts as the
+  asked one only when what follows starts with `:`, `-`, `@` or `/` (`qwen3` = `qwen3:latest`).
+- A Gemma thought channel (`<|channel>thought` … `<channel|>`) is stripped as a whole block, so the model's
+  reasoning no longer shows up in the answer.
+- An unknown model profile name falls back to `qwen36`, the same default as everywhere else, instead of `gemma4`.
+
+Update with `gem update samagotchi` (or `chi update`); no bundle changed.
+
 ## [0.18.0] - 2026-10-03
 
 ### Added
@@ -1002,7 +1035,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.18.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.18.1...HEAD
+[0.18.1]: https://github.com/dm1try/samagotchi/compare/v0.18.0...v0.18.1
 [0.18.0]: https://github.com/dm1try/samagotchi/compare/v0.17.0...v0.18.0
 [0.17.0]: https://github.com/dm1try/samagotchi/compare/v0.16.0...v0.17.0
 [0.16.0]: https://github.com/dm1try/samagotchi/compare/v0.15.0...v0.16.0

data/bin/chi

@@ -314,6 +314,7 @@ if launch == :attached
   exit Samagotchi::TerminalUI::AttachLauncher.exit_status(ended)
 end
 
+require "samagotchi/cli/exit"
 begin
   ended = Samagotchi::TerminalUI.new(
     prompt: options[:prompt],
@@ -326,8 +327,10 @@ begin
     model_name: options[:model],
     scratch: scratch
   ).run
-  # `chi -p X </dev/null`: the turn failed (nothing was sent again).
-  exit 1 if ended == :turn_failed
+  # `chi -p X </dev/null`: the turn failed (nothing was sent again); -p
+  # --non-interactive: the turn ended with no answer, or Ctrl-C cancelled it.
+  exit 1 if %i[turn_failed empty_answer].include?(ended)
+  exit Samagotchi::CLI::Exit::INTERRUPTED if ended == :interrupted
 rescue Samagotchi::TerminalUI::SessionBusy, Samagotchi::TerminalUI::SessionNotFound, Samagotchi::ModelProfile::MissingModel => e
   warn "Error: #{e.message}"
   exit 1

data/docs/cli.md

@@ -224,7 +224,13 @@ Notes:
   messages as turn context (a `-p` run on a resumed session never clobbers its
   conversation).
 - Non-interactive runs (`-p` with `--non-interactive`, or bare `--non-interactive`)
-  print only the final result output — no spinner, status line, or REPL.
+  print only the final result output on stdout — no spinner, status line, or REPL.
+  Everything else goes to stderr: the `Session: ID` line first, before the turn;
+  retry lines and hooks' notices as they come, the after_turn hooks' ones
+  (source-links' `sources:`) after the answer; and the error of a failed turn,
+  then `chi: the session is kept with your prompt; continue it with: chi
+  --resume ID` (exit 1). Ctrl-C saves the session with the prompt and a
+  cancel note and exits 130.
 
 ### Scratch sessions
 

data/docs/guardrails.md

@@ -295,6 +295,14 @@ restart. A rule that doesn't parse (an unknown key, a bad regex, no
 verdict, a `disable:` that isn't an id or a list of ids) makes chi **deny every tool call** and say why, rather than run
 without it.
 
+A bundle whose `requires_chi` the running chi doesn't meet (installed by a
+newer chi while the session's worker kept running) isn't read again: the
+rules the session loaded from it before stay, and a `guardrails>` line says
+once per bundle version to restart the session (`chi sessions stop ID`, then
+`chi --resume ID`). A chi that never loaded that bundle's rules (it starts
+older than the bundle) denies every tool call, as for a rule that doesn't
+parse, until chi is updated or the bundle uninstalled.
+
 ## The guardrails bundle
 
 ```sh

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

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

data/lib/samagotchi/client.rb

@@ -31,12 +31,39 @@ module Samagotchi
     CONTEXT_WINDOW_PROBE_READ_TIMEOUT = 2
     # Seconds a probe that got no answer (refused, timed out) is remembered:
     # a down or hung server then costs one probe per window, not one per
-    # generation, and a new turn doesn't ask again at once.
+    # generation, and a new turn doesn't ask again at once. A request to the
+    # host that succeeds drops the remembered failure (see
+    # #clear_props_failures!).
     PROPS_FAILURE_TTL = 30
 
     DEFAULT_TRANSPORT = :llama_cpp
     VALID_TRANSPORTS = %i[llama_cpp mlx omlx].freeze
 
+    # One /props cache per host per process. A host has more than one Client
+    # in a run (the registry's, a rebuilt HostRegistry's, the Engines of a
+    # TUI and a spec): with a cache each, every one of them asks /props for
+    # the same server. Keyed by the host's base URL (scheme://host:port), so
+    # two Clients of the same server share the answers their turns read.
+    # Entries live for the process: they are the same small hash per host
+    # (answers by model, failures by model with their timestamps).
+    @props_store = {}
+    @props_store_mutex = Mutex.new
+
+    class << self
+      # The shared props entry for a host's base URL:
+      # { answers: { model => ServerProps }, failures: { model => [props, at] },
+      #   mutex: Mutex }. The caller may hold the entry's own mutex.
+      def props_entry(base_url)
+        @props_store_mutex.synchronize { @props_store[base_url] ||= { answers: {}, failures: {}, mutex: Mutex.new } }
+      end
+
+      # Forget every host's answers and failures. Specs call it per example
+      # (the store outlives one); nothing in a run does.
+      def reset_props_store!
+        @props_store_mutex.synchronize { @props_store.clear }
+      end
+    end
+
     # Wire-format strategy for one server transport. `Client` keeps the
     # transport-agnostic request/retry/stream loop; everything that differs
     # between llama.cpp's native API and the OpenAI-compatible servers
@@ -175,9 +202,13 @@ module Samagotchi
       @open_timeout  = Samagotchi::Config.positive_seconds("server.open_timeout", open_timeout)
       @read_timeout  = Samagotchi::Config.positive_seconds("server.read_timeout", read_timeout)
       @transport = build_transport(resolve_transport(transport))
-      @props_cache = {}
-      @props_failures = {}
-      @props_mutex = Mutex.new
+      # This host's process-wide /props entry (see self.props_entry): its
+      # answers and failures are shared with every other Client of the same
+      # server.
+      @props_entry = self.class.props_entry("#{@scheme}://#{@host}:#{@port}")
+      @props_cache = @props_entry[:answers]
+      @props_failures = @props_entry[:failures]
+      @props_mutex = @props_entry[:mutex]
       @first_token_timeout = first_token_timeout
       @host_name = name
       @label = name.to_s.empty? ? @transport.label : name.to_s
@@ -270,6 +301,10 @@ module Samagotchi
         chunk[:finish_reason] = finish_reason if finish_reason
         on_chunk.call(**chunk)
       end
+      # The host answered: a /props probe that failed while it was down (or
+      # loading) is no longer true, so the next turn asks it again instead
+      # of reusing the failure for the rest of its PROPS_FAILURE_TTL.
+      clear_props_failures!
       result
     rescue LLM::BadRequest => e
       raise unless e.status == 404 && @transport.name == :llama_cpp
@@ -293,6 +328,7 @@ module Samagotchi
     def list_models
       uri = URI("#{@scheme}://#{@host}:#{@port}#{@transport.models_path}")
       response = @http.fetch(uri, Net::HTTP::Get.new(uri), log_fields: { purpose: "models" })
+      clear_props_failures!
       parsed = JSON.parse(response.body.to_s)
       parsed.fetch("data", parsed)
     rescue LLM::ProviderError
@@ -309,7 +345,9 @@ module Samagotchi
     # Whatever the server answers (a non-200 too) is cached per model; a
     # network failure for PROPS_FAILURE_TTL seconds, then the next call asks
     # again. A probe cut by this thread's Client.probe_cancel answers
-    # :cancelled, uncached, and the turn's next request ends it.
+    # :cancelled, uncached, and the turn's next request ends it. A completion
+    # or model list this client gets through clears the failures: a server
+    # that just answered is not the down or hung one the window remembered.
     def server_props(model: nil)
       path = @transport.props_path
       return nil unless path
@@ -350,11 +388,12 @@ module Samagotchi
       nil
     end
 
-    # Forget cached /props answers: the server may have restarted with
-    # another -c, or a model switch may have loaded one with a different
-    # window. A recent failure stays until its PROPS_FAILURE_TTL ends: it
-    # holds no stale window, and asking a hung server again at every turn's
-    # start is what it saves.
+    # Forget cached /props answers for this host: the server may have
+    # restarted with another -c, or a model switch may have loaded one with a
+    # different window. The host's entry is shared with every Client of the
+    # same server, so the clear reaches them all. A recent failure stays
+    # until its PROPS_FAILURE_TTL ends: it holds no stale window, and asking
+    # a hung server again at every turn's start is what it saves.
     def invalidate_context_window!
       @props_mutex.synchronize { @props_cache.clear }
     end
@@ -363,6 +402,15 @@ module Samagotchi
 
     def monotonic_now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+    # The host answered a request: whatever a probe failed with (refused,
+    # timed out, 503 while it loaded) is stale, so the next probe asks it
+    # again rather than serving the failure for the rest of its
+    # PROPS_FAILURE_TTL. A cached answer stays: it was read from the same
+    # running server.
+    def clear_props_failures!
+      @props_mutex.synchronize { @props_failures.clear }
+    end
+
     def probe_props(path, model)
       query = model.empty? ? "" : "?#{URI.encode_www_form(model: model)}"
       uri = URI("#{@scheme}://#{@host}:#{@port}#{path}#{query}")

data/lib/samagotchi/engine.rb

@@ -142,7 +142,8 @@ module Samagotchi
         model_key: -> { @model_key },
         model_name: -> { guardrail_model_name },
         cancelled: -> { !!active_cancel_controller&.cancelled? },
-        ask: ->(fields) { open_question(fields) }
+        ask: ->(fields) { open_question(fields) },
+        notify: ->(message) { guardrail_notify(message) }
       )
       @guardrail_failures = @guardrail_wiring.failures
       # Plugins that failed to load: announced apart, as plugins (not
@@ -1194,6 +1195,16 @@ module Samagotchi
     end
     private :hook_notify
 
+    # A guardrails line to the user after load (:guardrail_warning, as the
+    # load failures show): a running turn's event, else announced.
+    def guardrail_notify(message)
+      event = { type: :guardrail_warning, message: message.to_s }
+      in_turn, sink = @turn_state.in_turn_sink
+      in_turn ? emit_event(sink, event) : announce_or_hold(event)
+      nil
+    end
+    private :guardrail_notify
+
     # A question through the question flow (REPL sync handler, attached TUI,
     # web), single-select, kind "hook". A --non-interactive run has no one
     # to ask: nil at once. Anything but an answer (a sync handler's text, no
@@ -1569,13 +1580,13 @@ module Samagotchi
       emit_event(turn.on_event, turn.tag(turn_started))
       raise image_error if image_error
 
-      # Ask the server for its window again each turn (one short /props GET,
-      # cached across the turn's generations): a restart with another -c
-      # between turns raises no error that would drop the cache. The
-      # profile may probe too (a first turn, a retry). Both run after
-      # run_turn's probe-cancel swap, so a Stop cuts them, and a failure
-      # ends the turn as turn_failed.
-      @client.invalidate_context_window!
+      # The window and the profile probes run after run_turn's probe-cancel
+      # swap, so a Stop cuts them; a failure ends the turn as turn_failed.
+      # The cache itself was dropped at the previous turn's end, so this
+      # turn's first probe asks the server (a restart with another -c
+      # between turns is noticed), and the answer the session's prompt build
+      # read for its profile (a first turn) is what this turn starts from:
+      # one GET /props per turn, not two.
       refresh_profile!
 
       # Before anything of the turn is kept or a reminder is used up.
@@ -1828,6 +1839,13 @@ module Samagotchi
       # treats the just-finished turn as activity and re-arms its window.
       left = @turn_state.finish!
       Client.swap_probe_cancel(probe_cancel_before)
+      # The next turn's window and served model are asked again: the cache
+      # (this host's, process-wide) is dropped here, at the turn's end,
+      # rather than at its start, so what this turn read (the profile's own
+      # probe included) is not asked for a second time within the turn. A
+      # restart with another -c between turns is still noticed: the next
+      # turn's first probe goes to the server.
+      @client.invalidate_context_window!
       log_dropped_steers(left, "turn_ended")
       record_activity
       # Clear hooks so they remain turn-scoped and never leak into the next turn.

data/lib/samagotchi/guardrail_wiring.rb

@@ -5,6 +5,8 @@ require "yaml"
 require_relative "config"
 require_relative "log"
 require_relative "guardrails"
+require_relative "memory_bundle/manifest"
+require_relative "version"
 require_relative "hooks"
 require_relative "edit_preview"
 require_relative "tool_activity"
@@ -32,7 +34,10 @@ module Samagotchi
     # @param model_name [#call] → String, nil: the effective model's bare name
     # @param cancelled [#call] → Boolean, whether the running turn is cancelled
     # @param ask       [#call] (fields) → the answer; the Engine's question flow
-    def initialize(scratch:, hooks:, tools:, session:, model_key:, cancelled:, ask:, model_name: -> {})
+    # @param notify    [#call] (message) → shows a guardrails line in every UI
+    #   (a bundle's rules kept because it needs a newer chi)
+    def initialize(scratch:, hooks:, tools:, session:, model_key:, cancelled:, ask:, model_name: -> {},
+                   notify: ->(_message) {})
       @scratch = scratch
       @hooks_lookup = hooks
       @tools_lookup = tools
@@ -41,6 +46,11 @@ module Samagotchi
       @model_name_lookup = model_name
       @cancelled_lookup = cancelled
       @ask = ask
+      @notify = notify
+      # Bundle name → the rules last loaded from it whole, kept while the
+      # installed version needs a newer chi; [name, version] said so once.
+      @loaded_bundle_rules = {}
+      @kept_noticed = {}
       @failures = Guardrails::LoadFailures.new
       @rules_mutex = Mutex.new
       @git = Guardrails::GitInfo.new
@@ -115,7 +125,9 @@ module Samagotchi
 
     # Installed bundles' guardrails/*.yml, by bundle name then file name.
     # A file that is missing, changed since install (sha256) or doesn't
-    # parse is a required load failure.
+    # parse is a required load failure. A bundle whose requires_chi this
+    # chi doesn't meet isn't read (its rules may use keys this chi doesn't
+    # know): the rules last loaded from it stay (#too_new_bundle_rules).
     def bundle_rules
       require_relative "memory_bundle/provenance"
       rules = []
@@ -125,7 +137,13 @@ module Samagotchi
           @failures.add("rules (bundle #{bundle_name})", data[:error], required: true, group: :rules)
           next
         end
+        if (too_new = MemoryBundle::Manifest.requires_chi_failure(data[:requires_chi], Samagotchi::VERSION))
+          rules.concat(too_new_bundle_rules(bundle_name, data, too_new))
+          next
+        end
         dir = MemoryBundle::Provenance.new(name: bundle_name).guardrails_dir
+        loaded = []
+        whole = true
         data[:guardrails].sort_by { |k, _| k.to_s }.each do |basename, meta|
           what = "rules #{basename} (bundle #{bundle_name})"
           path = File.join(dir, basename.to_s)
@@ -139,12 +157,15 @@ module Samagotchi
             doc = YAML.safe_load(File.read(path))
             raise Guardrails::Rules::ParseError, "expected a mapping with rules:" unless doc.is_a?(Hash)
 
-            rules.concat(Guardrails::Rules.parse(doc["rules"], source: "bundle #{bundle_name}"))
+            loaded.concat(Guardrails::Rules.parse(doc["rules"], source: "bundle #{bundle_name}"))
           rescue Guardrails::Rules::ParseError, Psych::Exception => e
             Log.warn(:guardrails, "rules_file_invalid", echo: "[samagotchi:guardrails] #{what}: #{e.message}", bundle: bundle_name, file: basename.to_s)
             @failures.add(what, e.message, required: true, group: :rules)
+            whole = false
           end
         end
+        rules.concat(loaded)
+        @loaded_bundle_rules[bundle_name] = loaded if whole
       end
       rules
     rescue StandardError => e
@@ -192,6 +213,38 @@ module Samagotchi
 
     private
 
+    # The rules of a bundle that needs a newer chi: the ones last loaded
+    # from it, with one notice per bundle version (restart the session to
+    # load the new ones). Never loaded (a chi older than the bundle it
+    # starts with): none, and a required load failure, as the hook loader
+    # does for a guardrail hook, so the calls aren't quietly unguarded.
+    def too_new_bundle_rules(bundle_name, data, reason)
+      kept = @loaded_bundle_rules[bundle_name]
+      unless kept
+        Log.warn(:guardrails, "bundle_rules_requires_chi", echo: "[samagotchi:guardrails] bundle #{bundle_name}: its rules are not loaded: #{reason}",
+                                                           bundle: bundle_name)
+        @failures.add("rules (bundle #{bundle_name})", "#{reason}; update chi (chi update) or uninstall the bundle",
+                      required: true, group: :rules)
+        return []
+      end
+
+      key = [bundle_name, data[:version].to_s]
+      return kept if @kept_noticed[key]
+
+      @kept_noticed[key] = true
+      Log.warn(:guardrails, "bundle_rules_kept", bundle: bundle_name, version: data[:version].to_s,
+                                                 requires_chi: data[:requires_chi].to_s)
+      @notify.call(kept_notice(bundle_name, data))
+      kept
+    end
+
+    def kept_notice(bundle_name, data)
+      id = @session_lookup.call&.id || "ID"
+      "bundle #{bundle_name} #{data[:version]} needs chi #{data[:requires_chi]} and this session runs chi #{Samagotchi::VERSION}: " \
+        "its new rules are not loaded, the ones loaded before still apply. Restart the session to load them " \
+        "(chi sessions stop #{id}, then chi --resume #{id})"
+    end
+
     # [path, mtime, size] of config.yml and every installed bundle's
     # manifest.json and guardrails/ file.
     def rules_stamp

data/lib/samagotchi/llm/http.rb

@@ -168,7 +168,7 @@ module Samagotchi
 
       # Send +request+ and return the response with its body read.
       # @param retries [Boolean] false: one attempt, network errors raised as
-      #   is (Net::HTTP's own silent retry of an idempotent GET included)
+      #   is; either way Net::HTTP's own silent retry is off (see #start)
       # @param check_status [Boolean] false: return an error response instead
       #   of raising its ProviderError
       # @raise [RequestCancelled] when +cancel_controller+ cancels (with or
@@ -178,7 +178,7 @@ module Samagotchi
         identify(request)
         current = new_attempt_state(uri, request, log_fields, stream: false)
         attempt = lambda do |state|
-          start(uri, open_timeout: open_timeout, read_timeout: read_timeout, max_retries: retries ? nil : 0) do |http|
+          start(uri, open_timeout: open_timeout, read_timeout: read_timeout, max_retries: 0) do |http|
             state[:http] = http
             http.request(request).tap do |response|
               state[:status] = response.code.to_i
@@ -210,7 +210,13 @@ module Samagotchi
 
       def start(uri, open_timeout: nil, read_timeout: nil, max_retries: nil, &block)
         options = { open_timeout: open_timeout || @open_timeout, read_timeout: read_timeout || @read_timeout }
-        options[:max_retries] = max_retries if max_retries
+        # Net::HTTP retries an idempotent request once on its own (max_retries
+        # defaults to 1) when the connection drops before an answer: chi's
+        # RetryPolicy owns retries (and the log line says how many were sent),
+        # so every request here gets Net::HTTP's silent one off. Callers may
+        # still ask for it explicitly (a fetch whose retries: false passes 0).
+        retries = max_retries || 0
+        options[:max_retries] = retries
         options[:use_ssl] = true if uri.scheme == "https"
         Net::HTTP.start(uri.host, uri.port, **options, &block)
       end

data/lib/samagotchi/model_profile.rb

@@ -112,7 +112,7 @@ module Samagotchi
     end
 
     def self.default
-      gemma4
+      named(DEFAULT_NAME)
     end
 
     def self.normalize(value)
@@ -124,7 +124,7 @@ module Samagotchi
       when "gemma", "gemma4", "gemma4o"
         gemma4
       else
-        gemma4
+        named(DEFAULT_NAME)
       end
     end
 

data/lib/samagotchi/output_formatter.rb

@@ -45,13 +45,17 @@ module Samagotchi
     )
     INDIVIDUAL_RE.freeze
 
-    # Angle-bracketed literal tokens stripped wholesale (including the thought
-    # channel's trailing word). Applied before INDIVIDUAL_RE so multi-part tokens
-    # are removed as a unit.
     # Angle-bracketed literal tokens stripped wholesale (including the thought
     # channel's trailing word). Applied before INDIVIDUAL_RE so multi-part tokens
     # are removed as a unit. Pipes are escaped; angle brackets are literal.
-    LITERALS_RE = /<\|"\|>|<\|\w*channel>thought|<end_of_turn>/.freeze
+    LITERALS_RE = /<\|"\|>|<end_of_turn>/.freeze
+
+    # Gemma 4's thought channel, as a whole block: `<|channel>thought` to its
+    # `<channel|>` close, or to the end of the text when the close is missing
+    # (ToolCallParser::Gemma strips the same pair). Removing only the marker
+    # would leave the model's private reasoning in the answer; the channel is
+    # the profile's thinking lane, not output.
+    GEMMA_THOUGHT_RE = /<\|\w*channel>thought.*?(?:<channel\|>|\z)/m.freeze
 
     # Qwen prompt-literal placeholders, e.g. </think>.
     PROMPT_LITERALS = /\[\[SAMAGOTCHI_LITERAL_[A-Z_]+\]\]/.freeze
@@ -88,6 +92,7 @@ module Samagotchi
     def remove_tokens(text)
       text.to_s
           .gsub(QWEN_THINK_RE, '')
+          .gsub(GEMMA_THOUGHT_RE, '')
           .gsub(QWEN_TOOL_CALL_RE, '')
           .gsub(LITERALS_RE, '')
           .gsub(INDIVIDUAL_RE, '')

data/lib/samagotchi/served_model.rb

@@ -17,16 +17,26 @@ module Samagotchi
       name.is_a?(String) && !name.strip.empty? ? name : nil
     end
 
+    # The separators a provider uses when it decorates a model name: a tag
+    # (`qwen3:latest`), a date or quant suffix (`gpt-4o-2024-08-06`), an
+    # owner (`@org/name`) or a path (`meta-llama/Llama-3`). Anything else
+    # after the name is a different model (`gpt-4` is not `gpt-4o`).
+    EXTENSION_SEPARATORS = [":", "-", "@", "/"].freeze
+
     # Whether +served+ is another model than +asked+. Names that are equal
-    # (any case) or where one extends the other (a provider dropping
-    # `:free`, or adding a date) are the same model; unknown names never
-    # differ.
+    # (any case), or where one extends the other at a tag/date/owner
+    # separator (a provider dropping `:free`, or adding a date), are the
+    # same model; unknown names never differ.
     def differs?(asked, served)
       asked = asked.to_s.strip.downcase
       served = served.to_s.strip.downcase
       return false if asked.empty? || served.empty?
+      return false if asked == served
+
+      shorter, longer = asked.length <= served.length ? [asked, served] : [served, asked]
+      return true unless longer.start_with?(shorter)
 
-      !(asked.start_with?(served) || served.start_with?(asked))
+      !longer[shorter.length..].start_with?(*EXTENSION_SEPARATORS)
     end
   end
 end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -237,6 +237,8 @@ module Samagotchi
           end_turn
           own_turn_ended(event)
         when :prompt_restored then restore_prompt(event)
+        # The after_turn hooks are done (their notices came before it).
+        when :answer_display then @display_pending = false
         when :context_status, :used_memories_updated then @status.take_event(event)
         # Another client's anytime command: its line now, before the cards
         # it shows (its command_ran comes when it's done).
@@ -580,9 +582,10 @@ module Samagotchi
         @screen.commit("could not send the prompt (#{worker_down(e)})")
       end
 
-      # Whether the input's end must wait: the -p prompt isn't sent yet, or
-      # a prompt this run sent hasn't had its turn.
-      def own_turns_pending? = !@first_prompt.to_s.strip.empty? || !@open_ids.empty?
+      # Whether the input's end must wait: the -p prompt isn't sent yet, a
+      # prompt this run sent hasn't had its turn, or its turn's after_turn
+      # hooks still run (their notices, source-links' sources:, come next).
+      def own_turns_pending? = !@first_prompt.to_s.strip.empty? || !@open_ids.empty? || @display_pending == true
 
       # A turn ended: this run's prompt (and ours merged into it) had its turn.
       def own_turn_ended(event)
@@ -592,6 +595,8 @@ module Samagotchi
         ours = @open_ids.include?(id) || !@merged_ids.empty?
         @own_failed = true if ours && event[:type] == :turn_failed
         @own_empty = true if ours && event[:type] == :turn_completed && event.dig(:turn_summary, :empty_answer)
+        # The worker sends answer_display once its after_turn hooks ran.
+        @display_pending = true if ours && event[:type] == :turn_completed && event[:display_pending]
         @open_ids.delete(id)
         @open_ids.subtract(@merged_ids)
         @merged_ids.clear

data/lib/samagotchi/terminal_ui/one_shot_sink.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "formatting"
+require_relative "event_renderer"
+
+module Samagotchi
+  class TerminalUI
+    # The turn sink of `chi -p … --non-interactive` (Engine#run_turn's
+    # on_event): the few lines a reader wants while the turn runs, on
+    # stderr. stdout is the answer's alone, printed after the turn: a
+    # script or a parent agent reads it.
+    #
+    # It prints the retry lines the REPL shows: the loop asking again after
+    # an empty answer (:empty_answer_retry), and a generation retried after
+    # a failed request (:generation_retrying). And the hooks' notices
+    # (:hook_notice): one during the turn as it comes, one the after_turn
+    # hooks give (after :turn_completed; source-links' `sources:`) kept for
+    # #flush, which the caller runs after it has printed the answer.
+    class OneShotSink
+      include Formatting
+
+      # @param err [IO, nil] nil writes to $stderr as it is at each write
+      def initialize(err: nil)
+        @err = err
+        @turn_over = false
+        @held = []
+      end
+
+      def call(event)
+        case event[:type]
+        when :empty_answer_retry then line(format_empty_retry_line(event))
+        when :generation_retrying then line(format_generation_retry_line(event))
+        when :turn_completed, :turn_canceled then @turn_over = true
+        when :hook_notice
+          text = EventRenderer.hook_notice_line(event)
+          @turn_over ? @held << text : line(text)
+        end
+      end
+
+      # Print the notices that came after the turn's end.
+      def flush
+        line(@held.shift) until @held.empty?
+      end
+
+      private
+
+      def line(text)
+        err.puts(text)
+        err.flush
+      end
+
+      def err = @err || $stderr
+
+      # Colour when stderr, where the lines go, is a colour terminal.
+      def color_output?
+        return false unless err.tty?
+        return false if ENV.key?("NO_COLOR")
+
+        ENV.fetch("TERM", "") != "dumb"
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui.rb

@@ -30,6 +30,7 @@ require_relative "terminal_ui/input_support"
 require_relative "terminal_ui/image_input"
 require_relative "terminal_ui/plain_surface"
 require_relative "terminal_ui/live_region"
+require_relative "terminal_ui/one_shot_sink"
 require_relative "terminal_ui/question_prompt"
 require_relative "terminal_ui/repl_input"
 require_relative "terminal_ui/status_row"
@@ -210,7 +211,9 @@ module Samagotchi
     # follow-up REPL (--non-interactive) or drops into the REPL carrying the
     # post-turn conversation.
     # @return [Symbol, nil] :turn_failed when lines came from a pipe and a
-    #   turn failed (bin/chi exits 1)
+    #   turn failed, :empty_answer when a -p --non-interactive turn ended
+    #   with no answer (bin/chi exits 1 on both), :interrupted when Ctrl-C
+    #   cancelled that turn (bin/chi exits 130)
     def run
       # --non-interactive with no --prompt is a harmless no-op exit: build
       # nothing and return (no transient session, no banner).
@@ -240,25 +243,36 @@ module Samagotchi
       if @prompt && @non_interactive
         # Headless / CI mode: run directly without TTY rendering.
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
-        result = @engine.run_turn(
-          session,
-          @prompt,
-          on_event: nil,
-          max_iterations: IterationLimit.for(no_interrupt: true),
-          cancel_controller: nil,
-          images: ImageInput.extract(@prompt)
-        )
+        # Retry lines and hook notices on stderr; stdout gets the answer below.
+        sink = OneShotSink.new
+        begin
+          result = @engine.run_turn(
+            session,
+            @prompt,
+            on_event: sink,
+            max_iterations: IterationLimit.for(no_interrupt: true),
+            cancel_controller: nil,
+            images: ImageInput.extract(@prompt)
+          )
+        rescue LLM::ProviderError, ImageStore::Error => e
+          return one_shot_failed(session, e)
+        rescue Interrupt
+          return one_shot_interrupted(session)
+        end
         # No answer (the empty-answer retries used up): no text, or the chat
         # loop's placeholder (LLM::ModelResult#empty_answer?).
         if result.empty_answer?
-          # Nothing to print: say so on stderr and fail, so a script that
-          # pipes the answer doesn't take the silence for one.
+          # Nothing to print: say so on stderr and fail (bin/chi exits 1),
+          # so a script that pipes the answer doesn't take the silence for one.
           session.save
           warn EMPTY_ANSWER_ERROR
-          exit 1
+          sink.flush
+          return :empty_answer
         end
         @surface.commit(result.output)
         session.save
+        # The after_turn hooks' notices, after the answer as the REPL shows them.
+        sink.flush
         return
       end
 
@@ -286,6 +300,18 @@ module Samagotchi
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
+    # A -p --non-interactive turn that failed (bin/chi exits 1): the error,
+    # then how to go on. The Engine saved the failed turn with its prompt,
+    # so the session is kept and `chi --resume` takes it up again.
+    # @return [Symbol] :turn_failed
+    def one_shot_failed(session, error)
+      warn "Error: #{error.respond_to?(:summary) ? error.summary : error.message}"
+      if !@scratch && Session.exist?(session.id)
+        warn "chi: the session is kept with your prompt; continue it with: chi --resume #{session.id}"
+      end
+      :turn_failed
+    end
+
     # `chi -p "/models" --non-interactive`: the command's output; a refused
     # one fails the run (bin/chi exits 1). The session is saved only when
     # the command changed it.
@@ -302,6 +328,19 @@ module Samagotchi
       :turn_failed if result.status == :error
     end
 
+    # Ctrl-C in a -p --non-interactive turn: the Engine kept the prompt and
+    # a cancel note in the session (it saves only a failed turn), so save
+    # it here: `chi --resume` takes it up again. A scratch session goes in
+    # #run's ensure, so there is nothing to keep.
+    # @return [Symbol] :interrupted
+    def one_shot_interrupted(session)
+      return :interrupted if @scratch
+
+      session.save
+      warn "chi: canceled (Ctrl-C); the session is kept: continue it with chi --resume #{session.id}"
+      :interrupted
+    end
+
     # Delete the scratch session, the last thing the REPL does. Quiet after
     # a one-shot or on the way out of an error or a signal.
     def delete_scratch(session, quiet:)
@@ -400,19 +439,29 @@ module Samagotchi
       system_message = { role: "system", content: seed_system_prompt }
       if @resume_session
         messages = ContextNote.with_system_head(session.messages.dup, system_message)
-        @surface.commit("Resumed session: #{session.id}")
+        banner("Resumed session: #{session.id}")
         saved = @engine.saved_recap
-        @surface.commit(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved
+        banner(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved
       elsif @scratch
         messages = [system_message]
-        @surface.commit("Scratch session: nothing is kept, it is deleted when you leave.")
+        banner("Scratch session: nothing is kept, it is deleted when you leave.")
       else
         messages = [system_message]
-        @surface.commit("Session: #{session.id}")
+        banner("Session: #{session.id}")
       end
       messages
     end
 
+    # A line about the session, not the answer: on stderr in a
+    # --non-interactive run, whose stdout is the answer's alone (a script
+    # or a parent agent reads it), and before the turn, so it comes first.
+    def banner(text)
+      return @surface.commit(text) unless @non_interactive
+
+      $stderr.puts(text)
+      $stderr.flush
+    end
+
     # Interactive REPL loop. Session seed + messages are built by #run and
     # threaded in here (so --prompt / --resume share one code path). The
     # session's conversation is the single working copy: turns go through

data/lib/samagotchi/tool_declarations.rb

@@ -18,7 +18,7 @@ module Samagotchi
     TOOL_SCHEMAS = [
       {
         name: "execute",
-        description: "Run any shell command in a working directory (defaults to the project root) and see stdout, stderr, and exit code. Large output may be truncated to a head+tail preview with metadata.",
+        description: "Run any shell command in a working directory (defaults to the project root) and see stdout, stderr, and exit code. Large output may be truncated to a head+tail preview with metadata. Don't background with &; use task_create.",
         parameters: {
           type: "object",
           properties: {
@@ -153,7 +153,7 @@ module Samagotchi
       },
       {
         name: "task_create",
-        description: "Start a background task for a long-running shell command. Returns task id and output path for later inspection.",
+        description: "Start a background task for a long-running shell command. Servers and anything meant to keep running belong here, not in execute with &. Returns task id and output path for later inspection.",
         parameters: {
           type: "object",
           properties: {

data/lib/samagotchi/tools/execute.rb

@@ -21,6 +21,15 @@ module Samagotchi
       WAIT_SLICE_SEC = 0.2
       NOT_RUN_ON_STOP = "Error: not run, the user stopped the turn"
       TIMEOUT_HINT = "(killed at the limit; for a long command use task_create, then task_wait)"
+      # How long the output may stay open once the shell has exited: a
+      # `server &` child keeps the pipes, and the read would never end.
+      BACKGROUND_GRACE_SEC = 1.5
+      BACKGROUND_HINT = "(a background process kept the output open and was stopped; " \
+                        "to keep a server or long job running, start it with task_create)"
+      # It had left the process group (setsid), so it is still running.
+      BACKGROUND_DETACHED_HINT = "(a background process kept the output open and was left running; " \
+                                 "to keep a server or long job running, start it with task_create)"
+      READ_CHUNK_BYTES = 65_536
 
       def self.name        = NAME
 
@@ -35,7 +44,7 @@ module Samagotchi
         return "Error: cwd not found: #{resolved_cwd}" unless resolved_cwd
 
         timeout_sec = timeout_seconds
-        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled,
+        stdout, stderr, status, held_open = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled,
                                                       env: env)
 
         stdout_block = output_block("stdout", stdout)
@@ -50,6 +59,7 @@ module Samagotchi
         # model as "done, something happened".
         silent = stdout_block.nil? && stderr_block.nil?
         parts << (silent ? "exit: #{status.exitstatus} (no output)" : "exit: #{status.exitstatus}")
+        parts << (held_open == :detached ? BACKGROUND_DETACHED_HINT : BACKGROUND_HINT) if held_open
         parts.join("\n")
       rescue CommandTimedOut => e
         # Keep the "Error:" first line (callers classify on it), say how to run
@@ -75,13 +85,14 @@ module Samagotchi
         status = nil
         timed_out = false
         was_cancelled = false
+        aborted = false
+        held_open = false
         started = monotonic_time
         deadline = started + timeout_sec
 
         Open3.popen3(env || {}, command, chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
           stdin.close
-          stdout_reader = reader_thread_for(stdout)
-          stderr_reader = reader_thread_for(stderr)
+          readers = [OutputReader.new(stdout), OutputReader.new(stderr)]
 
           begin
             until wait_thr.join(WAIT_SLICE_SEC)
@@ -100,36 +111,103 @@ module Samagotchi
             # An Interrupt (or anything else) mid-wait: the child is in its own
             # process group, so it never saw the SIGINT. Kill it, or the reads
             # below block until it closes stdout.
+            aborted = true
             terminate_process_tree(wait_thr.pid)
             raise
           ensure
-            # Read the buffered output before closing the pipes. For a process
-            # that exits almost instantly (e.g. `echo hello`), the background
-            # reader thread may not have scheduled its `io.read` yet; joining
-            # the reader after the pipe is closed would return "".
-            stdout_text = stdout_reader.value
-            stderr_text = stderr_reader.value
-            close_quietly(stdout)
-            close_quietly(stderr)
+            # The shell is gone, but a child it put in the background (`cmd &`)
+            # may still hold the pipes: wait for EOF a short grace only, then
+            # stop the command's process group and keep the output so far.
+            # Already stopped (timeout, Stop, an exception): no more checks.
+            stopping = timed_out || was_cancelled || aborted
+            outcome = await_readers(readers, until_time: monotonic_time + BACKGROUND_GRACE_SEC,
+                                             deadline: stopping ? nil : deadline,
+                                             cancelled: stopping ? -> { false } : cancelled)
+            unless outcome == :done
+              was_cancelled = true if outcome == :cancelled
+              timed_out = true if outcome == :timeout
+              stopped = stop_process_group(wait_thr.pid, readers)
+              held_open = (stopped ? :stopped : :detached) if outcome == :grace && !stopping
+            end
+            readers.each(&:finish)
+            stdout_text, stderr_text = readers.map(&:text)
           end
         end
 
         raise CommandTimedOut.new(stdout_text, stderr_text) if timed_out
         raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started) if was_cancelled
 
-        [stdout_text, stderr_text, status]
+        [stdout_text, stderr_text, status, held_open]
       end
       private_class_method :run_command
 
-      def self.reader_thread_for(io)
-        Thread.new do
-          Thread.current.report_on_exception = false
-          io.read.to_s
-        rescue IOError, EOFError
-          ""
+      # Waits for both readers to hit EOF until +until_time+, the overall
+      # +deadline+ or a Stop. Returns :done, :grace, :timeout or :cancelled.
+      def self.await_readers(readers, until_time:, deadline:, cancelled:)
+        loop do
+          return :done if readers.all?(&:done?)
+          return :cancelled if cancelled.call
+          return :timeout if deadline && monotonic_time > deadline
+          return :grace if monotonic_time > until_time
+
+          readers.find { |r| !r.done? }&.wait(STOP_POLL_INTERVAL_SEC)
+        end
+      end
+      private_class_method :await_readers
+
+      # The shell has exited (its pid is reaped) but its process group still
+      # has members holding the output: TERM the group, then KILL it. A process
+      # that left the group (setsid) is out of reach; the pipes get closed.
+      # True once the output was released, false if something still holds it.
+      def self.stop_process_group(pgid, readers)
+        signal_group(pgid, "TERM")
+        return true if await_readers(readers, until_time: monotonic_time + STOP_GRACE_SEC, deadline: nil,
+                                              cancelled: -> { false }) == :done
+
+        signal_group(pgid, "KILL")
+        await_readers(readers, until_time: monotonic_time + STOP_GRACE_SEC, deadline: nil, cancelled: -> { false }) == :done
+      end
+      private_class_method :stop_process_group
+
+      # Only the group: the leader's pid is reaped, so it may name another process.
+      def self.signal_group(pgid, signal)
+        Process.kill(signal, -pgid)
+      rescue Errno::ESRCH, Errno::EPERM
+        nil
+      end
+      private_class_method :signal_group
+
+      # Reads a pipe in chunks on its own thread, so the output read so far
+      # survives the pipe being closed under it.
+      class OutputReader
+        def initialize(io)
+          @io = io
+          @buffer = String.new(encoding: Encoding::BINARY)
+          @thread = Thread.new do
+            Thread.current.report_on_exception = false
+            loop { @buffer << io.readpartial(READ_CHUNK_BYTES) }
+          rescue EOFError, IOError
+            nil
+          end
+        end
+
+        def done? = !@thread.alive?
+
+        def wait(seconds) = @thread.join(seconds)
+
+        # Closes the pipe (a reader still blocked gets IOError) and ends the
+        # thread; the text is safe to read afterwards.
+        def finish
+          @thread.join(STOP_POLL_INTERVAL_SEC) unless done?
+          Execute.send(:close_quietly, @io)
+          @thread.kill unless @thread.join(STOP_GRACE_SEC)
+        end
+
+        def text
+          @buffer.dup.force_encoding(@io.external_encoding || Encoding.default_external)
         end
       end
-      private_class_method :reader_thread_for
+      private_constant :OutputReader
 
       def self.close_quietly(io)
         io.close unless io.closed?

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.18.0"
+  VERSION = "0.18.1"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.18.1
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -352,6 +352,7 @@ files:
 - lib/samagotchi/terminal_ui/input_support.rb
 - lib/samagotchi/terminal_ui/line_reader.rb
 - lib/samagotchi/terminal_ui/live_region.rb
+- lib/samagotchi/terminal_ui/one_shot_sink.rb
 - lib/samagotchi/terminal_ui/plain_surface.rb
 - lib/samagotchi/terminal_ui/question_prompt.rb
 - lib/samagotchi/terminal_ui/question_slot.rb