samagotchi 0.42.0 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d41b91ef2514e877a756d7f66ba02f58b65c7d85f7446728b02ec06f652299b3
-  data.tar.gz: 37e0869508863e5db69395b847ac147101f60a79208a5ba9e789e3427eb9716e
+  metadata.gz: 684d8e5c169b4ce5df4cd21c4c46d0ef8524230e530d3e90ec2076f5b674e905
+  data.tar.gz: 54dbaf8bd2ad38b78e16aca155414748491912bdaebe1069f128e6182df7bfe5
 SHA512:
-  metadata.gz: abb02fdd05aec927500fbb42a750b9da3dc9e1c8e24cbc55bfdc933e797e206ee8e3a3502d0a4074804b0342f856726d2b04d2eb15c2aa61682e23439bca38ea
-  data.tar.gz: 681406d11e96949fd168b252a6717fe2f6dcfaa765400bf66a43a7131dc4440ff7f077312f3ccd219ddce8c05e88f15e4bc808c52652d265beed59eed89c8c1c
+  metadata.gz: de459298c279f571db785d374e1752a58060d26a13c4f7a6d22f8c4e4a5c82acbcffecd5784712eda405908cc3a8fd7bf1526952878b3791017088ebb62f120e
+  data.tar.gz: a99cf35d53b0a9fb7b3ed568a73d3383252ba334e4c8efd50efd9d97ded3cb716432fd51ee069e066ce3d21d137f1fadf49e20f2b99e9a769e430c8274278a64

data/CHANGELOG.md

@@ -8,6 +8,50 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.44.0] - 2026-10-08
+
+### Added
+
+- LLM context edits are visible: each batch of stubs that reaches the prompt gets a ✂ row in its step, in the web
+  and the terminal (`✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid off)`), whose web hover
+  lists the outputs, a stale stub's reason, a forget's note and kept lines, and the cost. After a reload a stubbed
+  output's tool row carries a ✂ mark (`✂ stubbed: superseded by a later read · ~1.0k tokens`, `✂ forgotten: <note>`,
+  `✂ forget staged`). The stream has a new event, `llm_context_edited`. See
+  [docs/configuration.md](docs/configuration.md) ("LLM context: what you see (✂)").
+
+### Fixed
+
+- Under an `llm_context.budget_tokens` budget without the forget layer (strategy `none` or `stale`), the model's
+  `[CONTEXT: …]` line said "of the context window" for a percentage of the budget; it now reads "about 62% of the
+  context budget (64k tokens) is in use", and its top bucket no longer asks the model to "summarize aggressively"
+  ("context budget critical — avoid large outputs and re-reads, delegate broad work to subagents").
+
+## [0.43.0] - 2026-10-08
+
+### Added
+
+- A new web chat can start under its own LLM context: the start page has an `llm ctx` chip beside the model
+  picker that shows the picked model's strategy, and its form (as the info bar's, titled "new chat") sets a
+  strategy, apply rule and budget for that chat's first turn on (`llm ctx stale · new chat`). The choice is not
+  remembered: it resets after a create, on a reload and when you open a session, and an untouched chip sends
+  nothing. `POST /api/sessions` takes
+  `llm_context` (`{strategy, apply, budget}` as `/llm-context` words them; anything else answers
+  `400 invalid_llm_context`), and `GET /api/models` rows carry each model's `llm_context`. See
+  [docs/configuration.md](docs/configuration.md) ("LLM context: a session's own strategy").
+- The web's `ctx` chip shows the context window and where it came from: its tooltip gains `context: ~41.0k of
+  128.0k tokens (server)`, and the chip reads `ctx ~12%` when the window is chi's 256k default, a guess no server,
+  model list or setting gave (the tooltip says to set `window_tokens` for the model).
+- github-pr 0.3.0: `bundles: github-pr: auto_attach:` says what happens to the branch's open PR when a worker
+  starts: `attach` (the default, as before), `offer` (a card, "PR #42 for branch feat/x", with **Attach** and **Not
+  here**, shown once per session; `/pr-attach 42` and `/pr-decline 42`) or `off` (nothing). In `offer` mode the
+  offers, what you clicked and each session's first prompt go to a local log, `plugins/github-pr/offers.ndjson` in
+  the state dir. See [docs/context.md](docs/context.md) ("Attach, offer or off").
+- For plugins: `ctx.context.decline(url:|name:)`, `declined?(name, url:)`, `attach(…, force: true)` (the user's
+  explicit choice, past a decline) and `mark_offered(name, hint)` / `offered(name)`, a per-session record that a
+  plugin offered a source. See [docs/plugins.md](docs/plugins.md) ("Attached context").
+
+Update with `chi update`: it updates github-pr (0.3.0: `auto_attach`; needs chi 0.43.0).
+
 ## [0.42.0] - 2026-10-08
 
 ### Added
@@ -1982,7 +2026,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.42.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.44.0...HEAD
+[0.44.0]: https://github.com/dm1try/samagotchi/compare/v0.43.0...v0.44.0
+[0.43.0]: https://github.com/dm1try/samagotchi/compare/v0.42.0...v0.43.0
 [0.42.0]: https://github.com/dm1try/samagotchi/compare/v0.41.0...v0.42.0
 [0.41.0]: https://github.com/dm1try/samagotchi/compare/v0.40.0...v0.41.0
 [0.40.0]: https://github.com/dm1try/samagotchi/compare/v0.39.0...v0.40.0

data/docs/configuration.md

@@ -900,6 +900,24 @@ models:
 - `/stats` counts the re-prefilled tokens each applied batch costs; `script/llm_context_bench.rb --strategy
   forget_outputs` replays the offer on stored sessions (docs/internals/llm-context-bench.md).
 
+## LLM context: what you see (✂)
+
+Every edit is shown; the session keeps the originals.
+
+- **A ✂ row** for each batch of stubs that reaches the prompt (`stale`'s, a `forget_outputs` call's, or the ones
+  staged until a turn's end), in the step it came in, in the web and the terminal alike:
+  `✂ forgot 2 outputs, stubbed 1 stale read · frees ~4.1k tokens (paid off)`. It says why it went now (`paid off`,
+  `the context is nearly full`, `at turn end`; nothing under `next_request`) and how many stubs stay staged. In the
+  web, its hover lists each output (its id, tool and path or command), a stale stub's reason, a forget's note once
+  with the lines it keeps, the tokens it frees and the tail the server reads again. A batch held back, the warm-up's
+  own copy and a restore show no row (the `forget_outputs` row says what a restore did). A reload puts the rows back
+  where they were (`cards.json`, its own cap of 20, apart from hook notices).
+- **A ✂ mark** on a tool row after a reload, above its output, when the model is sent a stub for it:
+  `✂ stubbed: superseded by a later read · ~1.0k tokens`, `✂ forgotten: <note>`, `✂ forgotten with t41` (the
+  other outputs of the call whose row carries the note), `✂ forget staged`, and `· lines 12-40 kept`.
+  The running turn's rows get theirs on the next reload.
+- Tokens are estimates (chars/4), hence the `~`.
+
 ## LLM context: a session's own strategy
 
 A session can set its own `llm_context` strategy, apply rule and budget, which come before the model's, its host's
@@ -909,6 +927,14 @@ its own). The first target is a long session such as a day-long coordinator, whe
 - **Set it** at start with `chi --llm-context stale,forget --llm-context-apply turn_end --llm-context-budget 64k`
   (the same flags on `chi send --new`), in the session with `/llm-context strategy … apply … budget …`
   (docs/cli.md, "Session commands"), or from the web's `llm ctx` chip in the info bar.
+- **A new web chat:** the start page's `llm ctx` chip, beside the model picker, shows the picked model's values
+  and follows a model pick. Its form (titled "new chat") sets a choice for that one chat: the chip reads
+  `llm ctx stale · new chat` in the accent colour, and the create sends it as `POST /api/sessions`'s
+  `llm_context` (`{"strategy": "stale,forget", "apply": "turn_end", "budget": "64k"}`, each a word as
+  `/llm-context` takes it, `default` for unset; anything else answers `400 invalid_llm_context` and starts
+  nothing), so the session file holds it before the first turn runs. It is not remembered: it resets after a
+  create, on a reload and when you open a session (a failed create keeps it), and an untouched chip sends nothing
+  (the model's values apply, as without the chip).
 - **Values:** `none` and a budget of `off` are values the session sets on purpose (they win over the model's);
   `default` (or `/llm-context reset` for all three) unsets one, back to following the model. A budget is 4k to
   10M tokens (`4000`–`10000000`, or `4k`–`10000k`). The layers are kept in chi's order (`stale`, then `forget`).

data/docs/context.md

@@ -175,6 +175,7 @@ It needs [`gh`](https://cli.github.com), logged in (`gh auth login`).
   the next start doesn't bring it back; `chi context add <PR URL>` or "+ URL"
   does.
 - `chi context add <PR URL>` and the web's "+ URL" attach any PR.
+- `auto_attach` (below) can make it ask first, or attach nothing.
 - The text: title, state, branch, description, reviews, comments (oldest
   first) and checks, every 5 minutes.
 - The summary says what changed in **counts, authors and states only**
@@ -184,6 +185,50 @@ It needs [`gh`](https://cli.github.com), logged in (`gh auth login`).
 - It wakes for a review requesting changes, checks turning red, and the PR
   merged or closed. Comments alone never wake.
 
+### Attach, offer or off
+
+```yaml
+bundles:
+  github-pr:
+    auto_attach: offer   # attach (the default) | offer | off
+```
+
+- `attach`: the branch's open PR is attached when the worker starts, as
+  above.
+- `offer`: nothing is attached; a card asks instead, once per session per
+  PR: **PR #42 for branch feat/x**, the PR's title and "Not attached: the
+  agent gets nothing until you attach it.", with **Attach** and **Not
+  here**. The terminal shows them as `→ /pr-attach 42` and
+  `→ /pr-decline 42`, to type. Attach attaches it as auto-attach would
+  (even after Not here: a click is your choice); Not here marks it removed
+  from the session, so `attach` mode won't attach it there either. Either
+  turns the card into a one-line notice. Not here on a PR that is attached
+  already changes nothing and says so: `chi context rm pr-42` removes it. A worker restart (idle exit,
+  resume) doesn't ask again; once the card has scrolled out of the last 20,
+  `/pr-attach 42` or "+ URL" still attaches it. `/pr-attach` and
+  `/pr-decline` act only on a PR offered in that session.
+- `off`: nothing is attached or offered. "+ URL", `chi context add <PR URL>`
+  and line links work as before.
+
+`true` and `false` (YAML reads a bare `on`/`off` as those) mean `attach` and
+`off`; an unknown value is `attach`, with a warning in the log. The setting
+is read when a worker starts.
+
+A web chat is created with its first message, so in `offer` mode the card
+arrives while that first turn runs: the first answer comes without the PR,
+and Attach delivers it before the next turn. An offered PR that isn't
+attached gets no line links (unless your message names its URL).
+
+In `offer` mode the bundle keeps a local log,
+`$XDG_STATE_HOME/samagotchi/plugins/github-pr/offers.ndjson`, to find out
+later when an offer is wanted: one JSON line per event, `offered` (session,
+project root, working directory, branch, PR URL, main checkout or worktree,
+model), `attached` and `declined` (with the seconds since the offer), and
+`first_prompt` (the first 160 characters of every session's first message,
+offered or not; not scratch sessions or delegate children). Over 1 MB it is
+renamed to `offers.ndjson.1` (one old file is kept). Only you can read it
+(0600), and nothing leaves your machine.
+
 ### Line links
 
 In the web, a file reference in an answer links to that line of the pull
@@ -256,6 +301,7 @@ sessions/<id>/<name>.json, …snapshot.json     a session's own
 sessions/<id>/subscriptions.json              what the session has seen and read (its worker writes it)
 sessions/<id>/muted/<name>                    a project source this session mutes
 sessions/<id>/declined/<name>                 a source you removed (its hint inside): auto-attach skips it
+sessions/<id>/offered/<name>                  a source a plugin offered here ({hint, why, at}): it isn't offered again
 ```
 
 Deleting a session deletes its folder. A source and its snapshot go with

data/docs/internals/context-telemetry.md

@@ -36,7 +36,10 @@ both loops):
 
 - `llm_context.budget_tokens` (or a model's or host's `llm_context_budget_tokens`): the buckets count against the
   budget instead of the window, the smaller of the two. The event's `window_tokens` and the status line's percentage
-  are of it too, and so is `payoff`'s top bucket.
+  are of it too, and so is `payoff`'s top bucket. Without the forget layer the model's line names it, `[CONTEXT:
+  about 62% of the context budget (64k tokens) is in use (…)]` (the window when that is the smaller), and its top
+  bucket reads "context budget critical — avoid large outputs and re-reads, delegate broad work to subagents": no
+  "summarize", as nothing in the model's hands shrinks the context.
 - The forget layer replaces the guidance with tiered offers of `forget_outputs`, each line a readout,
   `[CONTEXT: ~52k/64k tokens in use (bucket=60plus). …]`: the readout alone in the guided buckets below the top two
   (CLM: how-to at low pressure makes a model wipe everything); "Finish the unit of work in flight, then tidy once

data/docs/internals/engine.md

@@ -298,6 +298,7 @@ Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):
 | `:generation_cancelled` | the turn was cancelled mid-loop | `{iteration, reason, stopped_by}` |
 | `:empty_answer_retry` | an empty, cut or malformed answer is asked again | `{iteration, attempt, of, finish_reason, thinking_chars, stopped_by?, malformed?}` |
 | `:steer_cut` | a steer cut the generation | `{iteration, source}` |
+| `:llm_context_edited` | the apply rule applied a batch of LLM context edits (a request, a forget_outputs call, turn end; never the warm-up) | `{moment, why, freed_tokens, tail_tokens, staged, text, groups}` (`LLMContextNotice`) |
 | `:pending_input_merged` | queued input joined the conversation | `{iteration, count, content, steers?, answer}` |
 | `:tool_dispatch_started` / `:tool_dispatch_completed` | around a batch | `{iteration, call_count}` |
 | `:tool_call_started` | before a call runs | see ToolRunner |

data/docs/plugins.md

@@ -679,6 +679,9 @@ ctx.sessions.stop(id)      # one of this session's own children
 ctx.context.attach(url: "https://github.com/acme/app/pull/42", why: "branch feat/x has open PR #42")
 ctx.context.attach(name: "ci", cmd: "bin/ci-status", why: "this branch's CI", every_seconds: 120)
 ctx.context.list  # => [{name:, scope:, why:, hint:, fetched_at:, error:, provider:}]
+ctx.context.decline(url: "https://github.com/acme/app/pull/42")    # => "pr-42"
+ctx.context.mark_offered("pr-42", "https://github.com/acme/app/pull/42", why: "branch feat/x has open PR #42")
+ctx.context.offered("pr-42")  # => #<data Offer name="pr-42", hint="https://…", why="branch…", at="2026-10-08T…Z">, or nil
 ```
 
 [Attached context](context.md) for the session the plugin runs in: chi runs
@@ -691,13 +694,30 @@ gets a note when its text changes.
   command of the plugin's own. A source of that name already attached stays
   as it is. It returns the name, or nil when the user removed that name (or
   that URL) from the session: a plugin doesn't attach it again until the
-  user adds it (`ctx.context.declined?(name)` says so).
+  user adds it (`ctx.context.declined?(name, url: nil)` says so, by the
+  name or by the URL). `force: true` is for the user's own explicit choice
+  (a click on the plugin's card): it attaches anyway and clears the
+  declined marker, by the name and by the URL.
+- `decline(url:)` or `decline(name:)` marks the source declined in this
+  session, as the user's removal does: `attach` skips it from then on. With
+  `url:`, the name and hint come from the bundle's provider (`name:`
+  replaces the name). It returns the name. A source attached already stays
+  attached (`chi context rm` removes it).
+- `mark_offered(name, hint, why: nil)` records that the plugin offered a
+  source here (the hint is usually its URL; `why:` is kept for the attach
+  that may follow); `offered(name)` returns that record
+  (`ContextSources::Offer`: `name`, `hint`, `why`, `at`) or nil. A plugin that asks
+  before it attaches uses it so a worker restart doesn't ask again. Neither
+  an attach nor a decline clears it; deleting the session does.
 - The source is the session's (not the project's), marked
   `added_by: plugin:<bundle>`. It is plugin code, so it isn't asked about as
   the agent's `chi context add --cmd` is.
 - `list` gives the session's sources, its own then its project's.
-- `attach` raises `Samagotchi::Plugin::AttachedContext::Error` with the
-  reason (no session yet, no provider for the URL, a bad name).
+- Two attaches of one source at once (a double click) both return its
+  name.
+- `attach`, `decline` and `mark_offered` raise
+  `Samagotchi::Plugin::AttachedContext::Error` with the reason (no session
+  yet, no provider for the URL, a bad name).
 
 The [github-pr bundle](#the-github-pr-bundle) attaches the branch's PR from
 a quiet `chi.init` task.
@@ -1219,8 +1239,10 @@ nothing without `gh`, a repository or an open PR), and resolves PR URLs for
 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)). See [Attached
-context](context.md#github-prs-the-github-pr-bundle).
+of the session's PR ([Line links](context.md#line-links)). `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).
 
 ## The coordinator bundle
 

data/docs/sessions.md

@@ -65,7 +65,7 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 **Ordering:**
 
 - `Session.list` / `SessionManager.list_sessions` / `GET /api/sessions?sort=&order=&limit=&offset=` default to `updated_at desc` (newest activity first). Also supports `created_at`, `asc`. `X-Total-Count` header when paginated.
-- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat (`hide ▴` puts them away behind a `▾ N sessions` pill, remembered; in a window under 900 px wide, where the strip scrolls sideways, `▴ hide` sits in the top bar where the pill comes back; a window under 700 px tall hides them by itself, so a question or approval card in the stage keeps room, and the pill shows them until the window is tall again). A parent and its delegates are one card there: its `▸ 2 delegates · 1 live · 1 waiting` chip (the waiting part in the attention colour, the card's border too) opens their rows in a popover under it (a row per delegate at any depth, indented; a click opens that one, Esc or a click outside closes it, and the strip's order holds while it is open). A fork is a card of its own, and so is a delegate whose parent isn't listed (archived, another project), with its `↳ <parent>` chip; the pill counts cards, and every live or waiting session. "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). There a parent's card holds its delegates the same way, the chip opening their rows inside the card (each with an archive button on hover), open by itself while one of them waits on you; the count says `14 (+7 delegates)`, a search that matches a delegate shows its parent's card with the list open and the matching rows marked, and select mode picks cards (archiving a parent takes its delegates). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). The info bar copies `chi --attach <id>` for a terminal. A session whose prompt carried model notes has a `notes: deepseek` chip there (the names without `model_notes_`; the tooltip lists each with its scope and size; `session.prompt_notes` in `GET /api/sessions/:id`, the live worker's, else the session file's; see [Memory](memory.md#model-notes)). Its `llm ctx` chip names the LLM context strategy the next turn runs under (`llm ctx stale,forget · session`, in the accent colour when the session set its own; the tooltip gives each value's source), and its popover sets the session's own strategy, apply rule and budget, or follows the model again, by running `/llm-context` in the worker (the reply shows as a command bubble); `GET /api/sessions/:id`'s `session.llm_context` carries the values (the live worker's, else resolved from the session file), and a `command_ran` that changed them carries the new ones. It shows the context used (`ctx 42%`) and the last generation's decode speed (`87 tok/s`, `~64 tok/s` when estimated; see `/stats` in [cli.md](cli.md#session-commands)); hovering `ctx` there or on a session card lists the session's tokens in (summed over every request, with the cached share), out (with reasoning) and the cost when the provider reports one, for this session only, and the memory indexes its prompt holds (`memory index: ~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)`; see [Memory](memory.md#the-indexs-size)). The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first; typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id, sampling?}], warning?}`; `sampling` is the model's configured request parameters as `/model` words them, the row's tooltip in the list; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first line that is one of the new session's commands (`/model …`) goes to `POST /api/sessions/:id/command` instead, as later ones do. The browser remembers the last choice; a running session's model is in the info bar and changes only with `/model`. In the composer a line is a command when it is `!…` or starts with one of the session's command names (its `commands` list; `/stats`, `/exit` and the other terminal words get the page's own reply); an unknown `/word` (`/usr/bin/env is missing`) goes to the model as a prompt, as in a terminal; a one-word `/word` no command answers (`/modle`) is not sent: the page shows `Unknown command /modle. Did you mean /model? /help lists the commands.` (the "Did you mean" part only when a name is close). A `POST /turn` (or a session's first `prompt`) that is one of the worker's commands runs as that command too (`202 {status, command_id, session_id}`), so `chi send`, `chi -p` and a page whose command list lags all get the command. ↑/↓ in the composer walk the prompt history the TUI's ↑ walks ([Persistent Prompt History](cli.md#persistent-prompt-history)): ↑ with the caret on the first line, ↓ from the last line while browsing, ↓ past the newest brings the draft back; `GET /api/history` returns `{entries: [...]}`, oldest first (the page fetches it on focus and after each send). The server records a sent line in the routes once the worker took it (`POST /turn` accepted, a `!command` through `POST /command` or as a session's first line); `"history": false` in the body keeps it out (an image-only send).
+- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat (`hide ▴` puts them away behind a `▾ N sessions` pill, remembered; in a window under 900 px wide, where the strip scrolls sideways, `▴ hide` sits in the top bar where the pill comes back; a window under 700 px tall hides them by itself, so a question or approval card in the stage keeps room, and the pill shows them until the window is tall again). A parent and its delegates are one card there: its `▸ 2 delegates · 1 live · 1 waiting` chip (the waiting part in the attention colour, the card's border too) opens their rows in a popover under it (a row per delegate at any depth, indented; a click opens that one, Esc or a click outside closes it, and the strip's order holds while it is open). A fork is a card of its own, and so is a delegate whose parent isn't listed (archived, another project), with its `↳ <parent>` chip; the pill counts cards, and every live or waiting session. "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). There a parent's card holds its delegates the same way, the chip opening their rows inside the card (each with an archive button on hover), open by itself while one of them waits on you; the count says `14 (+7 delegates)`, a search that matches a delegate shows its parent's card with the list open and the matching rows marked, and select mode picks cards (archiving a parent takes its delegates). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). The info bar copies `chi --attach <id>` for a terminal. A session whose prompt carried model notes has a `notes: deepseek` chip there (the names without `model_notes_`; the tooltip lists each with its scope and size; `session.prompt_notes` in `GET /api/sessions/:id`, the live worker's, else the session file's; see [Memory](memory.md#model-notes)). Its `llm ctx` chip names the LLM context strategy the next turn runs under (`llm ctx stale,forget · session`, in the accent colour when the session set its own; the tooltip gives each value's source), and its popover sets the session's own strategy, apply rule and budget, or follows the model again, by running `/llm-context` in the worker (the reply shows as a command bubble); `GET /api/sessions/:id`'s `session.llm_context` carries the values (the live worker's, else resolved from the session file), and a `command_ran` that changed them carries the new ones. It shows the context used (`ctx 42%`) and the last generation's decode speed (`87 tok/s`, `~64 tok/s` when estimated; see `/stats` in [cli.md](cli.md#session-commands)); hovering `ctx` there or on a session card lists the session's tokens in (summed over every request, with the cached share), out (with reasoning) and the cost when the provider reports one, for this session only, and the memory indexes its prompt holds (`memory index: ~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)`; see [Memory](memory.md#the-indexs-size)). The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first; typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id, sampling?, llm_context?}], warning?}`; `sampling` is the model's configured request parameters as `/model` words them, the row's tooltip in the list; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). Beside it, an `llm ctx` chip shows the LLM context the picked model starts under (each `GET /api/models` row's `llm_context`, as the info bar's); its form sets one for the new chat only, sent as `POST /api/sessions`'s `llm_context` and never remembered (see [configuration.md](configuration.md#llm-context-a-sessions-own-strategy)). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first line that is one of the new session's commands (`/model …`) goes to `POST /api/sessions/:id/command` instead, as later ones do. The browser remembers the last model picked; a running session's model is in the info bar and changes only with `/model`. In the composer a line is a command when it is `!…` or starts with one of the session's command names (its `commands` list; `/stats`, `/exit` and the other terminal words get the page's own reply); an unknown `/word` (`/usr/bin/env is missing`) goes to the model as a prompt, as in a terminal; a one-word `/word` no command answers (`/modle`) is not sent: the page shows `Unknown command /modle. Did you mean /model? /help lists the commands.` (the "Did you mean" part only when a name is close). A `POST /turn` (or a session's first `prompt`) that is one of the worker's commands runs as that command too (`202 {status, command_id, session_id}`), so `chi send`, `chi -p` and a page whose command list lags all get the command. ↑/↓ in the composer walk the prompt history the TUI's ↑ walks ([Persistent Prompt History](cli.md#persistent-prompt-history)): ↑ with the caret on the first line, ↓ from the last line while browsing, ↓ past the newest brings the draft back; `GET /api/history` returns `{entries: [...]}`, oldest first (the page fetches it on focus and after each send). The server records a sent line in the routes once the worker took it (`POST /turn` accepted, a `!command` through `POST /command` or as a session's first line); `"history": false` in the body keeps it out (an image-only send).
 - Web notifications: when a session needs you while the tab is hidden or behind another window (a question or a guardrail approval, a plugin card with buttons during a turn such as check-in's, a failed turn, a turn done after 10 s or more; a delegated session only for its questions, a canceled turn never), the page title counts it, `(N) Chi`, until you come back to the tab. The bell at the right of the top bar also turns on OS notifications ("needs an answer", "needs approval", "needs you", "turn failed", "done in 42 s", under the session's first message; a click opens the session): its first click asks the browser for the permission, and the choice is kept per browser. Any session of the page's scope counts, not only the open one. What was already so when the page loaded never counts, and several chi tabs show one notification per event. A chi tab in front tells the others (a `BroadcastChannel`), so while you look at one, the ones behind neither notify nor count what it shows; coming back to a tab clears those events in the other tabs' titles too. The hub's `session` frames carry what this needs: `pending_question` (`{id, kind}`, kind `question` or `approval`), `pending_card` (`{id, bundle}`: the running turn's card with actions, from `pending_card.json` that the worker keeps in the session's folder while one is open; a card without actions, such as loop-guard's, never counts) and `last_turn` (`{outcome, ended_at, seconds, origin}`, saved in the session's JSON as the engine ends each turn).
 - The web frontend is a zero-build ES-module stack in `lib/samagotchi/web/public/`: `data.js` (retrieval, typed SSE `openStream` for a session and `openEvents` for the session list), `sessions_list.js` (the list as a pure reducer over `GET /api/events`: a snapshot replaces it, an upsert keeps a known card in place, a removal drops it; `families()` groups delegates under their parent), `families_view.js` (a parent's family chip, its rows and the strip's popover), `notify.js` (which of those events needs the user, for the notifications), `app.js` (presentation/state; a session with no live stream gets one when its `session` event says `bridge_up`, after one re-read: `event_seq` starts over in each worker, so a dropped stream is never resumed with its old cursor), `format.js` (pure formatters such as `previewOf`), `prompt_history.js` (the composer's ↑/↓ over the shared prompt history). Unit-tested via `npm test` (`node --test spec/web/public/*.test.js`).
 - Selecting a session in the web UI is read-only: `GET /api/sessions/:id` never spawns a worker (it reads a live worker's snapshot when one runs, else the session file). A prompt (`POST /turn`) or a command (`POST /command`) wakes the worker, and `/stream` briefly waits for a freshly-spawned bridge before answering. A caught-up SSE reconnect holds the stream open; `reset` markers are only sent for reconnects behind the ring window, or with a cursor from another worker (event ids are `<event_seq>-<epoch>`, one epoch per worker).

data/lib/samagotchi/bridge/card_store.rb

@@ -16,7 +16,8 @@ module Samagotchi
     # iteration started before it (a before_tool_call hook's notice comes
     # before its call's row, so the web puts it above row calls + 1). The
     # loop's "asking again" row (:empty_answer_retry, after an empty or cut
-    # answer) and a steer's cut row (:steer_cut) are kept the same way, and so is a question the turn asked
+    # answer), a steer's cut row (:steer_cut) and a ✂ row (:llm_context_edited,
+    # LLMContextNotice) are kept the same way, and so is a question the turn asked
     # (:question_requested), with how it was answered or cancelled, so a
     # reload draws the resolved card where it was.
     #
@@ -28,9 +29,10 @@ module Samagotchi
     # as /btw) goes after that turn: its prompt is already in the history.
     # A failed turn leaves no prompt, so its cards stay before the next one.
     #
-    # Notices (hook notices, load warnings, "asking again" rows) and cards
-    # (with questions) are capped apart, +capacity+ each, so a burst of
-    # notices can't push out a card. An open question (an approval too) is
+    # Notices (hook notices, load warnings, "asking again" rows), ✂ rows
+    # and cards (with questions) are capped apart, +capacity+ each, so a
+    # burst of notices can't push out a card, nor a long turn's ✂ rows a
+    # hook's notice. An open question (an approval too) is
     # never pushed out: the oldest other card or answered question goes.
     #
     # With a +path+ (the Bridge's: FILE in the session's folder) the store
@@ -47,11 +49,14 @@ module Samagotchi
     class CardStore
       CAPACITY = 20
       NOTICE_TYPES = %i[hook_notice guardrail_warning empty_answer_retry steer_cut].freeze
+      # Capped apart from the notices.
+      LLM_CONTEXT_TYPES = %i[llm_context_edited].freeze
+      LLM_CONTEXT_FIELDS = %i[type moment why freed_tokens tail_tokens staged text groups].freeze
       FILE = "cards.json"
       # The events after which the file is written again: the ones that
       # change an entry or the turn count.
-      SAVED_ON = (%i[card hook_notice empty_answer_retry steer_cut question_requested question_answered question_cancelled
-                     question_relay turn_failed] + Events::TURN_KEPT).freeze
+      SAVED_ON = (%i[card hook_notice empty_answer_retry steer_cut llm_context_edited question_requested question_answered
+                     question_cancelled question_relay turn_failed] + Events::TURN_KEPT).freeze
 
       # What a session's saved file lists, as a store started from it lists
       # (no turn running): the web's cards for a session no worker runs.
@@ -167,6 +172,7 @@ module Samagotchi
                                             .compact.merge(in_turn: false, turns: @turns_done))
         when :empty_answer_retry then add_turn_row(event.slice(:type, :attempt, :of, :stopped_by, :malformed)) if @running
         when :steer_cut then add_turn_row(event.slice(:type, :source)) if @running
+        when :llm_context_edited then add_turn_row(Marshal.load(Marshal.dump(event.slice(*LLM_CONTEXT_FIELDS)))) if @running
         when :question_requested
           add_turn_row({ type: :question, pending_question: Marshal.load(Marshal.dump(event[:pending_question])) }) if @running
         when :question_answered then resolve_question(event[:id], answer: event[:answer])
@@ -236,15 +242,20 @@ module Samagotchi
 
       def push(entry)
         @entries << entry
-        notice = notice?(entry)
-        kind = @entries.select { |e| notice?(e) == notice }
+        cap = cap_class(entry)
+        kind = @entries.select { |e| cap_class(e) == cap }
         return if kind.size <= @capacity
 
         evict = kind.find { |e| !open_question?(e) }
         @entries.delete_at(@entries.index { |e| e.equal?(evict) }) if evict
       end
 
-      def notice?(entry) = NOTICE_TYPES.include?(entry[:type])
+      # Which cap +entry+ counts against: :notice, :llm_context or :card.
+      def cap_class(entry)
+        return :llm_context if LLM_CONTEXT_TYPES.include?(entry[:type])
+
+        NOTICE_TYPES.include?(entry[:type]) ? :notice : :card
+      end
 
       def open_question?(entry)
         entry[:type] == :question && !entry.key?(:answer) && !entry[:cancelled]

data/lib/samagotchi/bridge/turn_notice.rb

@@ -4,7 +4,8 @@ module Samagotchi
   class Bridge
     # The events a running turn shows as rows of its own (not text, thinking
     # or a tool call): a hook's notice, the loop asking again after an empty
-    # or cut answer, a question and how it was answered. A UI that joins the
+    # or cut answer, a batch of LLM context edits (✂), a question and how it
+    # was answered. A UI that joins the
     # turn mid-way (TurnAccumulator's "notice" part) and one that reloads a
     # finished turn (CardStore) get the event back with the fields listed
     # here, and draw it with the handler that drew it live, where it was.
@@ -13,6 +14,7 @@ module Samagotchi
         hook_notice: %i[hook text level fallback_for],
         empty_answer_retry: %i[iteration attempt of stopped_by malformed],
         steer_cut: %i[iteration source],
+        llm_context_edited: %i[moment why freed_tokens tail_tokens staged text groups],
         question_requested: %i[pending_question],
         question_answered: %i[id answer],
         question_cancelled: %i[id reason]

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

@@ -1,17 +1,17 @@
 ---
 name: github-pr
-version: 0.2.0
+version: 0.3.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
+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
-requires_chi: ">= 0.32.0"
+requires_chi: ">= 0.43.0"
 needs:
 - command: gh
   why: reads the pull request
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:f8b9794f84681f3a16a4d49da3b857a59fec3ccdc2d0a2b16d1192fd2a26bdf3
+  sha256: sha256:8c3b1b2de9112320d95d42d19b924a2a6bb0418715d3c78a24ac695c7b825487
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers: