samagotchi 0.28.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51c7c1a00eec47f70f15b04381eb6b60f5bd6c66c8dd11fbe05ef045c41d5219
-  data.tar.gz: 00cbfcba1b3b21ef54c9d54bd9de349a90a19314cb5613e9daa94ca51c8c04fe
+  metadata.gz: 7af50a3a7e90170a9d6b4f3f5ab5914a0ab536ea121b498779109dabfb7c0b51
+  data.tar.gz: 4ddba29c753f1a6900956cc5abbbef70c3d912286e252c4c9adf08534a773368
 SHA512:
-  metadata.gz: 11f14c97b088efe1c1eafafb63604f44c84a7a7a79d738db5f6344191b6fa9948ceab37acd0f8daba2a85840b3f272bfcd767bd2147b0da7abbc23a04936bba4
-  data.tar.gz: e3136af1decc273b092f66756e2994ad0760a626cb9b007a4a4ad2f68ee85bdf6f37aab3f5a0bde85597f677bde3fde32826763c9b44001e941945abc39dfa5d
+  metadata.gz: 497f4731e7a4ca9c1bd5073bea8e897506d37a5fcdfd15ea394f5837edfc85d76fbaade739ec4f6de998f7da5a982c3a8a9c1d4674b1e218a50ab14fe673291b
+  data.tar.gz: 0c6428021607e8540dcb21801510eca0295be3fba2de0e09eb4c2fd3c2c362326301065b52c5bc7745e006768522312d1934659da4cacc93254560402c767e76

data/CHANGELOG.md

@@ -8,6 +8,87 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.30.0] - 2026-10-05
+
+### Added
+
+- chi saves the model ids each host last listed (`~/.local/state/samagotchi/model_lists.json`), so a command that
+  starts a session without listing the hosts itself knows what they serve.
+- `chi send --new --model` and the `delegate` tool's `model:` warn about a model id the named host's saved list
+  doesn't have: `host 'box' doesn't list model 'gemma-smal' (did you mean: gemma-small?); started it anyway`, on
+  stderr / in the tool's result. The session still starts: some hosts serve ids they don't list (a one-model
+  llama.cpp server takes any name, OpenRouter's `:nitro`). A name that names no host, a host with no saved list, and
+  a list over a week old are not checked.
+
+### Changed
+
+- Web: an open step whose label is its narration's first line or its first call's title shows only its call count,
+  so it doesn't repeat the words its body starts with; closed, the label is unchanged.
+- Web stage: an answered turn says its step count once (in the cloud's chip) and its time once (in the status row).
+- Web stage: `execute` and the task tools are blue in the running-tool row and the ticks, as in the tool rows under
+  them; purple is thinking's colour only (other tools' ticks are a quieter blue-grey).
+- Web stage: `edit` and `write` are blue in the running-tool row and the ticks too, as in the tool rows; green is a
+  finished call's `✓` and an answered turn's only.
+
+### Fixed
+
+- A command the user's Stop killed (or kept from starting) is saved as `stopped`, not `error`: the web shows it with
+  ■ and `stopped`, and the turn's `(N failed)` and the session's tool errors no longer count it.
+- Web: the stop-task confirm names a task from an earlier turn by its command (the wait row's title), not its id.
+- Web: a canceled turn's end line (the Stop, Ctrl-C, a hook, the session's stop) reads `■ canceled (stopped)` in the
+  stopped calls' amber, live and after a reload, not as a red error; a worker that exited mid-turn stays red `✕`.
+- Web stage: a call the Stop cut has an amber tick and an amber `■` in the trail, as its `■ STOPPED` row, instead of
+  its tool kind's colour.
+- A call still running when its turn is canceled is saved in the session's tool records as `stopped` (was
+  `canceled`), the word its row uses; one cut by a failed turn stays `canceled`.
+- A canceled turn's last step keeps the thinking it streamed, so reloading it shows the thought instead of an empty
+  step (both loops).
+- A plain REPL (`--no-shared`) keeps its session's `pending_card.json` as a worker does, so `chi web` marks a session
+  waiting on an open card it showed.
+- source-links: a ref that names its own repo (`other/repo#12`) takes `{host}` from the git remote only when the
+  source's `remote_host:` lists that host, so it can't link to the local checkout's host.
+- Web stage: the running-tool row no longer reads `thinking…` once the turn has ended (answered, canceled or
+  failed): it is idle, with no word.
+- The REPL and attached mode end a canceled turn with an amber `■` (`■ turn canceled (Ctrl-C)`, `■ turn stopped by
+  loop-guard`), as the web does, instead of `✕`: a stop someone chose, not an error; a failed turn keeps `✕`.
+- Web stage: a call a guardrail blocked has a red tick and a red `✕` in the trail, as its `✕ BLOCKED` row, instead
+  of its tool kind's colour.
+- A command step with more than one heredoc (`-f body="$(cat <<EOF …)" -f title="$(cat <<EOF …)"`) cuts every body
+  out of its text, and its chip says so: `EOF · 3 lines +1`, with all of them on hover.
+- A session worker survives a failed save between turns too (its first prompt, a command, taken notes, a dropped
+  question): it logs it and keeps going; notes whose save failed are kept and saved on the next pass.
+
+Update with `chi update` (source-links 0.3.4, mcp 0.4.4) and restart `chi web`.
+
+## [0.29.0] - 2026-10-05
+
+### Added
+
+- Web: a session card shows `looped` when loop-guard stopped its last turn (`stopped by <name>` for another hook),
+  like `chi sessions list`'s `[looped]`; the all-sessions search finds them by those words.
+- `chi bundle install` warns when a bundle needs a newer chi and its guardrail rules won't load (it already warned
+  about its hooks and plugin).
+
+### Changed
+
+- Web: a tool row shows its status as a mark (✓, ✕, ■, a spinner while it runs) instead of the word, so its command,
+  output and diff start right under the tool name; error, stopped and blocked calls keep their word after the title.
+  An open step's body sits indented under its summary.
+- Web: a step with a failed call says so in its collapsed label, `3 tool calls (1 failed)`, with a red chevron; the
+  turn's summary counts failed calls below 3 calls too.
+- Web: a `task_wait`, `task_get` or `task_stop` row names its task by the task's command instead of its id, a wait with
+  how long it waits (`bundle exec rspec · up to 600s`), also for a task started in an earlier turn; the id line stays
+  on hover.
+
+### Fixed
+
+- Guardrails: `> /tmp/x cat <<EOF` (a redirection written with a space before the command) is read as a heredoc of
+  data like `cat > /tmp/x <<EOF`, and a `)` inside quotes or a heredoc body no longer ends a `$(…)` early.
+- `!cmd` no longer hands a `--model` worker's model to a chi it runs as the default model.
+- A session worker survives a failed save at the end of a turn (it logs it) instead of crashing.
+- A turn that ends with an empty answer removes only its own retry note, not an earlier turn's cancel or failure note.
+- Web: streamed chunks from llama.cpp no longer carry its whole echoed prompt to every web client.
+
 ## [0.28.0] - 2026-10-04
 
 ### Added
@@ -1471,7 +1552,9 @@ 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.28.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.30.0...HEAD
+[0.30.0]: https://github.com/dm1try/samagotchi/compare/v0.29.0...v0.30.0
+[0.29.0]: https://github.com/dm1try/samagotchi/compare/v0.28.0...v0.29.0
 [0.28.0]: https://github.com/dm1try/samagotchi/compare/v0.27.0...v0.28.0
 [0.27.0]: https://github.com/dm1try/samagotchi/compare/v0.26.0...v0.27.0
 [0.26.0]: https://github.com/dm1try/samagotchi/compare/v0.25.0...v0.26.0

data/docs/cli.md

@@ -849,12 +849,12 @@ While a turn runs, you can cancel it without exiting the process:
 Behavior notes:
 
 - Cancellation returns control to the prompt immediately; what you typed there stays.
-- The turn ends with one line, `✕ turn canceled (Ctrl-C) · 3.1s`, and for a prompt turn a dim
+- The turn ends with one line, `■ turn canceled (Ctrl-C) · 3.1s` (`■`, a stop someone chose, in amber), and for a prompt turn a dim
   `partial progress kept; !rollback restores the pre-turn state` under it (a canceled continue is back where it
   started). A failed turn ends with `✕ turn failed: <summary> · 2.0s` and a dim `prompt restored for retry`. The
-  REPL and attached mode say the same; the web says `✕ canceled (Ctrl-C)` (`stopped` for its Stop button,
-  `by a hook` for a hook's). A turn a bundle's plugin stopped names it: `✕ turn stopped by loop-guard` (the web:
-  `✕ stopped by loop-guard`).
+  REPL and attached mode say the same; the web says `■ canceled (Ctrl-C)` (`stopped` for its Stop button,
+  `by a hook` for a hook's). A turn a bundle's plugin stopped names it: `■ turn stopped by loop-guard` (the web:
+  `■ stopped by loop-guard`).
 - Visible text the canceled request had streamed stays in the conversation, marked `[interrupted]`, so the next
   message (or a continue) picks up from the half-finished reply; the canceled request's thinking and any unfinished
   tool call are dropped.

data/docs/hooks.md

@@ -179,7 +179,7 @@ What a cut is, in detail:
 - It is an empty answer made early: it uses the `retry.empty_answer` budget
   ([configuration.md](configuration.md#llama-network-retry-behavior)). With
   no retry left (`retry.empty_answer: 0`, or already used) and nothing
-  queued, the turn ends cancelled (hook): "✕ turn canceled (hook)".
+  queued, the turn ends cancelled (hook): "■ turn canceled (by a hook)".
 - It shows nothing by itself: post your own notice (`event[:notify]`) to say
   why. The bundle and the reason go into the note the model reads and the
   log (`generation_stopped`).

data/docs/plugins.md

@@ -863,7 +863,7 @@ What happens (`action: retry`, the default):
    `loop-guard> thinking repeats itself ("Wait, the count of the letter r…", 3 sentences ×3, 4k chars, 8 s): cut`
    (a short run or a window says how many different sentences it held:
    "12 different sentences in 48"), and `↻ cut by loop-guard, asking again (1/1)`.
-2. If the retry loops too, the turn is stopped ("stopped the turn: …", "✕
+2. If the retry loops too, the turn is stopped ("stopped the turn: …", "■
    turn stopped by loop-guard") with a card that quotes the repeated
    sentences.
 3. A loop is forgotten after `forget_after` good steps in a row (generations

data/docs/sessions.md

@@ -56,7 +56,7 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 
 `--dry-run` is the safe preview. `--keep N` keeps the N newest sessions that stay: one that goes anyway (a leftover scratch session, one left empty, one older than `--days`) takes no place in the count. Web has no prune endpoint; use the CLI.
 
-`chi sessions list` shows each session's saved recap, its first sentence without the "The user was…" opening (as on the web cards), in place of its last prompt, cut to 60 characters; a session with no recap shows its last prompt. A session whose last turn a hook stopped carries `[looped]` when the hook was loop-guard (the thinking watch's cut, or its stop) and `[stopped by <hook>]` for any other hook, after `[archived]` (`--format json` has it as `stopped_by`; from `Session#last_turn`, so it stays until a later turn ends differently). A delegated session's row ends with `↳ <parent's short id>` (plain and `--live`; `--format json` has `parent_id`); rows keep their `updated_at` order, so a parent may be on another page than its children. After the status, `ctx 12%` says how full the context was after the session's last counted turn (from its `analytics.json`; blank when no turn had a server count or the window is unknown; `ctx_pct` in `--format json`). The web's session cards show it quietly too (`12%`), and a session's ctx meter shows it on load, before its next turn streams.
+`chi sessions list` shows each session's saved recap, its first sentence without the "The user was…" opening (as on the web cards), in place of its last prompt, cut to 60 characters; a session with no recap shows its last prompt. A session whose last turn a hook stopped carries `[looped]` when the hook was loop-guard (the thinking watch's cut, or its stop) and `[stopped by <hook>]` for any other hook, after `[archived]` (`--format json` has it as `stopped_by`; from `Session#last_turn`, so it stays until a later turn ends differently). The web's session cards wear the same marker as a badge: `looped` or `stopped by <hook>` after the status dot (a session that also waits on you shows only its waiting badge: the stop is behind the need), and the all-view's search matches its words too. A delegated session's row ends with `↳ <parent's short id>` (plain and `--live`; `--format json` has `parent_id`); rows keep their `updated_at` order, so a parent may be on another page than its children. After the status, `ctx 12%` says how full the context was after the session's last counted turn (from its `analytics.json`; blank when no turn had a server count or the window is unknown; `ctx_pct` in `--format json`). The web's session cards show it quietly too (`12%`), and a session's ctx meter shows it on load, before its next turn streams.
 
 **Projects:** a session belongs to the git project it was started in: the repository, whichever worktree or subfolder of it (the same project root memories use). `chi sessions list` (with `--live` and `--format` too) and `chi web` show the current folder's project; `--scope=all` shows every session, and so does a folder in no repo (`~`). `--cwd PATH` is a folder filter instead of the project. The project is stored with the session (`project_root` in its JSON, `project` in `--format json`), so a session keeps it after its worktree is deleted; sessions older than that are placed by their folder, and one whose folder is gone shows in `--scope=all` only. Retention, `--resume`/`--attach ID`, `chi send`/`chi note ID` and `chi note --all` (every live session) are not scoped. The agent's `list_sessions` lists its own project's sessions; `cwd: "/"` lists every one.
 
@@ -168,7 +168,7 @@ chi send --wait -m "and the tests?" 3fa2               # a follow-up in the same
 chi send --wait 3fa2                                   # sends nothing: waits for its next reply
 ```
 
-- `--new` takes no ids (one new session per call). `--dir DIR` is its folder, and so its project (default the current one); `--model M` its model (default the configured one; the name isn't checked up front, a wrong one fails the worker's first turn).
+- `--new` takes no ids (one new session per call). `--dir DIR` is its folder, and so its project (default the current one); `--model M` its model (default the configured one). A host config.yml doesn't have is refused before anything is spawned (exit 1). A `host:id` whose id that host's last saved list doesn't have (`~/.local/state/samagotchi/model_lists.json`, what `chi models` / `/models` / the web last listed for that host, at most a week old) gets one warning line on stderr, with up to three close ids as a hint (`did you mean: gemma-small?`), and the session starts anyway: some hosts serve ids they don't list (a one-model llama.cpp server takes any name). A bare id (no `host:`) isn't checked that way — routing sends it to whichever host lists it — and with no saved list for the host nothing is said; a wrong id then fails the worker's first turn.
 - `--new` prints `<full id>  started` on stdout. With `--wait` that line (and the `sent` line for an existing session) goes to stderr, so stdout is exactly the answer: the reply of the turn the message started, in full. It is the worker's `output/` file, the same one `delegate` reads; a turn that ends with only tool calls and no text has none.
 - `--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 run after it, and its reply would come back as the answer.
 - 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.
@@ -179,7 +179,7 @@ chi send --wait 3fa2                                   # sends nothing: waits fo
 
 ## Delegating
 
-The `delegate` tool hands a task to a **child session**: an ordinary chi session in a worker of its own, started in the parent's `working_directory` with the task, verbatim, as its first user message, on the parent's model unless the call names one (`model:` takes a name or an alias, resolved as `--model` is; nothing checks the host serves it, so an unknown one fails the child's first turn). Children run in parallel and only their **final reply** comes back to the parent: the child's newest `output/<timestamp>.txt` file, which the worker writes at the end of each turn that produced visible text, cut head-and-tail like an `execute` result. Nothing of the child's trace enters the parent's context. Nothing is hidden: a child shows in `chi sessions list` (`↳ <parent>`), the web (a `↳` chip on its card, `delegated by` in its info bar, listed right after its parent in the all-sessions view) and the `list_sessions` tool (`child`; the parent shows as `parent` in the child's own list); the user can `chi --attach <child id>` and steer it mid-run, and `chi send` and `send_note` reach it like any session.
+The `delegate` tool hands a task to a **child session**: an ordinary chi session in a worker of its own, started in the parent's `working_directory` with the task, verbatim, as its first user message, on the parent's model unless the call names one (`model:` takes a name or an alias, resolved as `--model` is; an unknown host comes back as the tool's `Error:` line; an id the host's saved model list doesn't have starts the child with a `Warning: host 'h' doesn't list model 'x' (did you mean: …?)` line in the result). Children run in parallel and only their **final reply** comes back to the parent: the child's newest `output/<timestamp>.txt` file, which the worker writes at the end of each turn that produced visible text, cut head-and-tail like an `execute` result. Nothing of the child's trace enters the parent's context. Nothing is hidden: a child shows in `chi sessions list` (`↳ <parent>`), the web (a `↳` chip on its card, `delegated by` in its info bar, listed right after its parent in the all-sessions view) and the `list_sessions` tool (`child`; the parent shows as `parent` in the child's own list); the user can `chi --attach <child id>` and steer it mid-run, and `chi send` and `send_note` reach it like any session.
 
 - `delegate(task, model:, session:, wait:, timeout:)`: starts a child and, by default, waits for its reply (`wait: false` returns at once, so several children can run side by side; `timeout`, default 600 s, leaves a slow child running; 0 checks once without waiting). With `session:` (a child's id or prefix) the task goes to that child as a follow-up instead, delivered like `chi send` (client id `delegate:<parent short id>`, shown as `delegate>` in the child's UIs); only this session's children take one.
 - `delegate_result(session:, timeout:)`: waits for a child's next reply: the one named, or the newest running child (`timeout` as for `delegate`: 0 checks once and returns at once). The reply comes back once; a later call waits for the next one.

data/lib/samagotchi/bundle_command.rb

@@ -36,7 +36,8 @@ module Samagotchi
         build [--scope system|project] [--name NAME] [--version VER] [--description DESC] [--out PATH] [FILES...]
           Build local memories and installed hooks (and plugin) into a shareable bundle (dir or zip).
           --scope selects source dir (default: system). --out inferred from extension; default <name>.zip.
-          FILES... optional allowlist of *.md basenames to include (default: all but installed bundles' ones).
+          FILES... optional allowlist of *.md basenames to include (default: all but installed bundles' ones);
+          a named memory brings its model overlays (<name>.<model-key>.md).
 
         trash [--empty] [--dry-run] [--older-than DAYS]
           List bundle trash (moved files from uninstalls/upgrades).
@@ -61,7 +62,8 @@ module Samagotchi
         build [--scope system|project] [--name NAME] [--version VER] [--description DESC] [--out PATH] [FILES...]
           Build local memories and installed hooks into a shareable bundle (dir or zip).
           --scope selects source dir (default: system). --out inferred from extension; default <name>.zip.
-          FILES... optional allowlist of *.md basenames to include (default: all but installed bundles' ones).
+          FILES... optional allowlist of *.md basenames to include (default: all but installed bundles' ones);
+          a named memory brings its model overlays (<name>.<model-key>.md).
 
         Examples:
           chi bundle build --scope system

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

@@ -1,11 +1,11 @@
 ---
 name: mcp
-version: 0.4.3
+version: 0.4.4
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:079a42892f10822115235e1ced7ccd481f80c9ef54abb094f9a1c599bb03e8e2
+  sha256: sha256:05543038e2950a5391655184f57a1028133eda8ca05f9e46e5cd2eddc3e9e608
 requires_chi: ">= 0.8.0"

data/lib/samagotchi/bundles/mcp/plugin.rb

@@ -18,11 +18,12 @@
 #           attach_image_paths: true  # default: an image path in the text, in the
 #                                     # temp dir or cwd, attaches it
 #
-# Image blocks in a result go to the model as images (text: "[image 1:
-# image/png, attached]"); so does an image file named in a text block,
+# Image blocks in a result go to the model as images (the text keeps
+# "[image 1: image/png]"); so does an image file named in a text block,
 # under the system temp dir or the server's cwd: the block is only its
 # absolute path (chrome-devtools-mcp --slim answers a screenshot that way),
-# or it says one ending in an image extension ("Saved it to /tmp/a.png.").
+# or it says one ending in an image extension ("Saved it to /tmp/a.png."),
+# noted as "[image 1: a.png]".
 # A server that doesn't start, answer or list its tools is skipped with a
 # notice; the rest of chi works. One that exits mid-session starts again on
 # its next call, at most MAX_RESTARTS times a session. /mcp lists the

data/lib/samagotchi/bundles/source-links/hooks/source_links.rb

@@ -40,8 +40,12 @@ require "open3"
 # A `url:` template takes {match} (group 1, else the whole ref), {1}…{9}
 # (numbered groups), {name} (named groups), and {repo}/{host}: the named
 # group when it took part, else the project's (Dir.pwd's) git remote, asked
-# of git once per worker. A ref with a placeholder that can't be filled is
-# not linked; a `{word}` that is none of these stays text (warned at load).
+# of git once per worker. A {repo} the ref itself names ("other/repo#12")
+# is that ref's own, so its {host} comes from the remote only when the
+# source's `remote_host:` list has the remote's host: else the ref would
+# link to this checkout's host with someone else's repo. A ref with a
+# placeholder that can't be filled is not linked; a `{word}` that is none
+# of these stays text (warned at load).
 #
 # The note is not stored in the conversation: it is an event, replayed by a
 # UI only while the session's worker lives (a reload keeps it; a stopped
@@ -457,7 +461,7 @@ class SourceLinks
     when /\A\d+\z/ then match[word.to_i]&.then { |value| escape_url(value) }
     when "repo", "host"
       value = match.names.include?(word) ? match[word] : nil
-      value ||= remote_value(word, source)
+      value ||= remote_value(word, source, repo_from_match: match.names.include?("repo") ? match["repo"] : nil)
       word == "repo" ? escape_repo(value) : value&.then { |host| escape_url(host) }
     else match[word]&.then { |value| escape_url(value) }
     end
@@ -466,7 +470,16 @@ class SourceLinks
   # {repo} / {host} from the project's git remote (the source's `remote:`,
   # default origin); nil when there is none, or when its host is not one of
   # the source's `remote_host:` list.
-  def remote_value(word, source)
+  #
+  # +repo_from_match+: the match's own {repo}, when it has one. Such a ref
+  # names its own repo (`other/repo#12`), not the local checkout's, so its
+  # {host} may only come from the remote when the source lists that remote's
+  # host (remote_host:): else the ref would link to the local remote's host
+  # with someone else's repo.
+  def remote_value(word, source, repo_from_match: nil)
+    derived_host = word == "host" && !repo_from_match.to_s.empty?
+    return nil if derived_host && source[:remote_hosts].empty?
+
     remote = project_remote(source[:remote])
     return nil unless remote
 

data/lib/samagotchi/bundles/source-links/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: source-links
-version: 0.3.3
+version: 0.3.4
 scope: system
 description: Links source refs (JIRA tickets, GitHub issues, …) in the model's answer — inline links in the web, and a one-line note after the turn (note false turns it off); sources are configured patterns
 trust_level: reviewed
@@ -8,7 +8,7 @@ files:
   source_links.md: sha256:aebd37f1e25491780994ecc4afc20ed6e8db32b724dc038302bb050177efada8
 hooks:
   source_links.rb:
-    sha256: sha256:454d3512a4aa078b288ff6d0ed25867222a56ead1a57ef1eaa14918e631fec23
+    sha256: sha256:c93269964ebc824b5f15ab60db81a458facd50de61446c550f254ea4c68964e2
     event: after_turn
     on_error: log
     priority: 90

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

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

data/lib/samagotchi/command_steps.rb

@@ -9,7 +9,9 @@ module Samagotchi
   # command as the model wrote it. Rules, in order:
   #
   # - a heredoc's body leaves its step's text and becomes its +heredoc+
-  #   ({tag:, lines:}), also one inside a "$(cat <<'EOF' … EOF)" argument;
+  #   ({tag:, lines:}), also one inside a "$(cat <<'EOF' … EOF)" argument; a
+  #   step with more than one is cut of them all, and lists them as
+  #   +heredocs+ (+heredoc+ stays the first; the web's chip names it, +N);
   # - steps are split at && || ; | |& & and newlines; a ( … ) subshell stays
   #   one step; +op+ is the operator before a step (nil for the first);
   # - a leading "cd X &&" / "cd X;" becomes +cd+ (only the first);
@@ -23,8 +25,8 @@ module Samagotchi
   #   parentheses) gives nil: the UI then shows the title and the raw
   #   command.
   module CommandSteps
-    Step = Data.define(:text, :op, :label, :limit, :heredoc) do
-      def initialize(text:, op: nil, label: nil, limit: nil, heredoc: nil) = super
+    Step = Data.define(:text, :op, :label, :limit, :heredoc, :heredocs) do
+      def initialize(text:, op: nil, label: nil, limit: nil, heredoc: nil, heredocs: nil) = super
 
       def to_h = super.compact
     end
@@ -122,29 +124,47 @@ module Samagotchi
 
       slice = text[from...to]
       heredoc = body && { tag: bodies[body.last], lines: body_lines(text[body.last]) }
-      slice, heredoc = inner_heredoc(slice) unless heredoc
-      Step.new(text: slice.strip, op: op, heredoc: heredoc)
+      slice, heredocs = inner_heredocs(slice) if heredoc.nil?
+      Step.new(text: slice.strip, op: op, heredoc: heredoc || heredocs&.first,
+               heredocs: heredocs && heredocs.size > 1 ? heredocs : nil)
     end
 
-    # A heredoc inside a $(…) in +slice+ (git commit -m "$(cat <<'EOF' …)"):
-    # the slice with the body cut out, and the heredoc; or the slice as is.
-    def inner_heredoc(slice)
-      return [slice, nil] unless slice.include?("<<")
+    # Every heredoc inside a $(…) in +slice+ (git commit -m "$(cat <<'EOF'
+    # …)"): the slice with all their bodies cut out, and the heredocs ([] for
+    # none). One step can hold several ("-f body=$(cat <<EOF …)" and
+    # "-f title=$(cat <<EOF …)"), and the rest of the step is text the reader
+    # would otherwise see.
+    def inner_heredocs(slice)
+      heredocs = []
+      return [slice, heredocs] unless slice.include?("<<")
 
       at = 0
       while (open = slice.index("$(", at))
         lexer = Lex::Lexer.new(slice[(open + 2)..])
         lexer.tokens
         doc = lexer.heredoc_spans.first
-        if doc
-          from = open + 2 + doc[:span].begin - 1 # the newline before the body
-          to = open + 2 + doc[:span].end
-          to += 1 if slice[to] == "\n"
-          return [slice[0...from] + slice[to..], { tag: doc[:tag], lines: body_lines(slice[(from + 1)...to]) }]
+        unless doc
+          at = open + 2
+          next
         end
+
+        from = open + 2 + doc[:span].begin - 1 # the newline before the body
+        to = open + 2 + doc[:span].end
+        to += 1 if slice[to] == "\n"
+        heredocs << { tag: doc[:tag], lines: body_lines(slice[(from + 1)...to]) }
+        cut = slice[0...from] + slice[to..]
+        # A span that cut nothing (it can't) would loop here: move past it.
+        if cut.length >= slice.length
+          at = open + 2
+          next
+        end
+
+        slice = cut
+        # The cut moved everything after it left; keep looking from the same
+        # spot, past this "$(".
         at = open + 2
       end
-      [slice, nil]
+      [slice, heredocs]
     end
 
     # The body's line count, its terminator line not counted.

data/lib/samagotchi/engine.rb

@@ -1942,11 +1942,12 @@ module Samagotchi
       # that way: the note, and nothing made up as its answer. The note's
       # marker is for the UIs (the notice, and the empty steps after a
       # reload); it goes on the result's conversation too (the REPL keeps it).
-      # A retry's nudge at the tail goes: this note says it all.
+      # A retry's nudge at the tail goes: this note says it all. An earlier
+      # turn's note stays: it says why that turn ended.
       if result.empty_answer?
         note = TurnNote.empty(retries: result.empty_retries, steps: result.empty_steps)
-        conversation&.replace(TurnNote.without_trailing(conversation))
-        saved = TurnNote.without_trailing(conversation || turn.session.messages)
+        conversation&.replace(TurnNote.without_trailing_nudge(conversation))
+        saved = TurnNote.without_trailing_nudge(conversation || turn.session.messages)
         conversation << note if conversation
         saved + [note]
       elsif result.canceled? && conversation

data/lib/samagotchi/guardrails/shell_lex.rb

@@ -169,19 +169,76 @@ module Samagotchi
           add(SUBST, close + 1 - @i)
         end
 
+        # From $( to the ) that closes it, as one SUBST. A quote or a
+        # heredoc body inside it is skipped over: a ) in one of those
+        # doesn't close the substitution.
         def substitution
           depth = 0
           j = @i + 1
           loop do
-            depth += 1 if @s[j] == "("
-            depth -= 1 if @s[j] == ")"
-            j += 1
-            break if depth.zero? || j >= @s.size
+            break if j >= @s.size
+
+            c = @s[j]
+            if ["'", '"'].include?(c)
+              j = quote_end(j)
+            elsif c == "("
+              depth += 1
+              j += 1
+            elsif c == ")"
+              depth -= 1
+              j += 1
+              break if depth.zero?
+            elsif @s[j, 2] == "<<"
+              j = substitution_heredoc(j)
+            else
+              j += 1
+            end
           end
           @unterminated = true unless depth.zero?
           add(SUBST, j - @i)
         end
 
+        # The index after the quote starting at +j+, a backslash in a double
+        # quote escaping the next character; the text's end when it is never
+        # closed.
+        def quote_end(j)
+          quote = @s[j]
+          k = j + 1
+          while k < @s.size
+            if quote == '"' && @s[k] == "\\" then k += 2
+            elsif @s[k] == quote then return k + 1
+            else k += 1
+            end
+          end
+          k
+        end
+
+        # From a << at +j+ inside a $(…) past its body's terminator line
+        # (nothing is lexed: the body is only stepped over), or on to the
+        # next character when no tag follows or the terminator never comes
+        # (a << that is no heredoc, as arithmetic's 1<<3, stays scanned).
+        def substitution_heredoc(j)
+          dash = @s[j + 2] == "-"
+          k = j + (dash ? 3 : 2)
+          k += 1 while [" ", "\t"].include?(@s[k])
+          tag, _quoted, stop = heredoc_tag(k)
+          return j + 1 if tag.empty?
+
+          eol = @s.index("\n", stop)
+          return j + 1 if eol.nil?
+
+          k = eol + 1
+          while k < @s.size
+            eol = @s.index("\n", k) || @s.size
+            line = @s[k...eol]
+            line = line.sub(/\A\t+/, "") if dash
+            return [eol + 1, @s.size].min if line == tag
+
+            k = eol + 1
+          end
+          j + 1
+        end
+
         def comment
           @i = @s.index("\n", @i) || @s.size
         end
@@ -306,10 +363,27 @@ module Samagotchi
         def data_sink?(at)
           start = at
           start -= 1 while start.positive? && @tokens[start - 1][0] == :word
-          verb = @tokens[start...at].map { |t| t[1] }.find { |w| !w.match?(/\A[A-Za-z_]\w*=/) && !w.match?(REDIRECT) }
+          verb = command_word(@tokens[start...at])
           next_op = @tokens[at..].find { |t| t[0] == :op }
           DATA_SINKS.include?(File.basename(verb.to_s)) && !["|", "|&"].include?(next_op&.dig(1))
         end
+
+        # The command word among the words before a heredoc's: the NAME=
+        # words and the redirections dropped, and with a redirection written
+        # with a space (> /tmp/x) its target word too.
+        def command_word(words)
+          i = 0
+          while i < words.size
+            word = words[i][1]
+            if word.match?(REDIRECT)
+              i += 1 if word.match?(/\A\d*[<>]{1,2}\z/)
+            elsif !word.match?(/\A[A-Za-z_]\w*=/)
+              return word
+            end
+            i += 1
+          end
+          nil
+        end
       end
     end
   end

data/lib/samagotchi/host_registry.rb

@@ -5,6 +5,7 @@ require_relative "config"
 require_relative "log"
 require_relative "model_ref"
 require_relative "client"
+require_relative "model_list_store"
 require_relative "llm/openai_chat"
 
 module Samagotchi
@@ -287,6 +288,9 @@ module Samagotchi
             models = list_models_for(entry)
             data = { host: entry.host, port: entry.port, transport: entry.transport, models: models, error: nil }
             @mutex.synchronize { @host_lists[name] = { data: data, at: @clock.call } }
+            # On disk too: a process that spawns a worker without listing
+            # (`chi send --new --model`, delegate) checks an id against it.
+            ModelListStore.save(name, models.map(&:id))
           rescue StandardError => e
             Log.warn(:model, "list_failed", host: name, error: e.class.name, msg: e.message.to_s[0, 500])
             data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: e.message }