samagotchi 0.89.0 → 0.90.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7e58a54e40f49c1617636172def63d9e6a3eaa3384ac33e26c0b55c75332555
-  data.tar.gz: 063a36d57a613a117e62b2882883c22e1ce413044c1e6d18e66aa1c8af0d6d83
+  metadata.gz: 06240ded5e15bc55c7c3467bc7d5c0e79daecd5822291feebf72bbab6e6e6cb7
+  data.tar.gz: 52adfdbb519ba9bed3575d55abe737dbca654d81c3c213706a556b56742628af
 SHA512:
-  metadata.gz: 879572f97fd05fdff6f15d4c91c3f3ce30d480ff0022b1ad3fb0220423c124004c67908f97e85ad6309302720671938cc90da80c6315de0134c9240a9b477feb
-  data.tar.gz: 0faf651033f823e4eadc87926d4c370e3e8eb714a4f8106d735110bfe7c8517972a70a4e960448ccda3b8ac1679c796e93b587070255803eb57e24e8c984a2b1
+  metadata.gz: 33fdd1b34ce5e0840330451bb90675fe6fb9de6903d3569f3d8e6559e09cad004bcd40bfeec0e0468943d0b2d2abfce8a21d097152c86a53bd2cd332e0386437
+  data.tar.gz: 5b19168272d7de67413c480c59bbee363b14a0ba106cdc146632cfb03be45cc646367454758fcbe95aba7562926ab700620e839b2526e818875312f5453d413d

data/CHANGELOG.md

@@ -8,6 +8,22 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.90.0] - 2026-10-19
+
+### Changed
+
+- SSE `tool_call_started` carries no `call`, `turn_completed` no `result`; read `tool`/`params`/`view` and
+  `turn_summary.output`. `?raw=1` on the worker's stream shows them.
+- docs/bundle-authoring.md (the guide chi reads to write a bundle) makes edit → `check --fix` → `test` → `try` the
+  loop, with `install --dev .` while iterating and `try` as the live check; its test example runs as written.
+
+### Fixed
+
+- `chi -p` followed by one of chi's own flags (`chi -p --non-interactive "text"`, `-p -v`) now exits 2 with a usage
+  error instead of taking the flag as the prompt.
+
+Update with `chi update` (the system bundle 0.90.0), then restart `chi web`.
+
 ## [0.89.0] - 2026-10-19
 
 ### Added
@@ -3513,7 +3529,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.89.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.90.0...HEAD
+[0.90.0]: https://github.com/dm1try/samagotchi/compare/v0.89.0...v0.90.0
 [0.89.0]: https://github.com/dm1try/samagotchi/compare/v0.88.0...v0.89.0
 [0.88.0]: https://github.com/dm1try/samagotchi/compare/v0.87.0...v0.88.0
 [0.87.0]: https://github.com/dm1try/samagotchi/compare/v0.86.0...v0.87.0

data/bin/chi

@@ -74,6 +74,7 @@ options = { verbose: false, no_interrupt: Samagotchi::Config.get("no_interrupt")
 cli_overrides = {}
 
 # Strict kebab enforcement: --recap_base_url is unknown (OptionParser would otherwise accept _ as -)
+known = %w[--prompt --resume --attach --shared --no-shared --model --thinking --toolkit --tool --no-tool --set --parent-answers --memory --mute --append-system-prompt --llm-context --llm-context-apply --llm-context-budget --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token] + Samagotchi::Config.cli_entries.map(&:cli_flag)
 ARGV.each do |arg|
   next unless arg.start_with?("--") && arg.include?("_")
 
@@ -82,7 +83,6 @@ ARGV.each do |arg|
   base = arg.split("=", 2).first
   # If dashed version is a known flag (registry or hardcoded), reject underscore variant
   dashed = base.tr("_", "-")
-  known = %w[--prompt --resume --attach --shared --no-shared --model --thinking --toolkit --tool --no-tool --set --parent-answers --memory --mute --append-system-prompt --llm-context --llm-context-apply --llm-context-budget --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token] + Samagotchi::Config.cli_entries.map(&:cli_flag)
   if known.include?(dashed) || known.include?(base)
     warn "Unknown option: #{arg} (did you mean #{dashed}?)"
     exit 1
@@ -191,8 +191,33 @@ end
 # value (-p, --model …: the parser's own list) keeps its next word, so
 # `chi -p "--no-tool=x is broken"` is a prompt. A tool name never starts
 # with "-": `--no-tool --` or `--no-tool --model` is a missing argument.
-takes_value = parser.instance_variable_get(:@stack).flat_map do |list|
-  list.list.select { |switch| switch.is_a?(OptionParser::Switch::RequiredArgument) }.flat_map { |switch| switch.long + switch.short }
+switches = parser.instance_variable_get(:@stack).flat_map { |list| list.list }
+                                          .select { |switch| switch.is_a?(OptionParser::Switch) }
+switch_flags = switches.flat_map { |switch| switch.long + switch.short }
+known_flags = (known + switch_flags).uniq
+takes_value = switches.select { |switch| switch.is_a?(OptionParser::Switch::RequiredArgument) }
+                      .flat_map { |switch| switch.long + switch.short }
+reject_prompt_flag = lambda do |flag, value|
+  if known_flags.include?(value)
+    warn "Error: #{flag} needs the prompt text right after it (got the flag #{value}) (see chi --help)"
+    exit 2
+  end
+end
+index = 0
+while index < ARGV.size && ARGV[index] != "--"
+  arg = ARGV[index]
+  if %w[-p --prompt].include?(arg)
+    reject_prompt_flag.call(arg, ARGV[index + 1])
+    index += 2
+  elsif arg.start_with?("--prompt=")
+    reject_prompt_flag.call("--prompt", arg.delete_prefix("--prompt="))
+    index += 1
+  elsif arg.start_with?("-p") && arg != "-p"
+    reject_prompt_flag.call("-p", arg.delete_prefix("-p").delete_prefix("="))
+    index += 1
+  else
+    index += takes_value.include?(arg) ? 2 : 1
+  end
 end
 missing_no_tool = lambda do
   warn "Error: missing argument: --no-tool (see chi --help)"

data/docs/architecture.md

@@ -187,10 +187,15 @@ higher-level events so UIs get clean turn boundaries without inferring them:
   model's thinking, `0` = never; plus `continue: true` for a continue turn, `resumed: true` for a step-limit Continue,
   `images:` with the prompt's image refs)
 - `:turn_completed` — `{ result:, turn_summary:, display_pending: }` (`result`: the final
-  `LLM::ModelResult`; `display_pending`: `after_turn` hooks may still present the answer)
+  `LLM::ModelResult`; Engine event (clients get it without `result`); `display_pending`: `after_turn` hooks may still
+  present the answer)
 - `:turn_canceled` — `{ cancellation_reason:, cancelled_by:, duration_ms: }` (`cancelled_by`: the bundle or hook label that
   stopped it, for `cancellation_reason: :hook`; else nil)
 
+These are the Engine's raw events. The worker's SSE projection omits `call` from
+`:tool_call_started` and `result` from `:turn_completed`; the answer remains in
+`turn_summary.output`.
+
 A turn started with `origin:` carries it on each of these (and `:turn_failed`).
 
 Every event is a `Hash` with a `:type` symbol key; the sink must not raise (the Engine
@@ -246,7 +251,8 @@ process that already owns the `Engine`); every worker starts it, and it exposes:
   `session_state_snapshot`. `?snapshot=1` joins with a snapshot frame instead of a replay;
   `?client_id=` names whose stream it is (`Bridge#open_streams_except`, used by `POST /exit`).
   Each event goes out as clients get it (`Bridge::ClientEvent.project`, in `SSEWriter#write_event`, live
-  and replayed alike); only a `generation_chunk` changes, to chi's own format (the chunk contract below).
+  and replayed alike); `generation_chunk`, `tool_call_started` and `turn_completed` are projected to the
+  contracts below. The ring retains raw events for replay and `?raw=1`.
   `?raw=1` writes events as the engine emitted them, for debugging on the worker's port: `chi web`'s
   `/api/sessions/:id/stream` never passes it on (`Web::App#stream_query`).
   An attached terminal's stream (`EventStream` with `rediscover:`) looks for the session's live
@@ -265,6 +271,22 @@ process that already owns the `Engine`); every worker starts it, and it exposes:
          "event_seq":812}
   ```
 
+  A `tool_call_started` frame keeps its row fields but omits the model's `call`:
+
+  ```
+  event: tool_call_started
+  data: {"type":"tool_call_started","iteration":2,"call_index":1,"tool":"write",
+         "params":"path=notes.txt","event_seq":812}
+  ```
+
+  A `turn_completed` frame omits `result`; `turn_summary.output` carries the answer:
+
+  ```
+  event: turn_completed
+  data: {"type":"turn_completed","turn_summary":{"output":"Done."},
+         "display_pending":false,"event_seq":813}
+  ```
+
   `counts` is `ContextUsage.normalize` of the provider's payload without `ctx_pct` (normalize computes it
   without the session's LLM context budget; a client counts `total_tokens` against the window or budget, as
   `ContextStatus#generation_done` does for the TUI) and with its nil keys left out: cumulative for the

data/docs/bundle-authoring.md

@@ -9,23 +9,22 @@ files, what a hook sees, how to test, and what goes wrong. The full references a
 ```
 chi bundle new my-bundle     # ./my-bundle: manifest.yml, plugin.rb, test/my_bundle_test.rb, README.md
 cd my-bundle                 # edit plugin.rb and the test
-chi bundle test              # the tests, on chi's own Ruby and lib (exit status: the tests')
+chi bundle install --dev .   # once while iterating: link this folder; edits load in the next session
 chi bundle check --fix       # manifest, files, shas (--fix rewrites them), requires_chi, install + load in a sandbox
+chi bundle test              # tests on chi's own Ruby and lib (exit status: the tests')
 chi bundle try . -p "Say hello"  # one real model turn; trace the bundle in an isolated install sandbox
-chi bundle install .         # into the user's chi; a NEW session loads it (a running one doesn't)
-chi bundle install --dev .   # or as a link to this folder: edits apply at the next session, no re-install
+chi bundle uninstall my-bundle && chi bundle install .  # at the end: leave dev mode, copy it in
 ```
 
-While you write it, `install --dev .` (once; `uninstall NAME` leaves dev mode) then try it in chi: a new session
-loads the plugin and hooks from the folder as they are, with no sha check (that bundle only; memories are copied).
-Re-install with `--force` from the same PATH to pick up memory edits.
-Dev-linked scripts aren't chmodded, since that would change the source. Chi warns with a `chmod +x PATH/scripts/x`
-hint when a listed script isn't executable; set that bit on the source script.
+The loop is **edit → `check --fix` → `test` → `try`**. `install --dev .` links the folder once, so a new session
+loads your edits with no reinstall (a running one doesn't; `try` doesn't need the link: it installs into its own
+sandbox). Memories are copied: re-install with `--force` from the same PATH to pick up memory edits. At the end,
+`uninstall NAME` leaves dev mode and a plain `install .` copies the bundle in (chi refuses it over a dev link).
+Dev-linked scripts aren't chmodded: chi warns with a `chmod +x PATH/scripts/x` hint; set the bit on the source.
 
-`check` prints one finding per line, `error|warn|info CODE file[:line]: message (fix: hint)`, and exits 1 on any
-error. Run it after every edit: an install takes exactly what it checks. It installs into a temp sandbox, not
-the user's config or state, but `check` and `test` run the bundle's plugin and hooks in their own process, as
-written: run them on code you'd install.
+`check` prints one finding per line (`error|warn|info CODE file[:line]: message (fix: hint)`), exits 1 on any error
+and installs into a temp sandbox, not the user's config or state; run it after every edit. `check` and `test` run
+the bundle's plugin and hooks in their own process, as written: run them on code you'd install.
 
 ## Trying a bundle
 
@@ -87,29 +86,36 @@ that list is never fired (`check` warns). The two a bundle wants most, for an `e
 Match on `result:`, not `output:`. An execute's result is its `stdout:` and `stderr:` blocks (each left out when
 empty), then `exit: N` (`exit: 0 (no output)` when both were empty); a non-zero exit makes `status:` `"error"`.
 Act through `ctx`: `ctx.notify(text, level: :warn)`, `ctx.steer(text)` (a line the model reads before its next
-step), `ctx.card(…)`, `ctx.stop_turn(reason)`, `ctx.ask_user(…)`, `ctx.data_dir` (the bundle's own folder),
+step), `ctx.card(…)`, `ctx.stop_turn(reason)`, `ctx.ask_user(…)`, `ctx.data_dir` (the bundle's state folder),
 `ctx.cwd`, `ctx.log`. In a test, each recorded notice, steer or stop names its hook as `"plugin.rb (bundle
 my-bundle)"`, the plugin's label (a `hooks/x.rb` file's is `"x.rb (bundle my-bundle)"`).
 
 ## Testing it
 
-`chi bundle new` writes a Minitest test that passes as written: copy its shape. The kit (`samagotchi/testing`)
-loads the bundle's source through chi's own loaders, in a sandbox (temp HOME, config and state), and records what
-it did at chi's edges:
+`chi bundle new` writes a Minitest test that passes as written: copy its shape. The kit (`samagotchi/testing`) loads
+the bundle's source through chi's own loaders in a sandbox (temp HOME, config and state) and records what it did:
+`load_bundle`, then `bundle.command` / `bundle.fire`, and the effects in `bundle.notices`. `bundle.ctx.data_dir` and
+`sandbox.state_dir` are that test's temporary state, never the user's (the scaffold's plugin, tested):
 
 ```ruby
-bundle = load_bundle(BUNDLE, settings: { "greeting" => "hi" })   # in a Samagotchi::Testing::Case test
-bundle.command("/my-bundle chi")                     # → what the command returned
-bundle.fire(:after_tool_call, tool: "execute", status: "error", result: "exit: 1 (no output)", call: { … })
-bundle.tool_call({ name: "execute", content: "rm -rf /" }).deny?   # before_tool_call hooks, through the real gate
-bundle.tool("my_tool", path: "a.txt")                # a chi.tool, as the model calls it
-bundle.notices, bundle.steers, bundle.cards, bundle.stops, bundle.questions   # what it did
-bundle.answer({ selected: "yes" }); bundle.model_answers << "text"           # ask_user / ask_model answers
-bundle.http.stub(:get, "https://api.example/x", json: { ok: true })          # ctx.http, never the network
-bundle.set(cwd: dir, running: false); sandbox.config(hash); sandbox.fake_executable("gh", "echo '{}'")
-bundle.install                                        # installed as chi installs it: warnings, load failures
+require "minitest/autorun"
+require "samagotchi/testing/minitest"
+
+class MyBundleTest < Samagotchi::Testing::Case
+  def test_command_and_failed_execute_notice
+    bundle = load_bundle(File.expand_path("..", __dir__), settings: { "greeting" => "hi" })
+    assert_equal "hi, there", bundle.command("/my-bundle")
+    bundle.fire(:after_tool_call, tool: "execute", status: "error", call: { name: "execute", content: "false" },
+                                  result: "exit: 1 (no output)", output: "[execute]\nexit: 1 (no output)")
+    assert_equal "the command exited 1", bundle.notices.last.text
+    assert_equal File.join(sandbox.state_dir, "plugins", bundle.name), bundle.ctx.data_dir
+  end
+end
 ```
 
+`bundle.tool_call` runs guarded hooks; `bundle.tool` calls a registered tool. `bundle.steers`, `cards`, `stops` and
+`questions` record effects; `bundle.answer` / `model_answers` provide `ask_user` / `ask_model` answers.
+`bundle.http.stub` stubs `ctx.http`; `sandbox.config`, `sandbox.fake_executable` and `bundle.install` cover setup.
 The full list is in [plugins.md, Testing a bundle](plugins.md#testing-a-bundle-experimental). The kit is
 experimental (it may change before chi 1.0). If a test needs a fake of chi's own (a stub of a `Samagotchi::`
 class, a hand-built `ctx`), that is a gap in the kit: say so to the user rather than reaching into chi.
@@ -132,7 +138,7 @@ class, a hand-built `ctx`), that is a gap in the kit: say so to the user rather
 
 ## Verifying it live
 
-After `chi bundle install .`, one real session shows it works with the user's chi:
+`chi bundle try . -p "Say hello"` is the live check (trace, plugin, notices); after the final install, check the copy:
 
 ```
 chi send --new --wait --format json --dir /tmp/try -m "/my-bundle chi"   # the JSON names the session id

data/docs/internals/engine.md

@@ -489,12 +489,12 @@ Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):
 | `:thinking_refused` / `:reasoning_history_refused` | the chat loop asked a step again without the thinking fields / the reasoning sent back; the Engine logs it and makes a once-per-session-and-host `:hook_notice` of it, the event itself never reaches the sink | `{iteration, model, level, detail}` |
 | `:pending_input_merged` | queued input joined the conversation | `{iteration, count, content, steers?, answer}` |
 | `:tool_dispatch_started` / `:tool_dispatch_completed` | around a batch | `{iteration, call_count}` |
-| `:tool_call_started` | before a call runs | see ToolRunner |
+| `:tool_call_started` | before a call runs | Engine event includes `call` (see ToolRunner); the Bridge's SSE frame omits it |
 | `:tool_call_completed` | after a call ran | see ToolRunner |
 | `:used_memories_updated` | a memory was read, and after the loop | `{used_memory_names, read_names?}` |
 | `:hook_notice` | a hook's or plugin's notify during a turn | `{hook, text, level}` (announced with `between_turns: true` outside a turn) |
 | `:guardrail_warning` | a guardrails line during a turn | `{message}` |
-| `:turn_completed` | normal end | `{result, turn_summary, display_pending}` |
+| `:turn_completed` | normal end | Engine event `{result, turn_summary, display_pending}`; the Bridge's SSE frame omits `result` (answer remains in `turn_summary.output`) |
 | `:turn_canceled` | Stop, hook stop, Ctrl-C | `{cancellation_reason, cancelled_by?, duration_ms}` |
 | `:turn_failed` | an error | `{error_class, message, duration_ms, error_kind?, retryable?, host?, summary?}` |
 | `:answer_display` | after the after_turn hooks (observers only, not the sink) | `{display, refs?}` (display a string, or nil; refs the count of the answer's refs, only when a hook attached some) |

data/lib/samagotchi/bridge/client_event.rb

@@ -10,8 +10,10 @@ module Samagotchi
     # the provider's raw `payload`, and no raw `content` (the chat loop's is
     # reasoning + content again, the native loop's the raw stream with its
     # tool-call bytes and thought tags): clients read `text`, `thinking`,
-    # `tool_call` and `counts`, never a provider's payload shape. `?raw=1` on
-    # the worker's stream skips this (debugging).
+    # `tool_call` and `counts`, never a provider's payload shape.
+    # :tool_call_started omits the model's `call`; clients render its row from
+    # the other fields. :turn_completed omits `result`; `turn_summary.output`
+    # carries the answer. `?raw=1` on the worker's stream skips this (debugging).
     #
     # Pure: the event is the one hash SessionObserver hands every observer
     # (the ring, TurnAccumulator, the other writers, SessionMetrics, hooks),
@@ -28,13 +30,19 @@ module Samagotchi
       # @param event [Hash] the engine's event (symbol keys; its payload has
       #   string keys)
       # @return [Hash] the event as clients get it: a copy for a
-      #   :generation_chunk, the same object for every other event
+      #   projected event, the same object for every other event
       def project(event)
-        return event unless event.is_a?(Hash) && event[:type].to_s == "generation_chunk"
+        return event unless event.is_a?(Hash)
 
-        projected = event.except(:payload, :content)
-        found = counts(event[:payload])
-        found ? projected.merge(counts: found) : projected
+        case event[:type].to_s
+        when "generation_chunk"
+          projected = event.except(:payload, :content)
+          found = counts(event[:payload])
+          found ? projected.merge(counts: found) : projected
+        when "tool_call_started" then event.except(:call)
+        when "turn_completed" then event.except(:result)
+        else event
+        end
       end
 
       # The payload's normalized counts, nil keys left out; nil when the

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

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

data/lib/samagotchi/llm/model_result.rb

@@ -4,8 +4,8 @@ module Samagotchi
   module LLM
     # Normalized result returned by every ModelBackend downstream of the agentic
     # loop (the loop lives inside the backend). What Engine#run_turn and the
-    # renderers (TerminalUI / Bridge) read: .output (= .text, and .to_s, which
-    # is how the :turn_completed `result:` reaches JSON), .conversation,
+    # renderers (TerminalUI / Bridge) read: .output (= .text, and .to_s: the
+    # Engine's :turn_completed `result:`; clients get turn_summary.output), .conversation,
     # .canceled?, .cancellation_reason, .exhausted?, .resumable?,
     # .empty_answer?, plus the native loop's .tool_activity, .context_status
     # and .pending_tool_calls, which the interactive renderer needs.

data/lib/samagotchi/tool_runner.rb

@@ -76,6 +76,7 @@ module Samagotchi
       call = verdict.call
       params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
       label = plugin_label(call[:name])
+      # Kept on the raw event for in-worker hooks and metrics, not sent to SSE clients.
       started = { type: :tool_call_started, iteration: iteration, call_count: call_count, call_index: call_index,
                   tool: call[:name], call: call.dup, params: params }
       started[:label] = label if label

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/public/turn_events.js

@@ -3,15 +3,11 @@
 
 import { ACTIVITY_FIELDS, EVENT_FIELDS, pickFields } from "./activity.js";
 
-// The answer text of a :turn_completed event. `turn_summary.output` is the
-// contract; `result` is the KernelLoop result, which reaches the wire as its
-// string form (older servers, other clients' fixtures).
+// Read turn_summary.output; Bridge::ClientEvent omits result for clients.
 export function turnOutput(data) {
   if (!data) return "";
-  const summary = data.turn_summary?.output;
-  const result = typeof data.result === "string" ? data.result : data.result?.output;
-  const out = [summary, result, data.content, data.output].find((v) => typeof v === "string" && v.trim());
-  return out ? out.trim() : "";
+  const output = data.turn_summary?.output;
+  return typeof output === "string" ? output.trim() : "";
 }
 
 // The end line for a turn whose worker went away mid-turn (the footer's

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.89.0
+  version: 0.90.0
 platform: ruby
 authors:
 - Dmitry Dedov