samagotchi 0.81.0 → 0.82.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0e5c6acd4a2774291e421b71b7b5729b0e3031c9afaa46715f40a1d976ebed2
-  data.tar.gz: 6390322560ddd65a847ea4d3a122b3751be778c40eb573d457c617880daa0e06
+  metadata.gz: 02be0edba759be799428a67ac174beba8a77c2869f3de8f677dec9a14977ae60
+  data.tar.gz: d28e0688aec5428264fc7a48162a7f4e03ea461371cc48aba4da3c64ecf2e9d8
 SHA512:
-  metadata.gz: c1d209965a45e687b89280cbcecfe0b51798dcff1a418837b3604f4b3b1e69e8d0f210d8b4972c84912e274c7f738c322a2270af36833fe17049e999081a2705
-  data.tar.gz: 9c5d2a4e2205da68d70d99db385ab3f79ebec1f83f8762baaf36d3ae466fc98204c68bcd93ab1868127e703f5d50eaed0dd363ac910541849298c3bbc72bb931
+  metadata.gz: 1df47ccd973923c62848fef02807f3982ede1b86ebf032425c1ecd311014103286803822a290b24f117d705e3e8f845b22cb4804e90cc731a8dd48a3946a3b6f
+  data.tar.gz: 3c901380929266d60c820ebba9ad3581bdb4392f498fbb43dcef6ba157e675c100a8dba752ee27a79d464692ffb0a407b75ead89961f38c89e6551bf8a9a6ada

data/CHANGELOG.md

@@ -8,6 +8,32 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.82.0] - 2026-10-18
+
+### Added
+
+- `chi send --wait --format json` names the turn it waited for (`turn_id`), and `chi send --wait --turn T ID` waits
+  for exactly that turn: running, queued or the last one that ended. A parent waiting again after exit 3 or 4 uses it
+  (docs/sub-agent.md).
+- Bundles: the experimental test kit's `before_tool_call_event` builds the real guardrail event without firing
+  bundle hooks.
+
+### Fixed
+
+- `chi send --wait ID` with no message, on an idle session whose last turn already ended, returns that turn (its
+  reply, or its end when it left none) instead of timing out `running`.
+- Web: a question or approval card arriving in the stage no longer snaps the stage to it; the stage eases it into
+  view.
+- Guardrails: `rm` and protected-path checks treat a `$(cat <<'EOF' … EOF)` commit or PR message as data; a
+  substitution that runs, a piped message and a real command beside it are still checked.
+- A late side request (an idle recap, `ctx.ask_model`) after the engine moved to another session no longer recreates
+  the deleted old session's folder.
+- HTTP: failed-request messages in the log are one short UTF-8 line.
+- Bundles, test kit: one `HookFailed` names every hook that failed; the boundary scan catches a `require_relative`
+  into chi's `lib/`; `before_tool_call_event` says when the guardrails didn't dispatch the event.
+
+Update with `chi update` (the system bundle 0.82.0), then restart `chi web`.
+
 ## [0.81.0] - 2026-10-18
 
 ### Added
@@ -3338,7 +3364,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.81.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.82.0...HEAD
+[0.82.0]: https://github.com/dm1try/samagotchi/compare/v0.81.0...v0.82.0
 [0.81.0]: https://github.com/dm1try/samagotchi/compare/v0.80.0...v0.81.0
 [0.80.0]: https://github.com/dm1try/samagotchi/compare/v0.79.0...v0.80.0
 [0.79.0]: https://github.com/dm1try/samagotchi/compare/v0.78.0...v0.79.0

data/docs/cli.md

@@ -18,7 +18,7 @@
 - `chi sessions list|stop|restart|archive|unarchive|delete|prune|clean|stats` — manage persisted sessions; `list` shows this git project's, `list --scope=all` every one, a delegated session with `↳ <parent>`, `list --archived` the archived ones too (see [Sessions](sessions.md)). `stats ID` prints a session's cost, tokens and progress (a live worker's `GET stats`, else its saved `analytics.json`; `--format json` one object) without running a model turn. A usage error (an unknown subcommand or flag, a flag missing its value, `stop`, `restart` or `delete` with no ids, a bad `list --format` or `--scope`, a `--days`, `--keep` or `--limit` that isn't a whole number) exits 2; an unknown or refused session exits 1
 - `chi note [--source NAME] [-m TEXT] (ID|PREFIX)... | --all` — add a context note (TEXT or stdin) to sessions: background the model sees on its next turn; it starts no turn (see [Sessions: Context notes](sessions.md#context-notes))
 - `chi context <add|push|ls|show|refresh|rm|mute|unmute> …` — attach live external text to sessions (a command chi runs every so often, or text pushed in); the model gets a short note when it changes and reads it with `context_read`; `chi context add <URL>` attaches a GitHub PR with the github-pr bundle (see [Attached context](context.md))
-- `chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...` — send a message to sessions as if typed there: a turn starts (or a running one takes it at its next step; `--cut` asks it to cut long thinking for it; `--queue` runs it as a turn of its own after the running one, and `--queue --wait` waits for that turn's own answer); piped stdin goes above `-m` as quoted context, and `--image` attaches images (see [Sessions: Sending a message](sessions.md#sending-a-message)); `--new` starts a session with it instead (`--new --continues ID|last:ID` the next link of that session's chain, see [Session chains](sessions.md#session-chains)), and `--wait` prints the answer (`--wait ID` with no message waits for the next reply without sending; `--format json` prints one JSON object instead; exit 3 a question waits, its options on stderr; exit 4 `--timeout` passed with the turn still running; see [Starting a session](sessions.md#starting-a-session))
+- `chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...` — send a message to sessions as if typed there: a turn starts (or a running one takes it at its next step; `--cut` asks it to cut long thinking for it; `--queue` runs it as a turn of its own after the running one, and `--queue --wait` waits for that turn's own answer); piped stdin goes above `-m` as quoted context, and `--image` attaches images (see [Sessions: Sending a message](sessions.md#sending-a-message)); `--new` starts a session with it instead (`--new --continues ID|last:ID` the next link of that session's chain, see [Session chains](sessions.md#session-chains)), and `--wait` prints the answer (`--wait ID` with no message waits for the next reply without sending — to an idle session whose last turn already ended, that ended turn's reply or end comes back; `--wait --turn T ID` with no message waits for exactly turn T, whether running, queued or last ended; `--format json` includes its `turn_id` when known, for waiting again after exit 3 or 4; exit 3 a question waits, its options on stderr; exit 4 `--timeout` passed with the turn still running; see [Starting a session](sessions.md#starting-a-session))
 - `chi answer ID --question QID (--option N|LABEL)... [--text T] [--timeout S] [--format json]` (or `--dismiss`) — answer the question a session waits on (the one `chi send --wait` exited 3 with), then wait and print what comes next as `chi send --wait` does: the reply (0), the next question (3), still running after `--timeout` (4). `--option` is 1-based or the label, repeated on a multi-select question; `--text` is free text, or a Deny's reason; `--dismiss` leaves it unanswered and the model finishes its reply. A question no longer open (the web answered first) isn't answered again: it waits for that turn's reply. An option the question doesn't offer exits 2; a worker that is gone exits 1 (`send the task again: chi send --wait -m "…" ID`). An approval can be denied, not allowed, unless `guardrails.parent_approvals: once` (a convention, not a security boundary; see [Guardrails](guardrails.md#approvals-from-a-parent-agent))
 - `chi desktop install|upgrade|uninstall|status` — the macOS "Send to chi" helper: a Service and a ⌃⌥⌘N hotkey that send text or images to a session (live, stopped or new) as a message (⏎, a turn runs) or a context note (⌘⏎) (see [Desktop helper](desktop.md))
 - `chi models [--format text|json] [--timeout S] [TEXT]` — list the models every configured host offers, as the names `--model` takes (see [Listing the models](#listing-the-models))

data/docs/configuration.md

@@ -575,7 +575,8 @@ hosts:
 - A server that sends no cached counts has its whole prompt priced at `input`: an overestimate.
 - Side requests (the idle recap, `/btw`, a plugin's `ctx.ask_model`) are priced by the same rule from the price of
   the model they asked on its host: the recap's host and model (`recap.*`, else the session's), `ask_model(model:)`'s
-  host. They count on `/stats`' own `side requests:` line, never in the session's `cost:`.
+  host. A recap using only `recap.base_url` has no host price. They count on `/stats`' own `side requests:` line,
+  never in the session's `cost:`.
 
 ## Thinking
 

data/docs/plugins.md

@@ -1134,6 +1134,7 @@ require "samagotchi/testing"
 bundle = Samagotchi::Testing::Bundle.load("path/to/my-bundle", settings: { "every" => 3 },
                                           host: { session_id: "s1", cwd: Dir.pwd })
 bundle.fire(:after_turn, status: "completed")            # → the event, after the hooks
+event = bundle.before_tool_call_event({ name: "read", path: "a.txt" }, params: "read a.txt")
 bundle.command("/mine stop")                             # → what the command returned
 bundle.tool("my_tool", path: "a.txt")                    # → the text the model reads
 verdict = bundle.tool_call({ name: "execute", content: "rm -rf /" })

data/docs/sessions.md

@@ -208,7 +208,7 @@ chi send --new --continues last:3fa2 -m "new day"      # the next link of 3fa2's
 - `--wait` takes one session: `--new` or one id. A session with a running turn is refused (`busy: a turn is running; wait or attach`, exit 1): the message would merge into it, and its reply would come back as the answer. `--queue --wait` is the way in: the message runs as a turn of its own after the running one, and the wait is for that turn alone (the ack's `enqueued_id` names its reply file and its `last_turn`), so the running turn's reply and end, and a question it asks meanwhile, are not the answer (it keeps waiting through them; its `--timeout` still applies); a question its own turn asks is (exit 3). Two queued waits each get their own turn's answer. A session waiting for an answer is still refused. `--format json` adds `delivery`: `queue`, or `next_step` when the running turn ended before the message went in (it then ran at once, and the answer is still its own).
 - Exit codes with `--wait`: 0 answered; 3 the turn waits for an answer from you (a question, a hook's question, a guardrail approval, or the step-limit question: see [chi as a sub-agent](sub-agent.md#the-step-limit)), and the session keeps waiting: stderr gets the whole question (`waiting for an answer (approval): …`, its text, the numbered options, whether free text is allowed) and how to answer it (`chi answer ID --question QID --option N`, or `chi --attach ID`, the web); 4 `--timeout S` passed with the turn still running (it goes on; wait again); 1 the turn ended without a reply (canceled, failed or empty), the worker failed or vanished, or the session was stopped; 130 on Ctrl-C, which leaves the turn running (`still running: chi --attach ID`). There is no default timeout.
 - `--format json` (with `--wait`) prints one JSON object on stdout however the wait ends, for a script or a parent agent (see [chi as a sub-agent](sub-agent.md)): `{"status":"answered","session_id":…,"text":…}`; `{"status":"question",…,"question":{"id","kind","header","text","options","multi_select","allow_freeform","approval"},"answer_with":"chi answer ID --question QID --option N"}`, where `kind` is `question` (the model's), `hook` or `approval` (with the tool, command, cwd, rule, reason and offered scopes); `{"status":"running",…,"detail":…}` (exit 4, and on Ctrl-C); and `failed`, `canceled`, `no_answer`, `error`, `worker_gone` or `stopped` with a `detail` line (exit 1); `failed` adds `error_kind` and `retryable`, `canceled` adds `cancel_reason` and `stopped_by`, when known. A failure before the wait (no such session, a busy one) is `error` too. A usage error (exit 2) prints no JSON.
-- `--wait ID` with no message (no `-m`, nothing piped) sends nothing: it waits for the session's next reply and prints and exits as above. With a turn running, that turn's reply (its `interrupted_turn` mark names it), not a turn's queued behind it; with the step-limit question standing, the reply of the turn its Continue runs. With neither (or a worker whose `bridge.json` lacks `turn_ids`), the next reply of any turn. A running session is fine (that is the point), so after exit 3, 4 or 130 an agent waits again this way while the user answers in the web or `chi --attach`; the question pending when it starts doesn't count again. An idle session with no worker waits until something wakes one. With `--new`, or two ids, it is a usage error (exit 2).
+- `--wait ID` with no message (no `-m`, nothing piped) sends nothing: it waits for the session's next reply and prints and exits as above. With a turn running, that turn's reply (its `interrupted_turn` mark names it), not a turn's queued behind it; with the step-limit question standing, the reply of the turn its Continue runs; with an idle session whose last turn already ended, that ended turn is the answer: its reply, or its end when it left no reply — a turn that finished in the gap between waits is reported, not waited for. With none of those (or a worker whose `bridge.json` lacks `turn_ids`), the next reply of any turn. A running session is fine (that is the point), so after exit 3, 4 or 130 an agent waits again this way while the user answers in the web or `chi --attach`; the question pending when it starts doesn't count again. An idle session with no worker waits until something wakes one. With `--new`, or two ids, it is a usage error (exit 2).
 - `--continues ID` (with `--new`) starts the next link of that session's chain instead (see *Session chains*): in its folder, on its model (or the one `--model` names), LLM context, thinking level and toolkit, so `--dir`, `--llm-context*`, `--thinking`, `--toolkit`, `--tool` and `--no-tool` are refused beside it; `ID` may be a prefix or `last:ID`, the chain's latest link. Without a message the new link starts idle; `--wait` then has nothing to wait for (a usage error). It prints `<full id>  started (continues 3fa2c1d0)`, with `; 2 delegates moved` inside the parentheses when open delegates moved to it; a refusal (continued already, naming the next link; an open delegate that can't move; a turn running) is `chi send: refused: …`, exit 1, and a `--model` it can't start on is `chi send: could not start a session: …`, exit 1, nothing archived. A fallback to the default model (below) prints `chi send: warning: …`.
 - The 16 KiB cap applies: `git diff | chi send --new …` on a big diff is refused; name the branch in the message instead and let the session read it.
 - A session nobody attaches to stalls at its first question or guardrail ask until someone answers it (`chi answer`, the web, `chi --attach`), and its worker stays up meanwhile: it doesn't idle-exit while a question waits (`chi sessions list` shows it as `waiting`; `chi sessions stop ID` frees it). Otherwise it idle-exits after `session.idle_exit_minutes` like any worker. These are ordinary sessions: delete them like any other.

data/docs/sub-agent.md

@@ -30,6 +30,7 @@ sources](context.md#peer-sources-the-peer-loop).
 ```sh
 chi send --new --wait --format json [--dir D] [--model M] [--timeout S] -m "task"
 chi send --wait --format json [--timeout S] [-m "follow-up"] ID
+chi send --wait --format json [--timeout S] --turn T ID
 chi send --queue --wait --format json [--timeout S] -m "follow-up" ID
 chi answer ID --question QID (--option N|LABEL)... [--text T] [--timeout S] [--format json]
 chi answer ID --question QID --dismiss [--timeout S] [--format json]
@@ -60,6 +61,11 @@ Exit codes, both commands:
 
 With `--format json` stdout is one JSON object (see
 [Starting a session](sessions.md#starting-a-session) for every field):
+when the wait is about a known turn, it includes `turn_id`. Use
+`chi send --wait --format json --turn <turn_id> <session_id>` to wait for
+that exact turn again after exit 4, or after exit 3 if someone else will
+answer the question. A turn id can name the running turn, a queued turn or
+the last turn that ended; any other id is an error.
 
 ```json
 {"status":"question","session_id":"297da360-…","question":{"id":"3f1c…","kind":"question",
@@ -115,7 +121,7 @@ a parent may deny it (`--option Deny --text "why"`, `--text` alone, or
 and tell your user`. For an approval, the question block and `answer_with` give
 the deny command, not `--option N` or `chi --attach`. The block also offers to
 leave it open: tell your user it waits in chi web (the bell and badge show
-it there), and `chi send --wait --format json ID` (no message) waits until
+it there), and `chi send --wait --format json --turn <turn_id> ID` waits until
 they answer it. With
 `guardrails.parent_approvals: once` in chi's config.yml (it has no environment
 variable), "Allow once" goes through; the wider scopes never do,
@@ -161,7 +167,11 @@ answers from any local process.
 - `chi send --wait ID` with no message waits past a question already reported
   (the step-limit question too), until someone answers it. It waits for the
   turn running when it starts (or the one the step-limit question continues),
-  and prints that turn's reply, not a queued one's after it.
+  and prints that turn's reply, not a queued one's after it. To an idle
+  session whose last turn already ended (no question standing), that ended
+  turn is the answer: its reply comes back (`answered`), or its end when it
+  left no reply (`failed`, `canceled`, `limit`, …) — so a turn that finished
+  in the gap between waits is reported, not waited for.
 - An answer to a question that is no longer open (you answered it in the web
   first) isn't sent; `chi answer` says so and waits for what comes next. Its
   JSON then has `"answered_here": false` (absent when the answer went in), so
@@ -185,18 +195,19 @@ Start a task: `chi send --new --wait --format json --timeout 500 -m "<task>"`
   user, showing them the question and its options; if you can't ask (no user in
   this run), stop and report the question and options instead of guessing. To
   answer, run the `answer_with` command with `--option N` (1-based, repeat for
-  multi-select) and/or `--text "…"`. It returns the same JSON. If you won't
-  answer, add `--dismiss` instead: chi does nothing it asked about, finishes
-  with what it found, and the reply comes back (exit 0).
+  multi-select) and/or `--text "…"`. It returns the same JSON. If you leave it
+  open for someone else to answer, wait again with `--turn <turn_id>` from the
+  JSON. If you won't answer, add `--dismiss` instead: chi does nothing it asked
+  about, finishes with what it found, and the reply comes back (exit 0).
 - `question.kind: approval`: chi wants to run something its user's guardrails
   flagged, and allowing it is up to your user. Deny it (the `answer_with`
   command: `--option Deny --text "why"`), and tell your user what it wanted to
   run and why. Or leave it open: tell your user it waits in chi web (the
-  session's short id), then `chi send --wait --format json --timeout 500 <session_id>`
+  session's short id), then `chi send --wait --format json --timeout 500 --turn <turn_id> <session_id>`
   waits until they answer it there. Never allow it yourself, through
   `chi answer`, a piped `chi --attach` or chi's web API.
-- `status: running` (exit 4): still working. Wait again:
-  `chi send --wait --format json --timeout 500 <session_id>`.
+- `status: running` (exit 4): still working. Wait for that same turn again:
+  `chi send --wait --format json --timeout 500 --turn <turn_id> <session_id>`.
 - `question.kind: continue`: chi ran out of steps before it answered. If it is
   getting somewhere, continue it (`answer_with`, `--option Continue`, with
   `--text "…"` to steer it on the way); if not,

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

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

data/lib/samagotchi/cli/parent_wait.rb

@@ -62,19 +62,25 @@ module Samagotchi
       #   a --wait with no message is about (ReplyWait.own_turn)
       # @param queued [Boolean] +turn+ is a queued message's (ReplyWait's
       #   queued:)
+      # @param ended_before [Boolean] a last_turn that ended before the
+      #   baseline is the answer (ReplyWait's ended_before:) — the
+      #   --wait-with-no-message's settled session
+      # @param report_turn_id [String, nil] the turn id to include in the
+      #   report, even when ReplyWait uses the next-reply path
       # @return [Integer] the exit status
       def wait_for_reply(id, cursor:, baseline:, timeout:, owner_grace: self.class::WORKER_GONE_AFTER, turn: nil,
-                         queued: false)
+                         queued: false, ended_before: false, report_turn_id: turn)
         result = ReplyWait.call(id, state_dir: @state_dir, cursor: cursor, timeout: timeout, baseline: baseline,
                                     owner_grace: owner_grace, poll_interval: self.class::POLL_INTERVAL, turn: turn,
-                                    queued: queued)
+                                    queued: queued, ended_before: ended_before)
+        result.turn_id = report_turn_id if report_turn_id && !report_turn_id.to_s.empty?
         result.text = result.text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
         @reported = true
         ParentReport.report(result, session_id: id, stdout: @stdout, stderr: @stderr, command: command_name,
                                     json: @json, timeout: timeout, extra: report_extra)
       rescue Interrupt
         if @json
-          @stdout.puts(ParentReport.json_line(ReplyWait::Result.new(status: :canceled), session_id: id,
+          @stdout.puts(ParentReport.json_line(ReplyWait::Result.new(status: :canceled, turn_id: report_turn_id), session_id: id,
                                                                                         extra: report_extra))
           @stdout.flush
           @reported = true

data/lib/samagotchi/engine.rb

@@ -569,7 +569,7 @@ module Samagotchi
         block = @metrics.add_side(usage)
         @session_observer.notify(type: :side_usage, kind: usage.kind, side: block)
       end
-      sid = @session&.id
+      sid = @metrics.session_id
       return if sid.nil? || turn_running?
       return unless File.exist?(Session.session_file(sid, state_dir: session_state_dir))
 

data/lib/samagotchi/guardrails/rm_targets.rb

@@ -33,8 +33,10 @@ module Samagotchi
       # @param session_root [String] the session's repo root (or cwd)
       def outside_tmp?(command, cwd:, tmp_roots:, session_root:, home: Dir.home, env: ENV)
         tokens = ShellLex.lex(command.to_s)
-        # rm inside $(…) or backticks: the lexer keeps no body.
-        return true if tokens.any? { |_, value| value.include?(ShellLex::SUBST) } && command.to_s.match?(/\brm\b/)
+        # rm inside $(…) or backticks: the lexer keeps no body. A message
+        # heredoc's text is data, so leave it out of this fallback.
+        code = ShellLex.code_text(command.to_s)
+        return true if tokens.any? { |_, value| value.include?(ShellLex::SUBST) } && code.match?(/\brm\b/)
 
         session = ProtectedPaths.real(session_root.to_s)
         roots = tmp_roots.reject { |tmp| ShellPaths.within?(session, tmp) }

data/lib/samagotchi/guardrails/shell_paths.rb

@@ -16,8 +16,9 @@ module Samagotchi
     # A word it can't resolve (another $VAR, $(…), a glob, a relative path
     # after cd $X) or one that reads as a script (sh -c '…', ruby -e '…':
     # spaces, quotes, operators in it) falls back to a text match (+text+);
-    # so does the whole command when it holds a $(…) or backticks (the
-    # lexer keeps no body).
+    # so does the whole command when it holds a $(…) or backticks (the lexer
+    # keeps no body), except for message heredoc bodies ShellLex.code_text
+    # recognizes as data.
     module ShellPaths
       # A word that is a script rather than a path.
       SCRIPT = /[\s;&|<>()'"`]/
@@ -42,7 +43,8 @@ module Samagotchi
         roots = dirs.compact.map { |dir| ProtectedPaths.real(dir.to_s.chomp("/")) }.reject(&:empty?).uniq
         walk = Walk.new(cwd, home, env)
         tokens = ShellLex.lex(command.to_s)
-        return true if tokens.any? { |_, value| value.include?(ShellLex::SUBST) } && command.to_s.match?(text)
+        code = ShellLex.code_text(command.to_s)
+        return true if tokens.any? { |_, value| value.include?(ShellLex::SUBST) } && code.match?(text)
 
         ShellLex.simple_commands(tokens).any? do |words|
           walk.step(words).any? { |word, path| path ? names?(path, roots, tmp_roots) : word.match?(text) }

data/lib/samagotchi/idle_client.rb

@@ -187,13 +187,8 @@ module Samagotchi
       raise SummarizeError, "server returned no parseable assistant content (#{e.message})"
     end
 
-    # The request's token counts and reported cost (a broadcast's triage
-    # has no session to count them in). The cache counts show whether the
-    # host reused a cached prefix. A side request evicts a session's cached
-    # prompt only on a llama.cpp with no host-memory cache (--cache-ram 0)
-    # or an old single-slot build, or when pinned to the session's slot,
-    # which chi never does; paid hosts and current llama.cpp aren't
-    # affected (docs/internals/prompt-caching.md).
+    # Log reported request usage when cache counts are present; session
+    # side-usage counting is handled separately by #report_usage.
     def log_usage(response, kind)
       usage = response.usage
       fields = usage&.cache_fields || {}

data/lib/samagotchi/llm/http.rb

@@ -390,7 +390,7 @@ module Samagotchi
                 end
         Log.public_send(failure_level, :http, event, **log_base(current), status: e.is_a?(ProviderError) ? e.status : nil,
                                                      ms: elapsed_ms(current), attempts: current[:attempts], error: e.class.name,
-                                                     msg: (e.respond_to?(:summary) ? e.summary : e.message).to_s[0, 300])
+                                                     msg: log_message(e.respond_to?(:summary) ? e.summary : e.message))
         raise
       end
 
@@ -410,13 +410,18 @@ module Samagotchi
       def retry_after(error, attempts, delay, on_retry, cancel_controller, current)
         Log.warn(:http, "retry", **log_base(current), attempt: attempts, max_retries: @retry_policy.max, delay_s: delay,
                                  status: error.is_a?(ProviderError) ? error.status : nil, error: error.class.name,
-                                 msg: error.message.to_s[0, 300])
+                                 msg: log_message(error.message))
         on_retry&.call(attempt: attempts, max_retries: @retry_policy.max, next_delay: delay,
                        error_class: error.class.name, error_message: error.message,
                        status: error.is_a?(ProviderError) ? error.status : nil)
         wait(delay, cancel_controller)
       end
 
+      def log_message(value)
+        value.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "\uFFFD")
+          .gsub(/[[:cntrl:]\u2028\u2029]+/, " ").split.join(" ")[0, 300]
+      end
+
       def check_status!(response)
         status = response.code.to_i
         return if status.between?(200, 299)

data/lib/samagotchi/parent_report.rb

@@ -76,6 +76,7 @@ module Samagotchi
     # @return [Hash] the --format json object
     def json(result, session_id:, timeout: nil, extra: {})
       report = { status: status(result), session_id: session_id }
+      report[:turn_id] = result.turn_id unless result.turn_id.to_s.empty?
       case report[:status]
       when "answered" then report[:text] = result.text.to_s
       when "question"
@@ -122,7 +123,7 @@ module Samagotchi
         text = if result.status == :waiting_for_answer
                  question_text(result.question, session_id: session_id)
                else
-                 "#{detail(result, session_id: session_id, timeout: timeout)}\n"
+                 "#{detail(result, session_id: session_id, timeout: timeout, turn_id: result.turn_id)}\n"
                end
         stderr.print("#{command}: #{text}")
       end
@@ -200,7 +201,7 @@ module Samagotchi
     end
 
     # What a wait that ended without an answer says, one line.
-    def detail(result, session_id:, timeout: nil)
+    def detail(result, session_id:, timeout: nil, turn_id: nil)
       attach = "chi --attach #{session_id}"
       case result.status
       when :waiting_for_answer
@@ -217,7 +218,10 @@ module Samagotchi
       when :error then "the worker failed: #{result.text}; #{attach} shows what happened"
       when :worker_gone then "the worker is gone; #{attach} shows what happened"
       when :stopped then "the session was stopped (chi sessions stop)"
-      else timeout ? "still running after #{format("%g", timeout)} s: #{attach}" : "still running: #{attach}"
+      else
+        wait_again = "chi send --wait --turn #{turn_id} #{session_id}" unless turn_id.to_s.empty?
+        hint = wait_again || attach
+        timeout ? "still running after #{format("%g", timeout)} s: #{hint}" : "still running: #{hint}"
       end
     end
 

data/lib/samagotchi/reply_wait.rb

@@ -52,8 +52,10 @@ module Samagotchi
     # @!attribute session [Session, nil] the session as the look that
     #   decided the outcome loaded it (a caller's next baseline); nil for
     #   :canceled and :timeout
+    # @!attribute turn_id [String, nil] the id of the turn this result is
+    #   about, when known
     Result = Struct.new(:status, :text, :file, :question, :outcome, :limit, :error_kind, :retryable, :cancel_reason,
-                        :stopped_by, :kept_steps, :session, keyword_init: true)
+                        :stopped_by, :kept_steps, :session, :turn_id, keyword_init: true)
 
     module_function
 
@@ -94,10 +96,18 @@ module Samagotchi
     # @param queued [Boolean] the turn: input was sent as a queue (or with
     #   images), which a running turn never merges: no fallback, even when
     #   its file was taken before the first look
+    # @param ended_before [Boolean] a last_turn that ended before the
+    #   baseline (chi send --wait with no message, on a session that went
+    #   idle in the gap between waits) is the turn's end too: with the
+    #   session idle and its last_turn still the baseline's, its end is
+    #   the answer — its reply, or its no-reply outcome. Its reply file
+    #   sorts at the cursor, not past it, and its end precedes the
+    #   baseline, so without it the wait would time out "running" again.
+    #   Not for a turn: wait (chi answer) whose own end it waits for.
     # @return [Result]
     # @raise [ArgumentError] no such session
     def call(id, state_dir:, cursor:, timeout: nil, poll_interval: POLL_INTERVAL, cancelled: -> { false },
-             baseline: nil, owner_grace: nil, interject: nil, turn: nil, queued: false)
+             baseline: nil, owner_grace: nil, interject: nil, turn: nil, queued: false, ended_before: false)
       deadline = timeout && (monotonic + timeout.to_f)
       seen_running = false
       gone_since = nil
@@ -159,6 +169,34 @@ module Samagotchi
 
         return Result.new(status: :canceled) if cancelled.call
 
+        # The turn that ended before this wait (ended_before: chi send
+        # --wait with no message, on a session that went idle in the gap
+        # between waits): its last_turn still stands, the session is idle,
+        # so its end is the answer, not a wait that times out "running"
+        # again. Its reply file sorts at the cursor (the newest), not past
+        # it: it is the turn's when it is at least as new as the turn's
+        # end (the worker writes it after recording the ended_at), else the
+        # turn left no reply and an earlier turn's file is not its.
+        if ended_before && turn.nil? && session.status == Session::STATUS_IDLE &&
+           (ended = session.last_turn&.ended_at) && !ended.to_s.empty? &&
+           baseline && ended == baseline[:last_turn]
+          file = newest_reply(id, state_dir: state_dir)
+          if file && reply_is_turns?(file, ended)
+            reply = Result.new(status: :done, text: File.read(File.join(reply_dir(id, state_dir: state_dir), file)), file: file)
+            reply.session = settled(session, id, state_dir: state_dir)
+            return reply
+          end
+
+          return no_reply(session, baseline, fresh: true)
+        end
+
+        if ended_before && turn && session.last_turn&.enqueued_id == turn &&
+           !(session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == turn) &&
+           (ended = session.last_turn&.ended_at) && !ended.to_s.empty? &&
+           baseline && ended == baseline[:last_turn]
+          return no_reply(session, baseline, fresh: true)
+        end
+
         if turn
           # Only the turn's own end: the session runs another turn when the
           # wait starts, and that one's end is not the answer. A last_turn
@@ -257,6 +295,18 @@ module Samagotchi
       session.last_turn&.enqueued_id
     end
 
+    # Whether +turn+ is a turn the caller can wait for: running now, queued
+    # as its own turn, or the last one to have ended.
+    def known_turn?(session, session_dir:, turn:)
+      id = turn.to_s
+      return false if id.empty?
+
+      running = session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == id
+      queued = SessionInbox.waiting_input(session_dir, id) == :turn_end
+      ended = session.last_turn&.enqueued_id == id
+      running || queued || ended
+    end
+
     # Whether the session's worker sidecar names TURN_IDS_FEATURE.
     def turn_ids?(session_dir)
       WorkerSidecar.read(session_dir)&.features&.include?(TURN_IDS_FEATURE) || false
@@ -390,6 +440,22 @@ module Samagotchi
       cursor.nil? || file > cursor
     end
 
+    # Whether the reply file +file+ is the turn that ended at +ended_at+'s,
+    # not an earlier turn's: the worker records the ended_at, then writes
+    # the reply (SessionInbox.write_output: the name's timestamp is the
+    # write time, at least the ended_at); every earlier turn's file is
+    # older than the turn's end. The wait and the session run on one
+    # machine, so the name's local-time read is the writer's. A name that
+    # doesn't read as a time isn't the turn's.
+    def reply_is_turns?(file, ended_at)
+      name = file.to_s
+      return false if name.length < 23
+
+      Time.parse(ended_at.to_s) <= Time.strptime(name[0, 14], "%Y%m%d%H%M%S") + (name[14, 9].to_f / (10**9))
+    rescue ArgumentError
+      false
+    end
+
     def monotonic
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end

data/lib/samagotchi/send_command.rb

@@ -43,7 +43,7 @@ module Samagotchi
              chi send --new --continues (ID|PREFIX|last:ID) [--model M] [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --queue --wait [--timeout S] [--format json] [-m TEXT] ID
-             chi send --wait [--timeout S] [--format json] ID
+             chi send --wait [--timeout S] [--format json] [--turn T] ID
         Sends a message to each session, as if typed in it: a turn starts,
         or a running one takes it at its next step. A stopped session's
         worker starts.
@@ -91,7 +91,10 @@ module Samagotchi
                     the web). With no message (no -m, nothing piped)
                     nothing is sent: it waits for the session's next
                     reply, a running turn's too (after exit 3, 4 or 130,
-                    wait again this way)
+                    wait again this way). To an idle session whose last
+                    turn already ended, that ended turn is the answer:
+                    its reply, or its end when it left none. --turn T
+                    waits for that running, queued or last-ended turn
         --cut       ask the running turn to cut the generation it is
                     streaming and take the message now (a generation that
                     has streamed only thinking for steer.cut_after; else
@@ -108,10 +111,12 @@ module Samagotchi
                     than queueing (it would steer; restart it)
         --timeout S (--wait) give up after S seconds, exit 4 (the turn
                     goes on); default no limit
+        --turn T    (--wait, no message) wait for this turn id, from the
+                    JSON's turn_id; not with -m
         --format json
                     (--wait) one JSON object on stdout, whatever the end:
                     status answered (text), question (question,
-                    answer_with), running, or failed, canceled,
+                    answer_with), turn_id when known, running, or failed, canceled,
                     limit, no_answer, error, worker_gone, stopped,
                     command (detail); with --cut or --queue also
                     delivery (what the worker applied: next_step, cut,
@@ -142,6 +147,7 @@ module Samagotchi
       f.switch "--queue"
       f.value "--timeout"
       f.value "--format"
+      f.value "--turn"
       # Starting a turn in every live session at once is too easy to do
       # by accident.
       f.refuse "--all", "there is no --all: name the sessions"
@@ -204,6 +210,7 @@ module Samagotchi
       prompt = compose(utf8(read_stdin), utf8(options[:message]))
       # Before the wait-only case, which would drop the images.
       return usage_error("--image needs a message: pass -m TEXT or pipe it in") if prompt.nil? && !options[:images].empty?
+      return usage_error("--turn cannot be used with a message") if options[:turn] && prompt
       return run_wait_only(options) if prompt.nil? && options[:wait] && !options[:new]
 
       # The next link of a chain may start idle, waiting for its first message.
@@ -268,6 +275,8 @@ module Samagotchi
         options[:timeout] = Float(options[:timeout], exception: false)
         return usage_error("--timeout takes seconds") unless options[:timeout]&.positive?
       end
+      return usage_error("--turn needs --wait") if options[:turn] && !options[:wait]
+      return usage_error("--turn is only for waiting without a message") if options[:turn] && (options[:new] || options[:queue] || options[:cut])
       return usage_error("--wait takes one session") if options[:wait] && options[:ids].uniq.size > 1
       return usage_error("at most #{MAX_IMAGES} images") if options[:images].size > MAX_IMAGES
       return new_options(options) if options[:new]
@@ -388,7 +397,7 @@ module Samagotchi
       return report_command(session.id) if @sent_command
 
       wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
-                                 timeout: options[:timeout])
+                                 timeout: options[:timeout], report_turn_id: @sent_enqueued_id)
     end
 
     # The model the new session will run, for the images check: --model
@@ -450,6 +459,9 @@ module Samagotchi
 
       cursor = ReplyWait.newest_reply(id, state_dir: @state_dir)
       baseline = baseline_of(session)
+      running_turn = if session.status == Session::STATUS_RUNNING
+                       ReplyWait.own_turn(session, session_dir: Session.session_dir(id, state_dir: @state_dir))
+                     end
       return 1 unless deliver(id, prompt)
       return report_command(id) if @sent_command
 
@@ -457,7 +469,15 @@ module Samagotchi
       # running at the check ended before it went in (an idle worker's ack
       # says next_step, and the file still runs as that turn).
       turn = @queue ? @sent_enqueued_id : nil
-      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn, queued: !turn.nil?)
+      report_turn_id = if @queue
+                         turn
+                       elsif session.status == Session::STATUS_RUNNING
+                         running_turn
+                       else
+                         @sent_enqueued_id
+                       end
+      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn, queued: !turn.nil?,
+                          report_turn_id: report_turn_id)
     end
 
     # --wait with no message: the session's next reply, sending nothing,
@@ -468,16 +488,33 @@ module Samagotchi
     # waits for whatever wakes one (the web, chi send) rather than calling
     # it gone. The turn running now, or the one whose continue offer
     # stands, is the one waited for (ReplyWait.own_turn): its reply, not a
-    # turn's queued behind it; with none known, the next reply.
+    # turn's queued behind it; with none known, the next reply. An idle
+    # session whose last turn already ended (no question standing) went
+    # idle in the gap between waits: that turn's end is the answer — its
+    # reply, or its no-reply outcome — so the wait returns it at once
+    # (ReplyWait's ended_before:) instead of timing out "running" again.
     # @return [Integer] the exit status
     def run_wait_only(options)
       id = resolve(options[:ids].first) or return 1
       session = Session.load(id, state_dir: @state_dir)
+      session_dir = Session.session_dir(id, state_dir: @state_dir)
+      requested_turn = options[:turn]&.to_s
+      if requested_turn && !ReplyWait.known_turn?(session, session_dir: session_dir, turn: requested_turn)
+        error_line("chi send: turn #{requested_turn} is not a running, queued, or last ended turn")
+        return 1
+      end
       live = session.status == Session::STATUS_RUNNING || SessionManager.session_owner(id, state_dir: @state_dir)
-      turn = ReplyWait.own_turn(session, session_dir: Session.session_dir(id, state_dir: @state_dir))
+      turn = requested_turn || ReplyWait.own_turn(session, session_dir: session_dir)
+      # The gate for the settled case: idle, a turn ended (last_turn), no
+      # question standing (a continue offer waits for its answer).
+      settled = session.status == Session::STATUS_IDLE && session.last_turn && session.pending_question.nil?
+      ended_before = requested_turn ? session.last_turn&.enqueued_id == requested_turn : settled
+      report_turn_id = turn
+      report_turn_id ||= session.last_turn&.enqueued_id if settled
       wait_for_reply(id, cursor: ReplyWait.newest_reply(id, state_dir: @state_dir),
                          baseline: baseline_of(session).merge(messages: nil),
-                         timeout: options[:timeout], owner_grace: live ? self.class::WORKER_GONE_AFTER : nil, turn: turn)
+                         timeout: options[:timeout], owner_grace: live ? self.class::WORKER_GONE_AFTER : nil,
+                         turn: turn, ended_before: ended_before, report_turn_id: report_turn_id)
     end
 
     # The session as it was before the message went in (ReplyWait's
@@ -514,6 +551,8 @@ module Samagotchi
         return false
       end
 
+      ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
+      @sent_enqueued_id = (ack["enqueued_id"] || ack[:enqueued_id])&.to_s
       @sent_command = command_ack?(result[:ack])
       @info.puts("#{session.id}  started#{continued_words(session)}#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
       true

data/lib/samagotchi/session_metrics/side_totals.rb

@@ -31,14 +31,21 @@ module Samagotchi
         return zero unless hash.is_a?(Hash)
 
         hash = hash.transform_keys(&:to_s)
-        kinds = hash["by_kind"].is_a?(Hash) ? hash["by_kind"] : {}
-        new(**COUNTS.to_h { |key| [key, count(hash[key.to_s])] }, cost_sum: cost(hash["cost_sum"]),
-                                                                  cost_estimate_sum: number(hash["cost_estimate_sum"]),
-                                                                  by_kind: kinds.each_with_object({}) do |(kind, row), rows|
-                                                                    row = row.is_a?(Hash) ? row.transform_keys(&:to_s) : {}
-                                                                    rows[kind.to_s] = { requests: count(row["requests"]), cost_sum: cost(row["cost_sum"]),
-                                                                                        cost_estimate_sum: number(row["cost_estimate_sum"]) }.freeze
-                                                                  end.freeze)
+        new(
+          **COUNTS.to_h { |key| [key, count(hash[key.to_s])] },
+          cost_sum: cost(hash["cost_sum"]),
+          cost_estimate_sum: number(hash["cost_estimate_sum"]),
+          by_kind: saved_kinds(hash["by_kind"])
+        )
+      end
+
+      def self.saved_kinds(hash)
+        kinds = hash.is_a?(Hash) ? hash : {}
+        kinds.each_with_object({}) do |(kind, row), rows|
+          row = row.is_a?(Hash) ? row.transform_keys(&:to_s) : {}
+          rows[kind.to_s] = { requests: count(row["requests"]), cost_sum: cost(row["cost_sum"]),
+                              cost_estimate_sum: number(row["cost_estimate_sum"]) }.freeze
+        end.freeze
       end
 
       # These totals with one side request counted in.
@@ -87,7 +94,7 @@ module Samagotchi
 
       def self.cost(value) = value.is_a?(Numeric) ? value : nil
 
-      private_class_method :count, :number, :cost
+      private_class_method :count, :number, :cost, :saved_kinds
 
       private
 

data/lib/samagotchi/session_metrics.rb

@@ -351,6 +351,9 @@ module Samagotchi
       end
     end
 
+    # @return [String, nil] the session id #persist writes under
+    def session_id = @mutex.synchronize { @session_id }
+
     # Count one side request (a recap, a plugin's ctx.ask_model) in the
     # side block, apart from the turns' totals. Safe from any thread.
     # @param usage [SideUsage]

data/lib/samagotchi/testing/boundary.rb

@@ -9,6 +9,8 @@ module Samagotchi
     # why: the APIs to design before that bundle could leave chi's repo
     # (spec/samagotchi/testing/boundary_spec.rb keeps both exact).
     module Boundary
+      LIB_DIR = File.expand_path("../..", __dir__)
+
       # A name a bundle may use, and the file that defines it (a require of
       # it is fine too). A name allows itself, its methods (".x") and what
       # it holds ("::X"); one ending in a method or constant allows only that.
@@ -124,6 +126,8 @@ module Samagotchi
       REFERENCE = /\bSamagotchi(?:::[A-Z]\w*)+(?:\.[a-z_]\w*[?!]?)?/
       # A require of one of chi's files.
       REQUIRE = %r{\brequire\s*\(?\s*["'](samagotchi(?:/[\w/]+)?)["']}
+      # A relative require that may leave the bundle.
+      REQUIRE_RELATIVE = /\brequire_relative\s*\(?\s*["']([^"']+)["']/
 
       # One reference outside ALLOWED, in a file of the bundle.
       Finding = Data.define(:reference, :file)
@@ -140,11 +144,22 @@ module Samagotchi
           text = File.read(path)
           refs = text.scan(REFERENCE).reject { |name| allowed?(name) }
           refs += text.scan(REQUIRE).flatten.reject { |file| ALLOWED_REQUIRES.include?(file) }.map { |file| %(require "#{file}") }
+          refs += text.scan(REQUIRE_RELATIVE).flatten.filter_map do |relative|
+            target = File.expand_path(relative, File.dirname(path))
+            next unless within?(target, LIB_DIR) && !within?(target, File.expand_path(dir))
+
+            %(require_relative "#{relative}")
+          end
           file = path.delete_prefix("#{File.expand_path(dir)}/")
           refs.uniq.map { |reference| Finding.new(reference: reference, file: file) }
         end
       end
 
+      def within?(path, dir)
+        path == dir || path.start_with?("#{dir}#{File::SEPARATOR}")
+      end
+      private_class_method :within?
+
       # Whether a bundle may use +name+ ("Samagotchi::X::Y", maybe ".method").
       def allowed?(name)
         ALLOWED.any? do |entry|

data/lib/samagotchi/testing/bundle.rb

@@ -26,12 +26,17 @@ module Samagotchi
     class HookFailed < StandardError
       # @return [Hooks::Failure]
       attr_reader :failure
-
-      def initialize(failure)
-        @failure = failure
-        error = failure.error
-        super("#{failure.hook} raised on #{failure.event}: #{error.class}: #{error.message}")
-        set_backtrace(error.backtrace) if error.backtrace
+      # @return [Array<Hooks::Failure>]
+      attr_reader :failures
+
+      def initialize(failures)
+        @failures = failures.dup.freeze
+        @failure = @failures.first
+        super(@failures.map do |failure|
+          error = failure.error
+          "#{failure.hook} raised on #{failure.event}: #{error.class}: #{error.message}"
+        end.join("; "))
+        set_backtrace(@failure.error.backtrace) if @failure.error.backtrace
       end
 
       def cause = @failure.error
@@ -142,7 +147,7 @@ module Samagotchi
             @plugin = built
           end
         end
-        @hooks_namespace = Hooks::BundleLoader.namespace_for(@name).const_set(:"KitHooks#{object_id}", Module.new)
+        @hooks_namespace = Module.new
         @manifest.hooks.each do |basename, hook|
           next if hook.event.empty?
 
@@ -168,6 +173,27 @@ module Samagotchi
         payload
       end
 
+      # Build the before_tool_call payload from the real Gate, without firing
+      # this bundle's hooks.
+      # @param call [Hash] the parsed tool call
+      # @param iteration [Integer]
+      # @param params [String] the call's one-line preview
+      # @param context [Guardrails::Context, nil]
+      # @param verdict [Verdict, nil]
+      # @return [Hash]
+      def before_tool_call_event(call, params:, iteration: 1, context: nil, verdict: nil)
+        context ||= Guardrails::Context.new(cwd: @recorder[:cwd], session_id: @recorder[:session_id],
+                                            interface: @recorder[:frontend])
+        dispatched = nil
+        capture = Hooks::Registry.new
+        capture.register(:before_tool_call) { |event| dispatched = event.dup }
+        gate = Guardrails::Gate.new(-> { capture }, context_lookup: -> { context }, tools_lookup: -> { tools })
+        gate.evaluate(call, iteration: iteration, params: params, verdict: verdict || Verdict.new(call: call))
+        raise ArgumentError, "guardrails did not dispatch a before_tool_call event for #{call[:name].inspect}" unless dispatched
+
+        dispatched.slice(:type, :iteration, :call, :params, :blocked, :block_reason, :guardrail, :context, :targets)
+      end
+
       # One tool call through a real Guardrails::Gate: the before_tool_call
       # hooks vote on a Testing::Verdict (pass +verdict+ to start from one,
       # another voter's deny in it), with the context and targets the Gate
@@ -331,8 +357,8 @@ module Samagotchi
         result = Hooks.capture_failures(failures, &)
         if @lenient
           @errors.concat(failures)
-        elsif (first = failures.first)
-          raise HookFailed, first
+        elsif failures.any?
+          raise HookFailed, failures
         end
         result
       end

data/lib/samagotchi/version.rb

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

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

@@ -1143,10 +1143,12 @@ function updateSessionTitle() {
 }
 
 // The stage takes a running turn's rows (its extras); else the history.
+// @return true when the stage took +el+ (it scrolls it into its view itself)
 function appendToHistory(el) {
   // (The stage's place first moves a turn still sliding away into the history.)
-  if (turnDom.place?.(el)) return;
+  if (turnDom.place?.(el)) return true;
   appendAboveLiveTiming(historyEl, el, liveTurn.timing.el);
+  return false;
 }
 
 // A turn-end re-read's timing (?tail=1&recent=1: the newest turn's records

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

@@ -26,7 +26,8 @@ import { plainText } from "./plain_line.js";
 
 // @param sessionId () => the open session's id (answers go there)
 // @param clientId this tab's id in the session's events
-// @param place (card) puts a new card at the end of the history
+// @param place (card) puts a new card at the end of the history; true: the
+//   stage took it (it brings the card into its view itself, eased)
 // @param isNearBottom () => whether the history follows its end
 // @param scrollToEnd () scrolls the history to its end
 // @param removeHintIfEmpty () drops the history's placeholder hint
@@ -200,10 +201,10 @@ export function createQuestionCards({
 
     // Read before the card makes the history taller.
     const follow = isNearBottom();
-    place(card);
+    const staged = place(card) === true;
     questionEl = card;
     if (follow) scrollToEnd();
-    focusWhenIdle(card, pq.id);
+    focusWhenIdle(card, pq.id, { staged });
   }
 
   function isPlainEnter(e) {
@@ -213,7 +214,10 @@ export function createQuestionCards({
   // A new card takes the focus while nobody is typing: the focus is on
   // the page or an empty composer. Checked after the caller is done, so a
   // card drawn already answered (the history replay) never takes it.
-  function focusWhenIdle(card, id) {
+  // +staged+: the stage holds the card and scrolls to it once it has grown
+  // for it (eased): the focus doesn't scroll, or the stage would snap to the
+  // card before its room eases in.
+  function focusWhenIdle(card, id, { staged = false } = {}) {
     queueMicrotask(() => {
       if (questionEl !== card || String(pending?.id) !== String(id)) return;
       const prompt = doc.getElementById?.("prompt");
@@ -221,7 +225,8 @@ export function createQuestionCards({
       const idle = !active || active === doc.body || (active === prompt && !prompt.value);
       if (!idle || (prompt && prompt.value)) return;
       const target = card.querySelector(".question-option input") || card.querySelector(".question-freeform");
-      target?.focus();
+      if (staged) target?.focus({ preventScroll: true });
+      else target?.focus();
     });
   }
 

metadata

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