samagotchi 0.48.0 → 0.49.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b751e52e486a5e301e85e8dd0557b9786fc240d59becf71152eaee6b97c2176e
-  data.tar.gz: 1be48dc0d3898135b44b56bab594ee4af910669512b584c6d408536ed14f47bb
+  metadata.gz: ca248891309ffde628ce6c03c2bbd35fa946f7fa669978c30d1478a0f236a920
+  data.tar.gz: 50e85c20fa0882c5caeeaf7a2c141dd46a443c5f725d60120e194ada9152871c
 SHA512:
-  metadata.gz: 0b3d59478632ccee06384d6844b7a7e5d21dcc0e90042056d305a4763272f0ed1b1d0e9c7559fe7296915bc07c62148417883ad7084c18c488bd5d522f1e7f72
-  data.tar.gz: 726ae060c0f5f0b0c9238b24aa15601431b0648e297cba8709e9943f1e257da447009bea82b669178c859080ed79d2a25dc60ccc805b429f95bf0e7b0ba36839
+  metadata.gz: e6ce68e65e80c48433bdb55706aaa19790ab6a140f81550f63420c1f4574d1e423a2dd356a01fda3534234331eacfb9a03151e3fa83b602d027d039ad44c76ab
+  data.tar.gz: a476e538ff5913c82625a18c8e23b822bc402f7ed206724debe65c95863a1ab7ab2606823befae4c44a0e265b3a8a45eafcf08c6b2215a27dab4bd6c03ac98ec

data/CHANGELOG.md

@@ -8,6 +8,37 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.49.0] - 2026-10-09
+
+### Added
+
+- Native Gemma 4 on llama.cpp (with `--mmproj`) sees images: `@path`, `read` on an image and the web's pasted images
+  reach it, as they do Qwen 3.6. Before, chi refused with "profile gemma4 has no image template yet".
+- Plugins: `ctx.frontend` says what runs the session: `:repl` (the REPL, `-p` without `--non-interactive`),
+  `:one_shot` (`-p --non-interactive`) or `:worker` (a session worker: the web, an attached TUI).
+
+### Changed
+
+- github-pr 0.4.0: line links read the PR's files (`gh api`) only in a session worker (the web, an attached chi), not
+  in the REPL, `chi -p` or a scratch session, whose answers no web page shows while they run. `bundles: github-pr:
+  line_links: always` reads in the REPL and `-p` too; `false` still turns it off. The PR lookup and attach are
+  unchanged. See [Line links](docs/context.md#line-links).
+
+### Fixed
+
+- Web: a command queued mid-turn (`/model X`) shows its bubble after the turn's answer once it runs, not among the
+  turn's rows above the answer.
+- A background task whose process exited and whose pid another process reused since no longer reads as running in
+  `task_list`, `task_get` and `task_wait` until a `task_stop`: each read checks the process's start time.
+- A continue that died after noting its moved delegates no longer notes them again when the new link's worker
+  finishes the move: `move.json` records who was told.
+- An attached chi watching a `-p --non-interactive` run says a question there was dismissed because no one could
+  answer it (`(dismissed: no one to answer in a non-interactive run)`), as the run itself does, not
+  `(question cancelled)`.
+
+Update with `chi update`: it updates github-pr (0.4.0: line links only where the web can show them). If you set
+`line_links: true` to get links in the REPL, set `line_links: always` instead.
+
 ## [0.48.0] - 2026-10-09
 
 ### Changed
@@ -2231,7 +2262,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.48.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.49.0...HEAD
+[0.49.0]: https://github.com/dm1try/samagotchi/compare/v0.48.0...v0.49.0
 [0.48.0]: https://github.com/dm1try/samagotchi/compare/v0.47.0...v0.48.0
 [0.47.0]: https://github.com/dm1try/samagotchi/compare/v0.46.1...v0.47.0
 [0.46.1]: https://github.com/dm1try/samagotchi/compare/v0.46.0...v0.46.1

data/docs/configuration.md

@@ -904,7 +904,7 @@ Whether a model can see images is found out before a turn with images is sent:
 
 - a native llama.cpp host: `/props` must report `modalities.vision` (the server
   runs with `--mmproj`) and a media marker, and the prompt profile must know the
-  chat template's image wrapping (qwen36 does; gemma4 not yet);
+  chat template's image wrapping (qwen36 and gemma4 do);
 - mlx and oMLX hosts: no (not verified with recent chi versions);
 - an OpenAI-API host: a local llama.cpp's `/props`, else the host's model list
   (OpenRouter's `architecture.input_modalities`); when it doesn't say, the image

data/docs/context.md

@@ -258,13 +258,20 @@ show the answer as it is.
   So the first answer of a very short turn may come without links, and
   after a push links may be a few lines off until the next read. Without
   `gh` or its login, nothing is linked.
+- **Where it reads**: only in a session worker (the web, an attached chi),
+  whose answers the web shows while the session runs. The REPL and
+  `chi -p` read nothing (no `gh api` calls), so their answers have no links,
+  in the web too; a scratch session never reads. The PR itself is still
+  attached and its context still reaches the model everywhere.
 
-Turn it off:
+`line_links:` takes `false` (off), `true` (the default: a worker only) or
+`always` (the REPL and `chi -p` read too, so their answers are linked when
+you open the session in the web later):
 
 ```yaml
 bundles:
   github-pr:
-    line_links: false
+    line_links: false   # or always
 ```
 
 ## Safety

data/docs/internals/background-tasks.md

@@ -19,7 +19,7 @@ Behavior:
 
 - `execute`, `task_create` and the `!cmd` shell bang run the command in a non-login shell: `/bin/sh -c` on Linux; on macOS, when `/bin/zsh` is there, `/bin/zsh --emulate sh +o ignore_braces +o sh_glob -o bash_rematch +o bsd_echo -c` (macOS's `/bin/sh` is bash 3.2, which can't parse an apostrophe in a heredoc inside `"$( )"`, the usual commit message shape). That mode reads no rc files and keeps POSIX word splitting, unmatched globs left as is, `{1..3}`, `[[ … =~ (…) ]]` with `BASH_REMATCH`, arrays, `$'…'`, `&>` and echo expanding `\t`. Bash-only builtins and variables (`shopt`, `BASH_VERSION`, `${!prefix*}`, `read -p`) are not there.
 - Task metadata and output are persisted under `tmp/tasks/`.
-- A task record keeps its process's pid and start time (`pid_started`). Before `task_stop` signals, the pid must still lead its own process group and must not have started at another time; otherwise the pid was reused by another process, nothing is signalled and the task ends as failed. A start time that can't be read at that moment (a failed `ps`) falls back to the group check, as does a record without `pid_started` (from an older chi). `task_get`, `task_list` and `task_wait`'s polls check the group only (no `ps` per poll).
+- A task record keeps its process's pid and start time (`pid_started`). Before `task_stop` signals, the pid must still lead its own process group and must not have started at another time; otherwise the pid was reused by another process, nothing is signalled and the task ends as failed. A start time that can't be read at that moment (a failed `ps`) falls back to the group check, as does a record without `pid_started` (from an older chi). `task_get`, `task_list`, `task_wait`'s polls and the running-task lists (a cancelled turn's note, a worker's idle exit) make the same check, so a task whose pid was reused reads as exited (failed) at once, not as running until a `task_stop`; on macOS that is one `ps` per running task per check (~5 ms).
 - Task listing is workspace-scoped (current project only).
 - `task_get` returns metadata and `output_path`; use `read` for output contents.
 - `task_wait` accepts `timeout`, `tail_lines` (maximum 100), and `done_pattern` (a regular expression string).

data/docs/plugins.md

@@ -505,6 +505,7 @@ full label, `plugin.rb (bundle my-bundle)`.
 | `ctx.repo_root` | the git checkout holding `cwd`, or nil |
 | `ctx.scratch?` | whether the session is a `chi scratch` one (deleted when it ends) |
 | `ctx.delegate?` | whether the session is a delegate child: a task another session handed over |
+| `ctx.frontend` | what runs the session, read now: `:repl` (the REPL, `-p` without `--non-interactive`), `:one_shot` (`-p --non-interactive`: one turn, then exit) or `:worker` (a session worker: the web, an attached TUI). Only a worker's answers reach the web while it runs; a REPL's show there once the session is opened. Until the host sets it (while the plugins load, inside `Engine.new`) it reads `:one_shot`, so read it in hooks and init tasks, not in `register` |
 | `ctx.fork?` | whether the session is a fork (`ctx.sessions.fork`): it has a parent but isn't a delegate child, and started from a conversation, so its first prompt isn't its first user message |
 | `ctx.model` | the model the session runs on now: its resolved ref (`host:id`), right after `/model` too |
 | `ctx.model_key` | that model's memory overlay key (`<name>.<key>.md`, what `memory_write current_model_only` writes) |
@@ -1240,8 +1241,9 @@ nothing without `gh`, a repository or an open PR), and resolves PR URLs for
 `chi context add` and the web's "+ URL". Its script prints the PR as text
 and a summary of what changed in counts, authors and states only; it wakes
 the session for a review requesting changes, checks turning red, or the PR
-merged or closed. In the web, a `path:line` in an answer links to that line
-of the session's PR ([Line links](context.md#line-links)). `auto_attach:
+merged or closed. In the web, a `path:line` in a worker's answer links to
+that line of the session's PR ([Line links](context.md#line-links); `line_links:
+always` for the REPL and `chi -p` too). `auto_attach:
 offer` asks with a card first (`/pr-attach N`, `/pr-decline N`), `off`
 attaches nothing ([Attach, offer or off](context.md#attach-offer-or-off)).
 See [Attached context](context.md#github-prs-the-github-pr-bundle).

data/docs/sessions.md

@@ -197,7 +197,7 @@ A session can **continue** an earlier one: "the next day of the same routine" (a
 - **The recap first:** a previous link with a live worker is asked for a recap (the Bridge's `POST /recap`) and given up to 30 s to write it; one with none wrote its recap when its worker left.
 - **The previous link is archived** before the new one starts, by the archive's own rules (see *Archiving a session*): a turn running, a prompt queued or the step-limit question refuse it, a live idle worker is stopped, a plain REPL's session is refused. Its finished delegates are archived with it, as any archive does.
 - **Its open delegates move to the new link** instead: each direct delegate that is running, waiting for an answer, has a live worker or a reply its parent wasn't given, or has such a delegate below it (checked again after the recap wait, so one delegated meanwhile moves too). It moves with its own delegates, stays unarchived, and from then on is the new link's: its card folds under the new link, its reports ring the new link (an idle one runs a wake turn for them, as for its own delegates), `delegate_result` and the `⑂` chip count it there, and what its parent was already told (`delegates.json`) and any report still waiting come along, so nothing is reported twice. A moved delegate gets a context note from `session chain`, `Your parent session is now 4b7e9a01 (…), the next link of its session chain: …`, as its system prompt keeps naming the parent it started with. The move writes `<child>/parent.json` (`{parent_id, from, at}`) beside the child's session file, never the file itself, so a live child worker saving its own copy changes nothing; every reader applies it (a later move overwrites it; it is never removed). A continue is **refused for an open delegate that can't move** (`ContinueRefused`, naming it): one whose live worker runs an older chi (`older chi worker 0.46.1; restart it`: `chi sessions restart <id>`, or stop it) or that is open in a chi REPL (close it there). An older `chi web` or CLI still running shows a moved delegate under the archived link until it is restarted.
-- **If the continue fails part-way:** a new link that fails to start gives its moved delegates back before it is deleted (each gets a note saying so; its worker is stopped first, if one started, and a worker that won't stop is reported, the link left), with any report one of them rang it with meanwhile; the previous link, back in the lists, is woken for reports waiting. A continue that dies in the middle leaves a `move.json` in the new link's folder: the new link's next worker finishes that move (only the delegates it names) as it starts. Until the new link's own worker holds it, a ring from a moved delegate doesn't start another (a `starting` marker in its folder, which that worker removes; a stale one, over 60 s old or from a process that is gone, is ignored). An open delegate below an archived delegate refuses the continue (`under archived …`): unarchive that one, or archive this one.
+- **If the continue fails part-way:** a new link that fails to start gives its moved delegates back before it is deleted (each gets a note saying so; its worker is stopped first, if one started, and a worker that won't stop is reported, the link left), with any report one of them rang it with meanwhile; the previous link, back in the lists, is woken for reports waiting. A continue that dies in the middle leaves a `move.json` in the new link's folder: the new link's next worker finishes that move (only the delegates it names, and without a second note to one already told) as it starts. Until the new link's own worker holds it, a ring from a moved delegate doesn't start another (a `starting` marker in its folder, which that worker removes; a stale one, over 60 s old or from a process that is gone, is ignored). An open delegate below an archived delegate refuses the continue (`under archived …`): unarchive that one, or archive this one.
 - **Refused too:** a link that is continued already (naming the link that continues it; continue that one, or `last:<id>`), a previous link whose folder is gone, and one whose model names a host config.yml no longer has. A refusal starts nothing and archives nothing; a new link that fails to start puts back what was archived. Every refusal that can be known up front (the archive's ones included) comes before the recap wait. One continue of a session runs at a time (a lock in its folder; other chains don't wait), so a double click finds the first one's link and is refused, while a `last:<id>` continue that waited follows the chain to its new end.
 - **Web:** `POST /api/sessions` takes `continues: "<id, prefix or last:id>"`, with `idle: true` (a new link waiting for its first message, previewed by the previous link's, or `preview`) or a `prompt`, and not `dir`, `model` or `llm_context` (400 `invalid_continues`: the previous link's are taken). 201 is the new session's summary, `continues` set, with `moved`: the ids of the delegates that moved to it (`[]` for none); 404 `not_found`; 400 `ambiguous_id` for a prefix of several sessions, `invalid_model` for a model whose host is gone; 409 `continued` with `next_id` (the link that continues it already, which the page opens instead), `open_children` with `ids` (open delegates that can't move), `folder_gone`, `busy`, `scratch` or `owned_by_tui`. Every session summary carries `continues`.
 - **The page:** the info bar's `continue →` continues the open session (`continues: <id>, idle: true`; it reads `continuing…` through the recap wait) and opens the new link with `Continue where we left off.` in the composer, not sent (the same line for every chain; a draft already there stays instead); the previous link is archived, a toast says so (`Continued 3fa2c1d0 in 4b7e9a01; 3fa2c1d0 is archived; 1 open delegate moved`), and a moved delegate's card folds under the new link. A link continued already has no `continue →`: its `→` link goes to the next link (a stale page's continue answered 409 `continued` opens `next_id`). A continue refused for open delegates that can't move shows a toast that names each one (its preview and what the server says to do: `older chi worker 0.46.1; restart it`, `open in a chi REPL; close it there`), each a link to its page; any other refusal shows the server's words. The info bar of a link carries `← 2026-10-08` (the previous link's day) and, on an earlier link, `2026-10-10 →`, each a link with its preview and id in the tooltip. A link whose title is the opener and nothing else (its first message once sent) shows its chain's first link's title instead, on its card, in the popover and in its info bar's title line, display only (its messages and data keep the opener; its own title when the first link is gone). The lists fold a chain into the card of its latest listed link, whatever the earlier links' archived state (typing in an archived link brings it back, folded there still), their delegates with them: the card's `↩ day N` chip (`day N of M` when later links aren't listed) opens a popover of the other links, newest first (`day N`, its date, its recap's first sentence or its preview, `archived`), a click opens one; the chip shows a live dot or `waiting` for a link that has a worker or waits on the user, and a waiting link puts its chain's card first. All sessions folds nothing while a search is typed or "include archived" is on: every link is a card of its own then, its chip `day N of M`, with its own delegates folded in, so a search finds an earlier link and its delegates.

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

@@ -1,6 +1,6 @@
 ---
 name: github-pr
-version: 0.3.3
+version: 0.4.0
 scope: system
 description: Attaches the branch's open GitHub pull request to a session as context (and any PR URL with chi context add or the web's "+ URL"); the agent gets a note when reviews, comments, checks or its state change; in the web, a path:line in an answer links to that line of the PR; the auto_attach setting can offer the PR with a card first, or attach nothing
 trust_level: reviewed
@@ -11,7 +11,7 @@ needs:
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:f68b53bfb552e35c9b151ee42cc10c07923481fc3d5496f023422e388df6719a
+  sha256: sha256:2510f8e5bfc77b2a6343b47d56bf6be9da09fd8741f52928462945a55d83f0ce
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers:

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

@@ -23,8 +23,11 @@ require "tmpdir"
 # model's text stays as it was. The after_turn hook links from a per-PR
 # cache and never runs gh (the web holds the answer until the hooks are
 # done); before_turn, before_generation and the init task fill the cache
-# off the turn's thread. `bundles: github-pr: line_links: false` turns it
-# off.
+# off the turn's thread (`gh api`), in a session worker only: the REPL and
+# -p --non-interactive show no web page while they run (ctx.frontend; a chi
+# without it counts as a worker), and a scratch session never fetches.
+# `bundles: github-pr: line_links:` false turns it off, "always" fetches in
+# the REPL and -p too (still not for a scratch session).
 #
 # `bundles: github-pr: auto_attach:` says what the init task does with the
 # branch's open PR: `attach` (the default), `offer` (a card with Attach and
@@ -37,6 +40,8 @@ class Plugin
   COMMAND_SECONDS = 20
   # before_generation looks for a newly attached PR at most this often.
   GENERATION_CHECK_SECONDS = 30
+  # line_links' values: off, a worker's only (the default), every frontend.
+  LINE_LINKS_MODES = { false => :off, true => :worker, "always" => :always }.freeze
   # auto_attach's values (YAML's bare true/false: attach/off).
   AUTO_ATTACH_MODES = { "attach" => :attach, "offer" => :offer, "off" => :off, true => :attach, false => :off }.freeze
   # /pr-attach and /pr-decline take a PR number (`42` or `#42`).
@@ -50,6 +55,7 @@ class Plugin
     @cache = PrCache.new
     @generation_checked_at = nil
     @warned_mode = false
+    @warned_line_links = false
   end
 
   def register(chi)
@@ -58,13 +64,13 @@ class Plugin
       # Inline (an init task has its own thread), whatever the attach
       # returned (attached already, a child, a scratch session), and after
       # it, so a PR it just attached is warm for the first answer.
-      refresh(ctx, attached_prs(ctx)) if line_links?(ctx)
+      refresh(ctx, attached_prs(ctx)) if prefetch?(ctx)
       summary
     end
     chi.on(:before_turn) do |event, ctx|
       # The prompt too: messages is the history before this turn, and a
       # delegate child's task is its first prompt.
-      kick(ctx, attached_prs(ctx) + PrRef.from_messages(event[:messages], prompt: event[:prompt])) if line_links?(ctx)
+      kick(ctx, attached_prs(ctx) + PrRef.from_messages(event[:messages], prompt: event[:prompt])) if prefetch?(ctx)
       log_first_prompt(event, ctx)
     end
     chi.command("/pr-attach", "Attach the PR this session was offered: /pr-attach 42", anytime: true) do |args, ctx|
@@ -150,7 +156,34 @@ class Plugin
 
   private
 
-  def line_links?(ctx) = ctx.settings["line_links"] != false
+  # `bundles: github-pr: line_links:`: :off, :worker (true or unset) or
+  # :always; an unknown value (a quoted "false") is :worker, logged once.
+  def line_links_mode(ctx)
+    value = ctx.settings["line_links"]
+    return :worker if value.nil?
+
+    LINE_LINKS_MODES.fetch(value.is_a?(String) ? value.strip.downcase : value) do
+      ctx.log.warn(:pr_line_links_unknown, value: value.to_s[0, 40]) unless @warned_line_links
+      @warned_line_links = true
+      :worker
+    end
+  end
+
+  def line_links?(ctx) = line_links_mode(ctx) != :off
+
+  # Whether to fetch PR data for line links (gh api): not for a scratch
+  # session (gone at exit), and by default only in a session worker, the
+  # one frontend whose answers the web shows while it runs. A chi before
+  # ctx.frontend (0.49.0) counts as a worker.
+  def prefetch?(ctx)
+    return false if ctx.scratch?
+
+    case line_links_mode(ctx)
+    when :off then false
+    when :always then true
+    else (ctx.respond_to?(:frontend) ? ctx.frontend : :worker) == :worker
+    end
+  end
 
   def offer_card_id(number) = "github-pr-offer-#{number}"
 
@@ -275,7 +308,7 @@ class Plugin
   # A PR attached while the turn runs (a parent attaching it right after
   # `delegate wait: false`), checked at most every GENERATION_CHECK_SECONDS.
   def check_attached(ctx)
-    return unless line_links?(ctx)
+    return unless prefetch?(ctx)
     return if @generation_checked_at && now - @generation_checked_at < GENERATION_CHECK_SECONDS
 
     @generation_checked_at = now

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

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

data/lib/samagotchi/child_move.rb

@@ -30,7 +30,7 @@ module Samagotchi
   # until it is done: a worker that starts and finds one finishes the move
   # (#adopt), and a failed continue moves the same children back.
   module ChildMove
-    # <new link dir>/move.json: {from, ids}, while a move is under way.
+    # <new link dir>/move.json: {from, ids, noted}, while a move is under way.
     INTENT_FILE = "move.json"
     # <new link dir>/starting: {pid, at}, from the move to the worker's spawn.
     STARTING_FILE = "starting"
@@ -47,8 +47,11 @@ module Samagotchi
     # link, their subtrees with them), +refuse+ the open ones it can't move
     # (SessionManager::OpenChild, why: an older chi worker or a chi REPL).
     Plan = Data.define(:move, :refuse)
-    # A move under way: from the session, the children moved.
-    Intent = Data.define(:from, :ids)
+    # A move under way: from the session, the children moved, and those
+    # already sent their note (so a move finished again notes no one twice).
+    Intent = Data.define(:from, :ids, :noted) do
+      def initialize(from:, ids:, noted: []) = super
+    end
 
     module_function
 
@@ -100,16 +103,26 @@ module Samagotchi
     # Move +ids+ (direct children of +from+) to +to+: the intent, the
     # cursors +to+ lacks (delegates.json), the overrides, the rings waiting
     # in +from+'s children/, a note to each child, then the intent goes.
-    # Safe to run again on the same move.
+    # Safe to run again on the same move: the intent records each child
+    # noted, and a run finishing it (#adopt) notes only the rest. A crash
+    # between a note and its record notes that child twice (better than
+    # none).
     # @param undo [Boolean] a failed continue moving them back: its note says so
     def apply(ids, from:, to:, state_dir:, undo: false)
       return if ids.empty?
 
-      write_intent(to, Intent.new(from: from, ids: ids), state_dir: state_dir)
+      intent = Intent.new(from: from, ids: ids)
+      left = read_intent(to, state_dir: state_dir)
+      intent = intent.with(noted: left.noted & ids) if left && left.from == from && left.ids.sort == ids.sort
+      write_intent(to, intent, state_dir: state_dir)
       copy_cursors(ids, from: from, to: to, state_dir: state_dir)
       ids.each { |id| Session.reparent(id, to: to, from: from, state_dir: state_dir) }
       move_rings(ids, from: from, to: to, state_dir: state_dir)
-      ids.each { |id| note_child(id, to: to, undo: undo, state_dir: state_dir) }
+      (ids - intent.noted).each do |id|
+        note_child(id, to: to, undo: undo, state_dir: state_dir)
+        intent = intent.with(noted: intent.noted + [id])
+        write_intent(to, intent, state_dir: state_dir)
+      end
       clear_intent(to, state_dir: state_dir)
       Log.info(:worker, undo ? "delegates_moved_back" : "delegates_moved", from: from[0, 8], to: to[0, 8], count: ids.size)
     end
@@ -143,7 +156,8 @@ module Samagotchi
       data = JSON.parse(File.read(File.join(Session.session_dir(session_id, state_dir: state_dir), INTENT_FILE)))
       return nil unless data.is_a?(Hash) && Session.valid_id?(data["from"]) && data["ids"].is_a?(Array)
 
-      Intent.new(from: data["from"], ids: data["ids"].select { |id| Session.valid_id?(id) })
+      noted = data["noted"].is_a?(Array) ? data["noted"].select { |id| Session.valid_id?(id) } : []
+      Intent.new(from: data["from"], ids: data["ids"].select { |id| Session.valid_id?(id) }, noted: noted)
     rescue JSON::ParserError, SystemCallError
       nil
     end
@@ -151,7 +165,7 @@ module Samagotchi
     def write_intent(session_id, intent, state_dir:)
       dir = Session.session_dir(session_id, state_dir: state_dir)
       FileUtils.mkdir_p(dir)
-      AtomicFile.write(File.join(dir, INTENT_FILE), JSON.generate({ "from" => intent.from, "ids" => intent.ids }))
+      AtomicFile.write(File.join(dir, INTENT_FILE), JSON.generate({ "from" => intent.from, "ids" => intent.ids, "noted" => intent.noted }))
     end
 
     def clear_intent(session_id, state_dir:)

data/lib/samagotchi/engine.rb

@@ -2470,7 +2470,8 @@ module Samagotchi
         model_key: -> { @model_key },
         state_dir: -> { session_state_dir },
         scratch: -> { @scratch },
-        llm_context: -> { @session&.llm_context }
+        llm_context: -> { @session&.llm_context },
+        frontend: -> { interface }
       )
     end
 

data/lib/samagotchi/model_profile.rb

@@ -40,7 +40,7 @@ module Samagotchi
                 :system_prefix, :user_prefix, :assistant_prefix,
                 :model_prefix,
                 :stop_sequences, :tool_decl_format,
-                :image_template
+                :image_template, :image_check_token
 
     def initialize(config)
       @name = config[:name]
@@ -65,10 +65,12 @@ module Samagotchi
       # How the chat template wraps an image's media marker ("%{marker}"),
       # or nil when chi doesn't know it yet (native images are refused).
       @image_template = config[:image_template]
+      # A token the server's chat template must contain for images to be
+      # sent (VisionSupport); defaults to the template's opening token.
+      @image_check_token = config[:image_check_token] || image_open_token
     end
 
-    # The token the image template opens with, e.g. "<|vision_start|>": the
-    # server's chat template must use it too (VisionSupport).
+    # The token the image template opens with, e.g. "<|vision_start|>".
     def image_open_token
       image_template&.split("%{marker}")&.first.to_s
     end
@@ -92,7 +94,12 @@ module Samagotchi
         assistant_prefix: "",
         model_prefix: "",
         stop_sequences: ["<turn|>", "<|tool_response>"],
-        tool_decl_format: :gemma4
+        tool_decl_format: :gemma4,
+        # The bare marker: llama.cpp's mtmd wraps Gemma 4 images in
+        # <|image>…<image|> itself, as its chat path does (V13 spike). The
+        # template writes <|image|> for an image part; Gemma 3's doesn't.
+        image_template: "%{marker}",
+        image_check_token: "<|image|>"
       )
     end
 

data/lib/samagotchi/plugin/context.rb

@@ -25,9 +25,11 @@ module Samagotchi
     # model's memory overlay key (ctx.model, ctx.model_key).
     # +steer+ takes (text, label), +stop_turn+ and +stop_generation+
     # (reason, label), each true when it acted on a running turn.
+    # +frontend+ returns the Engine's interface (:repl, :worker,
+    # :non_interactive), which ctx.frontend names for plugins.
     Host = Struct.new(:session_id, :cwd, :messages, :messages_partial, :notify, :ask_user, :cancelled, :card,
                       :ask_model, :model_name, :model_key, :state_dir, :scratch, :llm_context, :steer, :stop_turn, :stop_generation,
-                      keyword_init: true)
+                      :frontend, keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -103,6 +105,16 @@ module Samagotchi
       # Whether the session is a `chi scratch` one (deleted when it ends).
       def scratch? = !!@host.scratch&.call
 
+      # ctx.frontend's values, by the Engine's interface.
+      FRONTENDS = { repl: :repl, non_interactive: :one_shot, worker: :worker }.freeze
+
+      # What runs the session, read now (the host sets it after the plugins
+      # load): :repl (the REPL, -p without --non-interactive), :one_shot
+      # (-p --non-interactive: one turn, then exit) or :worker (a session
+      # worker: the web, an attached TUI). A host without one is :worker.
+      # @return [Symbol]
+      def frontend = FRONTENDS.fetch(@host.frontend&.call, :worker)
+
       # Whether the session is a delegate child (Session#delegate?): a task
       # another session handed over, not the user's own.
       def delegate? = !!saved_session&.delegate?

data/lib/samagotchi/prompt.rb

@@ -59,30 +59,45 @@ module Samagotchi
       [text + prefill_for(messages, profile, prefill), images]
     end
 
-    def self.image_lines(items, profile, images)
-      return "" if items.empty?
+    # A message's image lines: +text+ holds them all in order (what goes
+    # inside the message); +placeholders+ and +markers+ split the lines of
+    # images not sent from the sent ones' media markers, for Gemma's tool
+    # response, whose markers go after the block.
+    ImageLines = Data.define(:lines) do
+      def text = join(lines)
+      def placeholders = join(lines.reject(&:last))
+      def markers = join(lines.select(&:last))
+
+      private
+
+      def join(subset) = subset.empty? ? "" : "\n#{subset.map(&:first).join("\n")}"
+    end
 
+    def self.image_lines(items, profile, images)
       lines = items.each_with_index.map do |item, index|
-        next item.placeholder unless item.sent?
-        next ImageRef.placeholder(item.ref, ImagePlan::CANT_SEE) unless profile.image_template
+        next [item.placeholder, false] unless item.sent?
+        next [ImageRef.placeholder(item.ref, ImagePlan::CANT_SEE), false] unless profile.image_template
 
         images << item.data
-        "[image #{index + 1}: #{ImageRef.name(item.ref)}] " \
-          "#{Kernel.format(profile.image_template, marker: ImagePlan::NATIVE_PLACEHOLDER)}"
+        ["[image #{index + 1}: #{ImageRef.name(item.ref)}] " \
+         "#{Kernel.format(profile.image_template, marker: ImagePlan::NATIVE_PLACEHOLDER)}", true]
       end
-      "\n#{lines.join("\n")}"
+      ImageLines.new(lines: lines)
     end
 
     def self.format_with_turn_markers(messages, profile, suffixes)
       last_user = messages.rindex { |m| m[:role] == "user" } || -1
       parts = messages.each_with_index.map do |m, index|
-        content = prompt_content_for(m, profile) + suffixes[index]
+        lines = suffixes[index]
+        content = prompt_content_for(m, profile) + (m[:role] == "tool_response" ? lines.placeholders : lines.text)
         previous = index.positive? ? messages[index - 1][:role] : nil
         following = messages[index + 1]&.dig(:role)
         case m[:role]
         when "tool_response"
-          # Inside the model's turn; closed when another role follows.
-          tool_response_blocks(content, profile) +
+          # Inside the model's turn; closed when another role follows. Its
+          # sent images go after the blocks, outside the quoted value, as
+          # Gemma's chat template puts them; placeholder lines stay inside.
+          tool_response_blocks(content, profile) + lines.markers +
             (following && following != "tool_response" && following != "model" ? "#{profile.turn_end}\n" : "")
         when "model"
           content = strip_gemma_thought(content) if index < last_user && !content.include?(profile.tool_call_open)
@@ -136,7 +151,7 @@ module Samagotchi
       parts = []
 
       messages.each_with_index do |m, index|
-        content = prompt_content_for(m, profile) + suffixes[index]
+        content = prompt_content_for(m, profile) + suffixes[index].text
         case m[:role]
         when "system"
           parts << "#{profile.system_prefix}#{content}<|im_end|>\n"

data/lib/samagotchi/prompt_literal_guard.rb

@@ -16,7 +16,10 @@ module Samagotchi
       ["[[SAMAGOTCHI_LITERAL_GEMMA_STRING_DELIM]]", '<|"|>'],
       ["[[SAMAGOTCHI_LITERAL_THINK_OPEN]]", "<|think|>"],
       ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_OPEN]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN],
-      ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_CLOSE]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE]
+      ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_CLOSE]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_SOFT]]", "<|image|>"],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_START]]", "<|image>"],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_END]]", "<image|>"]
     ].freeze
 
     QWEN_TOKEN_PAIRS = [

data/lib/samagotchi/terminal_ui/question_prompt.rb

@@ -2,6 +2,7 @@
 
 require_relative "question_slot"
 require_relative "../turn_flow"
+require_relative "../question_desk"
 
 module Samagotchi
   class TerminalUI
@@ -80,9 +81,15 @@ module Samagotchi
         "  waiting in parent #{@relayed_to} too (answering here works)" if @relayed_to
       end
 
+      # The line a question dismissed in a --non-interactive run leaves (no
+      # one could answer it there): the REPL's own, and an attached UI's on
+      # its cancel (QuestionDesk::UNANSWERABLE_REASON).
+      UNANSWERABLE_TEXT = "(dismissed: no one to answer in a non-interactive run)"
+
       # What a question closed with no answer here says: a relayed approval
       # names where it went; else "(question cancelled)".
       def closed_text(reason)
+        return UNANSWERABLE_TEXT if reason.to_s == QuestionDesk::UNANSWERABLE_REASON
         return CONTINUE_CLOSED.fetch(reason.to_s, "(question cancelled)") if continue?
         return "(question cancelled)" unless @delegate
 

data/lib/samagotchi/terminal_ui.rb

@@ -1356,7 +1356,7 @@ module Samagotchi
     # dismissed it.
     def dismiss_unaskable_question(prompt)
       @engine.cancel_question(QuestionDesk::UNANSWERABLE_REASON) rescue nil
-      banner(prompt.summary("(dismissed: no one to answer in a non-interactive run)", paint: method(:paint)))
+      banner(prompt.summary(QuestionPrompt::UNANSWERABLE_TEXT, paint: method(:paint)))
       false
     end
 

data/lib/samagotchi/tools/task_runtime.rb

@@ -213,7 +213,7 @@ module Samagotchi
         return record unless record["status"] == "running"
 
         pid = record["pid"]
-        return record if chis_group?(record)
+        return record if chis_group?(record, started: record["pid_started"])
         # Gone: its exit code says how it ended.
         return mark_finished_without_exit_code(record) if ProcessGroup.signalable?(pid) && !ProcessGroup.alive?(pid)
 
@@ -222,8 +222,9 @@ module Samagotchi
 
       # Whether the record's pid still leads its own group. With +started+
       # (the start time recorded at task_create), also the same process: a
-      # ps per call, so only task_stop asks it, just before the signal;
-      # a refresh (each task_wait poll, task_list) checks the group only.
+      # ps per call on macOS (~5 ms), asked by each refresh (task_list,
+      # task_get, each task_wait poll) so a reused pid reads as exited, and
+      # by task_stop again just before the signal.
       def chis_group?(record, started: nil) = ProcessGroup.leader?(record["pid"], started: started)
 
       # A running record whose pid isn't a group chi started (NOT_CHIS_PROCESS)

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/vision_support.rb

@@ -73,9 +73,9 @@ module Samagotchi
       return no("the server gives no media marker (update llama.cpp)") unless media_marker(props)
       return no("profile #{profile&.name || "?"} has no image template yet") unless profile&.image_template
 
-      open = profile.image_open_token
-      unless open.empty? || body["chat_template"].to_s.include?(open)
-        return no("the server's chat template doesn't use #{open} (profile #{profile.name})")
+      check = profile.image_check_token
+      unless check.empty? || body["chat_template"].to_s.include?(check)
+        return no("the server's chat template doesn't use #{check} (profile #{profile.name})")
       end
 
       Answer.new(value: true, reason: nil)

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

@@ -2265,10 +2265,15 @@ const streamHandlers = {
     if (view.resync) await resync();
     // A card's action that isn't anytime (the step-limit question's
     // /continue) has no bubble: nothing to remove. An anytime or queued
-    // one's bubble was drawn at its command_queued: filled in here.
+    // one's bubble was drawn at its command_queued: filled in here. One
+    // queued for after the turn ran after it: its bubble moves from among
+    // the turn's rows to after its answer and timing line.
     const queued = view.anytime || view.queued ? commandBubble(view.commandId) : null;
     if (view.hidden) queued?.remove();
-    else if (queued) drawCommandBubble(queued, view);
+    else if (queued && view.queued && !view.anytime) {
+      queued.remove();
+      addCommandBubble(view);
+    } else if (queued) drawCommandBubble(queued, view);
     else addCommandBubble(view);
   },
   // An anytime command (/help, a plugin's /btw) runs at once, beside a

metadata

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