samagotchi 0.27.0 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b91f830918a3f58dac1d54820450ec90b4caa2d8f970b3fab03c8a0199b3ac2e
-  data.tar.gz: 1d1f0f1dc839247801be1462a895e8a57e189a68882fbaeb5a7707fdb4add0ab
+  metadata.gz: 581b7b0fa7184fb49a83588921656f2f91f05ae04538592e69874ba1207b686c
+  data.tar.gz: 4c381eb155ab69b933cda29461a02b111910adfb53309bb38ffc5819dfc764d6
 SHA512:
-  metadata.gz: 398faa2152be479cf78093fb9c752158932a2c186bf1fa5fd1ee9a622895bf742f82f1a25c843febfb877c826cee869623ee9871c50154015fdb54d02a490054
-  data.tar.gz: 35a4b45af554dd9cfd79c87d67ed7d819d14759421f8f669ac769ddbb1b37a64f5b0c79101f15a002ebdb4a2e2e9bee1def9eead820d50f61312c9f4a8cc41c8
+  metadata.gz: 84b0ba1d65c4c5d41fcbee9e925934f6fd6ee1eb4b46bb35af98b46cde28f9ad334ab56ff44e1ee503f0f7f9dab107d03429c145c7097fa35f90aa8ab86f1f4f
+  data.tar.gz: 7725dc03f4d5c9d42e7a5c4cae0ba5729740a6d95d37fb04c7bdcc611489907b039ad2ec9b0770c7f47ff04fc681d750309988825896c0e90c1e5b7c0dda3605

data/CHANGELOG.md

@@ -8,6 +8,68 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [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
+
+- Desktop: the panel's footer says where its text and images came from, "from clipboard" (the hotkey) or "from
+  selection" (Send to chi); run `chi desktop upgrade`.
+- `cache.ttl: 1h` keeps a Claude model's prompt-cache breakpoints for an hour instead of 5 minutes (a write costs 2×
+  the input price instead of 1.25×; off by default), and `cache.key: session` sends the session id as
+  `prompt_cache_key` to OpenAI's API and OpenRouter (off by default).
+- `chi sessions list` marks a session whose last turn loop-guard stopped with `[looped]` (another hook:
+  `[stopped by <name>]`); `--format json` carries `stopped_by`.
+
+### Changed
+
+- Past `image.max_per_request` images, the oldest are left out in batches of half the limit instead of one per new
+  image, so the earlier conversation stays a cacheable prefix; the placeholder reads "an older image (chi sends up
+  to the newest N)".
+- After loop-guard cuts a runaway reply, chi's retry note tells the model to continue the task with its next tool
+  call (or answer if it's done) instead of "answer briefly", which made models wrap up in the middle of a task.
+
+### Fixed
+
+- REPL: a line typed ahead during a turn no longer starts a turn-end warm-up that the next turn throws away.
+- Web: when one of a task's stop buttons is clicked, the other one (the stage's step list) disables too.
+- Desktop: `chi desktop install` starts the helper with a bare env, so `SAMAGOTCHI_*` settings (and anything else)
+  from the install shell no longer stick to the helper and the chi it runs until a relaunch; run `chi desktop upgrade`.
+- Desktop: ⌘⏎ on the panel's "New session" row says "A note needs a session" instead of only beeping, and the Note
+  button is off on that row; run `chi desktop upgrade`.
+- Desktop: the panel lists live sessions in the order they started, so ⌘1…⌘9 no longer shift when a session runs a
+  turn (a new session comes last); run `chi desktop upgrade`.
+
+Update with `chi update`, then `chi desktop upgrade` if you use the desktop helper.
+
 ## [0.27.0] - 2026-10-04
 
 ### Added
@@ -1438,7 +1500,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.27.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.29.0...HEAD
+[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
 [0.25.0]: https://github.com/dm1try/samagotchi/compare/v0.24.0...v0.25.0

data/docs/cli.md

@@ -495,9 +495,12 @@ A model that can see images gets them these ways:
 Images are downscaled to a 1568 px long side (with `sips` on macOS or
 ImageMagick; without either, a larger image is refused with a hint) and stored
 next to the session in `<session>/images/`, and the session file keeps small
-references to them. Each request sends the newest 20 images of the conversation;
-older ones become a line like `[image shot.png 1280×800 not sent: only the
-newest 20 images are sent]`.
+references to them. Each request sends up to the newest 20 images of the
+conversation (`image.max_per_request`); past that the oldest are left out ten at
+a time (half the limit), so the earlier conversation stays the same between
+requests and the server's prompt cache keeps it. A left-out image becomes a line
+like `[image shot.png 1280×800 not sent: an older image (chi sends up to the
+newest 20)]`.
 
 A model that can't see images (a text-only model, llama.cpp without
 `--mmproj`, an mlx host) refuses a turn with images before sending it:

data/docs/configuration.md

@@ -519,8 +519,20 @@ OpenAI-compatible host get two prompt-cache breakpoints (`cache_control` on the
 message), so each step reads the earlier prompt from Anthropic's cache instead of paying for it again. The system
 prompt goes as two text parts, the breakpoint after the first: everything sessions share, then the model, working
 directory and session lines, so a new session reads the shared part from the cache as well; the debug
-log's line shows `cache=on`. Nothing to configure. A provider behind a gateway may still not cache: check the
-cached tokens in `/stats`. Each request's own counts are in the debug log's `generation_completed` line:
+log's line shows `cache=on`. A provider behind a gateway may still not cache: check the cached tokens in `/stats`.
+
+Anthropic drops a cache entry 5 minutes after its last read, so a session you come back to after a longer pause
+writes its prompt again. `cache.ttl: 1h` keeps the breakpoints an hour (the log shows `cache=1h`); a write then
+costs 2× the input price instead of 1.25×, so it pays off when you often pause 5–60 minutes between turns.
+`cache.key: session` sends the session id as `prompt_cache_key` (OpenAI's API and OpenRouter only; the log shows
+`cache_by=session`), which OpenAI uses to route a conversation to the machine that holds its cache:
+
+```yaml
+cache:
+  ttl: 1h        # 5m (default) or 1h
+  key: session   # off (default) or session
+```
+ Each request's own counts are in the debug log's `generation_completed` line:
 `prompt=` (its prompt tokens), `cached=` (read from the server's cache) and `cache_write=` (written to it, when the
 server reports writes); recap and side requests log theirs as `recap request_usage`.
 
@@ -784,7 +796,7 @@ downscaled first; three settings bound them (env `SAMAGOTCHI_IMAGE_*` or
 image:
   max_side: 1568          # long side in px (Claude's standard; ~1.3k tokens for 1280×800)
   max_bytes: 3750000      # larger after downscaling → re-encoded as JPEG
-  max_per_request: 20     # older images in the conversation become placeholder lines
+  max_per_request: 20     # older images become placeholder lines, dropped in batches of half this
 ```
 
 Whether a model can see images is found out before a turn with images is sent:
@@ -899,6 +911,8 @@ described in their own sections.
 | `hosts.<name>.remote` | by address | | `true`/`false`: treat the host as a remote provider or a local server. See "Remote or local". |
 | `max_tool_output_chars` | `10000` | yes | Tool output kept in the conversation; a top-level key (see below). |
 | `cache.warmup` | `auto` | | `auto`: after a turn, send the next turn's prompt (up to the next message) to a local llama.cpp host on the native loop, so the next turn prefills only its message; never a remote or `api: openai` host. `off`: never. See [prompt caching](internals/prompt-caching.md#the-turn-end-warm-up). |
+| `cache.ttl` | `5m` | | How long Anthropic keeps the prompt-cache breakpoints of a Claude model on a remote host: `5m` (Anthropic's default) or `1h`. A 1h cache write costs 2× the input price (5m: 1.25×), a read the same 0.1×. See "Remote or local". |
+| `cache.key` | `off` | | `session`: send the session id as `prompt_cache_key` to OpenAI's API and OpenRouter, which route and cache by it; no other host gets it. `off`: none. |
 | `retry.max` | `5` | yes | See "Llama Network Retry Behavior". |
 | `retry.base_delay` | `0.5` | yes | |
 | `retry.max_delay` | `8.0` | yes | |

data/docs/internals/prompt-caching.md

@@ -43,9 +43,9 @@ right-hand column happens.
  shared by every turn of this session ─────────────────────────────────────
 ┌──────────────────────────────────────────────────────────────────────────┐
 │ history      user / assistant / tool messages, APPEND-ONLY               │  !rollback, a failed or
-│              (images: the newest N, ImagePlan)                           │  cancelled turn's tail,
-│                         ◄── remote Claude: breakpoint #2 on the last     │  the image window
-│                             non-system message                           │  sliding, history
+│              (images: up to the newest N, cut in batches; ImagePlan)     │  cancelled turn's tail,
+│                         ◄── remote Claude: breakpoint #2 on the last     │  the image cut moving
+│                             non-system message                           │  a batch, history
 ├──────────────────────────────────────────────────────────────────────────┤  sanitizing (thinking
 │ tail notes   reminders, turn notes, steers (system/user messages)        │  stripped per spec)
 │ new prompt   this turn's user message                                    │
@@ -83,7 +83,39 @@ user message starts (`KernelLoop#warmup_prompt`) and sends it in a thread (`Clie
   server has since cleared skips its prompt cache and prefills everything (measured 0.5 s → 12 s). For the same
   reason `id_slot` is a reserved sampling key.
 - What breaks it (the warm-up simply misses): a system-prompt rebuild (`/thinking`, `/model`, a tool change),
-  the image window sliding, `!rollback`.
+  the image cut moving a batch, `!rollback`.
+
+## The image window
+
+A request sends at most `image.max_per_request` images (20 by default); older ones become placeholder lines
+(`[image a.png 1280×800 not sent: an older image (chi sends up to the newest 20)]`). If the window slid by one
+image per new image, every new image would turn the oldest sent one into a placeholder and rewrite history from
+there. So the cut is a pure function of the image count (`ImagePlan.dropped_count`): nothing is dropped up to
+the limit, then the oldest in whole steps of half the limit (21–30 images drop 10, 31–40 drop 20). Between two
+step boundaries the earlier messages stay byte-identical; at a boundary the history from the newly cut image on
+is prefilled once. The native and the chat loop use the same plan.
+
+## Remote caches: TTL and routing
+
+- **TTL.** Anthropic keeps a breakpoint 5 minutes after its last read; a session the user comes back to later
+  writes its prompt again. `cache.ttl: 1h` sends `cache_control: {type: "ephemeral", ttl: "1h"}` on both
+  breakpoints (the log line shows `cache=1h`). Off by default: a 1h write costs 2× the input price, a 5m write
+  1.25×, a read 0.1× either way, so 1h pays off only when pauses of 5–60 minutes are common.
+- **Routing.** Every chat request carries a `Session-Id` header, which OpenRouter uses to keep a conversation on
+  one provider. `cache.key: session` also sends the session id as `prompt_cache_key` in the body, the field
+  OpenAI's API routes and caches by (OpenRouter honours it too); the log line shows `cache_by=session`. Only
+  `api.openai.com` and OpenRouter get it, and only the session's own chat requests (not recap or `/btw`): a local
+  llama.cpp, Splash or another gateway may reject an unknown field. Off by default.
+
+## Reading the numbers
+
+- The debug log's `generation_completed` line: `prompt=` (the request's prompt tokens), `cached=` (read from the
+  server's cache) and `cache_write=` (written to it, where the provider reports writes). The `http` line of a
+  remote Claude request shows `cache=on` (or `cache=1h`) when it carried breakpoints.
+- The warm-up logs `model warmup` with `cached=`, `prefilled=` and `prefill_ms=`.
+- `/stats`: "cached N (P%)" and "cache writes" for the session.
+- A healthy session: from the second request on `cached=` is close to `prompt=`; a second fresh session in the
+  same project reads everything up to the volatile tail.
 
 ## Rules for changes
 
@@ -114,7 +146,6 @@ user message starts (`KernelLoop#warmup_prompt`) and sends it in a thread (`Clie
   a slot (`id_slot`) is the hazard. With `--cache-ram 0` or an old single-slot build, a recap does evict the
   session. `--ctx-checkpoints` controls how many restore points a hybrid model keeps. chi sends
   `cache_prompt: true` on every native request.
-- **OpenRouter / Anthropic:** the default cache TTL is 5 minutes. Provider routing (which upstream serves a
-  request) also decides whether a cache is there to hit.
+- **OpenRouter / Anthropic:** the default cache TTL is 5 minutes (`cache.ttl: 1h` for an hour, see above).
+  Provider routing (which upstream serves a request) also decides whether a cache is there to hit.
 
-Still to come: image-window batches and longer remote TTLs.

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 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.
 

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/system/manifest.yml

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

data/lib/samagotchi/config.rb

@@ -142,6 +142,14 @@ module Samagotchi
       # prompt on a local llama.cpp host while the user reads; off never
       # does. A :string, since YAML reads an unquoted off as false.
       Entry.new(key: "cache.warmup",             yaml_path: %w[cache warmup],             type: :string, default: "auto",           expose: %i[env config]),
+      # How long Anthropic keeps a cache breakpoint (PromptCache): 5m, or
+      # 1h for long reading gaps (a 1h write costs 2x the input price, a 5m
+      # one 1.25x, so it's opt-in).
+      Entry.new(key: "cache.ttl",                yaml_path: %w[cache ttl],                type: :string, default: "5m",             expose: %i[env config]),
+      # session sends the session id as `prompt_cache_key` to OpenAI's API
+      # and OpenRouter (OpenAIChat), which route and cache by it; off sends
+      # none. A :string, since YAML reads an unquoted off as false.
+      Entry.new(key: "cache.key",                yaml_path: %w[cache key],                type: :string, default: "off",            expose: %i[env config]),
 
       Entry.new(key: "retry.max",                yaml_path: %w[retry max],                type: :integer, default: 5,               expose: %i[env config cli]),
       Entry.new(key: "retry.base_delay",         yaml_path: %w[retry base_delay],         type: :float,   default: 0.5,             expose: %i[env config cli]),

data/lib/samagotchi/desktop/macos/App.swift

@@ -18,7 +18,7 @@ final class ServiceProvider: NSObject {
       error.pointee = "No text or image in the selection" as NSString
       return
     }
-    app?.open(text: text, images: images)
+    app?.open(text: text, images: images, origin: "selection")
   }
 }
 
@@ -60,12 +60,14 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
   /// The hotkey doesn't activate us, so the frontmost app is the source.
   func openFromClipboard() {
     let (text, images) = ImageIntake.read(NSPasteboard.general)
-    open(text: text, images: images)
+    open(text: text, images: images, origin: "clipboard")
   }
 
-  func open(text: String, images: [PanelImage] = []) {
+  /// @param origin "clipboard" (the hotkey) or "selection" (the Service)
+  func open(text: String, images: [PanelImage] = [], origin: String) {
     let from = sourceApp
-    panel.show(text: text, images: images, source: from?.localizedName?.lowercased() ?? "desktop", returnTo: from)
+    panel.show(text: text, images: images, origin: origin, source: from?.localizedName?.lowercased() ?? "desktop",
+               returnTo: from)
   }
 }
 

data/lib/samagotchi/desktop/macos/ChiRunner.swift

@@ -118,11 +118,13 @@ final class ChiRunner {
                       stdin: stdin, timeout: timeout ?? self.timeout, completion: completion)
   }
 
-  /// The live sessions, then up to +recentCount+ stopped ones, newest
-  /// first. A session a chi REPL holds is in neither: it takes no notes or
+  /// The live sessions, oldest started first, then up to +recentCount+
+  /// stopped ones, newest first. The live order is by creation so ⌘1…⌘9
+  /// stay on their sessions as turns update them; a new one comes last.
+  /// A session a chi REPL holds is in neither: it takes no notes or
   /// messages. A failed second call just leaves "recent" empty.
   func sessions(recentCount: Int = 3, completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
-    list(["--live"]) { result in
+    list(["--live", "--sort", "created_at", "--order", "asc"]) { result in
       guard case .success(let live) = result else { completion(result); return }
       self.list(["--limit", "20"]) { recent in
         let liveIds = Set(live.map(\.id))

data/lib/samagotchi/desktop/macos/Panel.swift

@@ -20,6 +20,9 @@ final class PanelModel: ObservableObject {
   /// The selection or clipboard: the quoted context of a message, or a note.
   @Published var text = ""
   @Published var source = ""
+  /// The path the opening text and images took: "clipboard" (the hotkey)
+  /// or "selection" (the Service); "" when the panel opened empty.
+  @Published var origin = ""
   /// Sent as `--image` with a message; notes are text only.
   @Published var images: [PanelImage] = []
   /// The thumbnail under the pointer (shows its ✕). Kept here, not in a
@@ -74,8 +77,9 @@ final class PanelModel: ObservableObject {
   }
   var live: [LiveSession] { sessions.filter { !$0.recent } }
 
-  /// One list for rows, ⌘ numbers and selection: live sessions, then kitty
-  /// windows, then recent sessions.
+  /// One list for rows, ⌘ numbers and selection: live sessions (oldest
+  /// started first: their numbers stay put), then kitty windows, then
+  /// recent sessions.
   var targets: [Target] { live.map(Target.chi) + kittyWindows.map(Target.kitty) + recent.map(Target.chi) }
 
   /// Up to maxImages; the rest is dropped (and its temp files deleted).
@@ -534,9 +538,17 @@ struct PanelView: View {
       .padding(.horizontal, 8).padding(.vertical, 4)
       .background(Capsule().fill(Color.primary.opacity(0.07)))
 
-      Text(byteLabel)
-        .font(.system(size: 11).monospacedDigit())
-        .foregroundColor(model.bytes > noteCap ? .red : .secondary)
+      HStack(spacing: 0) {
+        if !model.origin.isEmpty {
+          Text("from \(model.origin) · ").foregroundColor(.secondary)
+            .help(model.origin == "clipboard" ? "opened with the hotkey: the text and images are the clipboard's"
+                                              : "opened with Send to chi: the text and images are the selection")
+        }
+        Text(byteLabel).foregroundColor(model.bytes > noteCap ? .red : .secondary)
+      }
+      .font(.system(size: 11).monospacedDigit())
+      .lineLimit(1)
+      .fixedSize()
 
       Text(model.message)
         .font(.system(size: 11))
@@ -554,8 +566,9 @@ struct PanelView: View {
           .help("paste it into the agent's input without Enter: add more, then press Enter there")
       } else {
         Button("Note ⌘⏎") { send(.note) }
-          .disabled(!model.sendEnabled || !model.selectedKitty.isEmpty)
-          .help("add it as background the model sees on its next turn; starts no turn")
+          .disabled(!model.sendEnabled || !model.selectedKitty.isEmpty || model.newSelected)
+          .help(model.newSelected ? "a note needs a session: pick one, or ⏎ starts a new one with the message"
+                                  : "add it as background the model sees on its next turn; starts no turn")
       }
       Button(action: { send(.message) }) {
         if model.phase == .sending { ProgressView().controlSize(.small) } else { Text("Send ⏎") }
@@ -753,8 +766,9 @@ final class PanelController: NSObject, NSWindowDelegate {
     return true
   }
 
+  /// @param origin "clipboard" or "selection": where text and images came from
   /// @param returnTo the app to give focus back to on close
-  func show(text: String, images: [PanelImage] = [], source: String, returnTo app: NSRunningApplication?) {
+  func show(text: String, images: [PanelImage] = [], origin: String, source: String, returnTo app: NSRunningApplication?) {
     returnTo = app
     // A show on an open panel resets it without a close.
     dropImages()
@@ -762,6 +776,7 @@ final class PanelController: NSObject, NSWindowDelegate {
     model.images = []
     model.add(images)
     model.text = text
+    model.origin = text.isEmpty && images.isEmpty ? "" : origin
     model.source = source
     model.message = ""
     model.newSelected = false
@@ -873,13 +888,18 @@ final class PanelController: NSObject, NSWindowDelegate {
       model.message = "Paste only is for kitty windows"
       return
     }
+    // A note into a session that doesn't exist yet makes no sense.
+    if kind == .note, new {
+      NSSound.beep()
+      model.message = "A note needs a session"
+      return
+    }
     if kind == .note, !model.images.isEmpty {
       NSSound.beep()
       model.message = "Notes are text only: ⏎ sends the image as a message"
       return
     }
-    // A note into a session that doesn't exist yet makes no sense.
-    guard model.sendEnabled, new ? kind == .message : !(ids.isEmpty && windows.isEmpty) else { NSSound.beep(); return }
+    guard model.sendEnabled, new || !(ids.isEmpty && windows.isEmpty) else { NSSound.beep(); return }
     model.phase = .sending
     model.message = ""
     if !new {

data/lib/samagotchi/desktop/macos.rb

@@ -310,7 +310,11 @@ module Samagotchi
         # type may otherwise show only after a re-login).
         @runner.run([LSREGISTER, "-f", app_path])
         @runner.run([PBS, "-update"])
-        @runner.run(["open", "-g", app_path])
+        # open hands the app its own env, so the install shell's
+        # (SAMAGOTCHI_* knobs, tokens) would stay in the helper and in every
+        # chi it runs until a relaunch. Through env -i the app gets launchd's
+        # bare env, as at login; launch.json carries what chi needs.
+        @runner.run(["/usr/bin/env", "-i", "HOME=#{@env["HOME"] || Dir.home}", "/usr/bin/open", "-g", app_path])
       end
 
       def quit

data/lib/samagotchi/engine.rb

@@ -1780,7 +1780,7 @@ module Samagotchi
     # A caller's check that the next turn starts at once (input queued for
     # it: a worker's inbox) or that none follows (a one-shot run): no
     # warm-up then. nil: neither.
-    attr_writer :next_turn_waiting
+    attr_accessor :next_turn_waiting
 
     # After a completed turn, prefill the next turn's prompt up to its user
     # message while the user reads (PromptWarmup, cache.warmup). Only on a
@@ -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/kernel_loop.rb

@@ -372,13 +372,20 @@ module Samagotchi
       return unless turn.on_stream_event
 
       event = { type: :generation_chunk, iteration: turn.iteration, content: chunk[:content], text: split[:text],
-                thinking: split[:thinking], payload: chunk[:payload] }
+                thinking: split[:thinking], payload: event_payload(chunk[:payload]) }
       # A chunk of a tool call (its bytes are dropped from both lanes): a
       # steer doesn't cut this generation (Engine#cut_for_steer).
       event[:tool_call] = true if split[:tool]
       emit(turn, **event)
     end
 
+    # The payload a :generation_chunk event carries: llama.cpp's last chunk
+    # echoes the whole rendered prompt, which nothing reads and every SSE
+    # client would get (the kernel's own reads keep the full payload).
+    def event_payload(payload)
+      payload.is_a?(Hash) ? payload.except("prompt") : payload
+    end
+
     # The payload's prompt-cache counts, kept as the largest seen.
     def note_cache_counts(generation, payload)
       counts = TokenUsage.from_payload(payload)