samagotchi 0.83.0 → 0.84.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b7fb93e6e4741b5380cfaeaa2a27d37dd326099f2d3cf568b659941e9c34930
-  data.tar.gz: bc53710bd1f4dab4d2d5d4e1eb23814f367fc47833b930fd6bd7ee3a1411423b
+  metadata.gz: e5e180d3ef3bc5dd32bd646d471b1ef88e11083aba16f6908a8c4588b0173b4c
+  data.tar.gz: b337e5690f3094d5f3b0e8528aacbedab734211c9be60ed5ff314f6eb4299ea7
 SHA512:
-  metadata.gz: 882ac69395d70f9b27e8b9922b704c1b1818ad400eeb4551dac38c905df7822d17ac43450f71b5c5a0653b0af9b45470098981f9ee25e36dc2f45a1bb2a9eeee
-  data.tar.gz: 1e982daa8adf0881d87ea82256e96565cceb09ab4d6793325a87ce0214df3355a5798c3da75f9afab30126aba7bd5f7f9facf7dfd1f032e3c2cfd9a5e4aaeed4
+  metadata.gz: 4ce619eccbfc69729b160a2b19c65d3b8e91d0f2b641fb6d4eb288d8fd12e9a147529745a8a3b5272270a2fabec6e597f423086c6574cb06f689816b32550568
+  data.tar.gz: 4a9922290d92cabab3aac30f17292119cc6e778243a7e1b57bd8260423a27446b34b978346056566619f8e358da8dabbd9e80f8bc3aa9fc198dab99e9b27b38c

data/CHANGELOG.md

@@ -8,6 +8,15 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.84.0] - 2026-10-18
+
+### Added
+
+- `--set BUNDLE.KEY=VALUE` on `chi` and `chi send --new`: a bundle setting for this session, saved with it and kept
+  by forks and continued links. A bundle lists the keys a session may set in its manifest's `session_settings:`;
+  its plugin reads them in `ctx.settings`, over config.yml's. `POST /api/sessions` takes `bundle_settings`.
+- The cost-cap bundle takes a session's own cap: `chi send --new --set cost-cap.cap=3 -m "…"` (cost-cap 0.1.1).
+
 ## [0.83.0] - 2026-10-18
 
 ### Added
@@ -3380,7 +3389,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.83.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.84.0...HEAD
+[0.84.0]: https://github.com/dm1try/samagotchi/compare/v0.83.0...v0.84.0
 [0.83.0]: https://github.com/dm1try/samagotchi/compare/v0.82.0...v0.83.0
 [0.82.0]: https://github.com/dm1try/samagotchi/compare/v0.81.0...v0.82.0
 [0.81.0]: https://github.com/dm1try/samagotchi/compare/v0.80.0...v0.81.0

data/bin/chi

@@ -82,7 +82,7 @@ ARGV.each do |arg|
   base = arg.split("=", 2).first
   # If dashed version is a known flag (registry or hardcoded), reject underscore variant
   dashed = base.tr("_", "-")
-  known = %w[--prompt --resume --attach --shared --no-shared --model --thinking --toolkit --tool --no-tool --memory --mute --append-system-prompt --llm-context --llm-context-apply --llm-context-budget --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token] + Samagotchi::Config.cli_entries.map(&:cli_flag)
+  known = %w[--prompt --resume --attach --shared --no-shared --model --thinking --toolkit --tool --no-tool --set --memory --mute --append-system-prompt --llm-context --llm-context-apply --llm-context-budget --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token] + Samagotchi::Config.cli_entries.map(&:cli_flag)
   if known.include?(dashed) || known.include?(base)
     warn "Unknown option: #{arg} (did you mean #{dashed}?)"
     exit 1
@@ -125,6 +125,11 @@ parser = OptionParser.new do |opts|
   # --no-tool is taken out of ARGV before parse! (OptionParser would read it
   # as --tool's negation); this is its help line.
   opts.separator "        --no-tool NAME               Leave this tool out of the toolkit (repeatable; a comma list too)"
+  opts.on("--set BUNDLE.KEY=VALUE", "A bundle setting for this session, over config.yml's bundles: (repeatable; a key the " \
+                                  "bundle's manifest lists in session_settings:; numbers, true, false and off are typed, the rest is text; " \
+                                  "saved in the session: --set cost-cap.cap=3)") do |v|
+    (options[:sets] ||= []) << v
+  end
   opts.on("--memory NAME", "Preload a memory entry into the system prompt (repeatable; a comma list too)") { |m| (options[:memories] ||= []) << m }
   opts.on("--append-system-prompt FILE", "Put FILE's text into the system prompt, after AGENTS.md (repeatable; saved in the session; " \
                                         "config append_system_prompt: is the baseline)") { |f| (options[:append_system_prompt] ||= []) << f }
@@ -225,6 +230,10 @@ if options[:new_token] && !web
   warn "Error: --new-token goes with chi web (chi web --new-token)"
   exit 1
 end
+if options[:sets] && web
+  warn "Error: --set is a new session's (chi --set, chi send --new --set), not chi web's"
+  exit 2
+end
 
 # A scratch session is new, runs here and goes when it ends.
 if scratch
@@ -372,6 +381,20 @@ if options[:toolkit] || options[:tools] || options[:no_tools]
                                                            remove: options[:no_tools])
 end
 
+# --set BUNDLE.KEY=VALUE: a new session's bundle settings, checked here
+# against the installed bundles (a typo isn't saved).
+if options[:sets]
+  require "samagotchi/bundle_session_settings"
+  begin
+    options[:bundle_settings] = Samagotchi::BundleSessionSettings.from_flags(options[:sets])
+  rescue Samagotchi::BundleSessionSettings::Error => e
+    warn "Error: #{e.message}"
+    exit 2
+  end
+  # An existing session's run names it among the flags it ignores.
+  options[:toolkit_flags] = (options[:toolkit_flags] || []) + ["--set"]
+end
+
 chi_update_hint.call
 require "samagotchi/launch_mode"
 launch, launch_note = if scratch
@@ -408,7 +431,8 @@ if launch == :attached
                                                        thinking: options[:thinking],
                                                        appended_prompt_files: options[:appended_prompt_files] || [],
                                                        toolkit: options[:toolkit_value],
-                                                       toolkit_flags: options[:toolkit_flags] || [])
+                                                       toolkit_flags: options[:toolkit_flags] || [],
+                                                       bundle_settings: options[:bundle_settings] || {})
   rescue Samagotchi::TerminalUI::AttachLauncher::Error => e
     warn "Error: #{e.message}"
     exit 1
@@ -430,6 +454,7 @@ begin
     appended_prompt_files: options[:appended_prompt_files] || [],
     toolkit: options[:toolkit_value],
     toolkit_flags: options[:toolkit_flags] || [],
+    bundle_settings: options[:bundle_settings] || {},
     non_interactive: options[:non_interactive],
     model_name: options[:model],
     scratch: scratch

data/docs/cli.md

@@ -204,6 +204,7 @@ controls exit behavior (`--non-interactive`); `--resume` composes with both.
 | `--model NAME` | Use this model for the run (overrides the configured default and a resumed session's model). |
 | `--thinking LEVEL` | This session's own thinking level: `off`, `low`, `medium` or `high`, saved in the session and first in the order (`default` unsets it). On `--resume` or `--attach` it is set at once, through a `/thinking` on an attached worker. With `chi web` it is instead the default for the sessions its workers run, below a session's own (as env `SAMAGOTCHI_THINKING_LEVEL` is). See "Thinking" in configuration.md. |
 | `--toolkit NAME`, `--tool NAME`, `--no-tool NAME` | A new session's toolkit, the tools its prompts declare: `full` (every built-in), `lean`, `child`, one of config's `toolkit.kits` or a bundle's (without `--toolkit`: config's `toolkit.default`), with tools declared on top of it (`--tool`) or left out (`--no-tool`); both repeatable, a comma list too. Saved in the session as given; a respawned worker, a fork and a continue keep it. Ignored with `--attach`/`--resume` (one line, as `--memory`); `/toolkit` changes it. Not on `chi web` (config's `toolkit.default` covers its sessions). See [Toolkits](configuration.md#toolkits). |
+| `--set BUNDLE.KEY=VALUE` | A bundle setting for a new session (repeatable; a later one of the same key wins), laid over config.yml's `bundles: <bundle>:` in what the bundle's plugin reads (`ctx.settings`): `--set cost-cap.cap=3`. The value is typed simply: an integer (`3`, `-1`) or a decimal (`2.5`) is a number, `true` is true, `false` and `off` are false, anything else stays the text as given (`010`, `0x10`, `3:30`, `No`, `null`). For cost-cap, `0`, a negative number or `off` is no cap. Only a key the installed bundle's manifest lists in `session_settings:` is taken: a bundle that isn't installed (or whose plugin doesn't load), a key it doesn't list (a record installed before the bundle listed it says to run `chi update` or `chi bundle upgrade NAME`), or another shape (`--set foo`, `--set a.b.c=1`) is an error naming what it takes, exit 2, nothing started. Saved in the session; a respawned worker, a fork and a continue keep it, a delegate child doesn't. Ignored with `--attach`/`--resume` (one line, as `--toolkit`); refused with `chi web`. See [Per-session settings](plugins.md#per-session-settings). |
 | `--profile NAME` | Prompt profile (`qwen36` or `gemma4`) for every model in this run, over config and the server's template (same as `--model-profile`, env `SAMAGOTCHI_MODEL_PROFILE`). See "Prompt profile" in configuration.md. |
 | `--memory NAME` | Preload a memory entry into the system prompt (repeatable; a comma list too). Merged under the config.yml `memories:` baseline. Works attached: the list is stored on the session, so its worker builds the same prompt on every respawn. |
 | `--append-system-prompt FILE` | Put `FILE`'s text into the system prompt, after AGENTS.md and before the memory indexes (repeatable; relative to the shell's directory). Added after the config.yml `append_system_prompt:` list. A missing or unreadable file is an error, exit 1. Saved in the session, so a respawned worker, a fork and a continue keep it; ignored with `--attach`/`--resume` (one line, as `--memory`). See [Appended prompt files](configuration.md#appended-prompt-files). |

data/docs/internals/bundles.md

@@ -27,7 +27,7 @@ user-facing side (what a bundle owns, profiles, needs) is in [memory.md](../memo
 | `SourceIdentity` (source.rb) | what a source is, for comparing two installs of one name: `shipped:<dir>` (any gem or checkout), `git:<url>` (no `#ref`, trailing `/` or `.git`), `path:<realpath>`; nil when it can't place one |
 | `PreparedSource` (source.rb) | one source normalized once (dir, owned, git commit): `BundleCommand` reads the bundle's name from its `manifest.yml` (the name for every kind of source, a git URL too) and hands it to the Installer (`prepared:`), so a source is cloned or extracted once per command |
 | `MemoryFiles` | which top-level `*.md` files of a bundle are its memories (`.select`: the `files:` list, else all but README/LICENSE and the like), `.unshipped` (listed, not shipped) and `.symlinks` (skipped: a symlink is never a memory) |
-| `Manifest` | parses/validates `manifest.yml` (`name:` is the bundle's name and a directory under `.bundles/`, so a path such as `../x`, `a/b`, `.` or `..` is refused: `name: … is not a bundle name`; YAML that doesn't parse or isn't a mapping is a `ValidationError` too; files, hooks as `BundleHook`, plugin, scripts, needs, requires_chi, includes, context_providers) and writes it (`Manifest.write`, for Builder). It ignores `requires_chi_next`, a shipped bundle's release-time marker (`script/release/release_tools.rb`, docs/releasing.md) |
+| `Manifest` | parses/validates `manifest.yml` (`name:` is the bundle's name and a directory under `.bundles/`, so a path such as `../x`, `a/b`, `.` or `..` is refused: `name: … is not a bundle name`; YAML that doesn't parse or isn't a mapping is a `ValidationError` too; files, hooks as `BundleHook`, plugin, scripts, needs, requires_chi, includes, context_providers, session_settings: the keys a session's `chi --set` may give, recorded at install in `manifest.json` for `BundleSessionSettings` to check) and writes it (`Manifest.write`, for Builder). It ignores `requires_chi_next`, a shipped bundle's release-time marker (`script/release/release_tools.rb`, docs/releasing.md) |
 | `Installer` | one install/upgrade/dry run of one bundle (below) |
 | `AssetInstaller` | the parts that live in `.bundles/<name>/`: hooks, guardrail rules, plugin, scripts; returns `AssetInstaller::Installed` (the paths the record keeps) |
 | `Merger` | 3-way classification per file: `install`, `fast_forward`, `keep`, `noop`, `conflict` |

data/docs/plugins.md

@@ -28,6 +28,7 @@ plugin:
 requires_chi: ">= 0.1.28"    # optional: a gem-style requirement (">= 0.1.28, < 0.2"); the bundle's hooks/ check it too
 # requires_chi_next: true    # shipped bundles only, ignored by chi: rake release:bump raises requires_chi
                              # to the chi being released (docs/releasing.md)
+session_settings: [cap]      # optional: the settings a session may set (chi --set my-bundle.cap=3)
 needs: [gh]                  # optional: outside commands it relies on (see memory.md#bundles-that-need-outside-commands)
 ```
 
@@ -70,7 +71,9 @@ of [anytime](#anytime-true) and the `save_note` tool (see `chi.tool` below). Ins
 
 Settings work as they do for hooks ([hooks.md](hooks.md#settings)). An
 `initialize` that takes an argument gets the bundle's section of config.yml
-`bundles:`, as one Hash with string keys.
+`bundles:`, as one Hash with string keys. It runs once, when the plugin loads, before any session: it never
+sees a session's own `--set` values. A value a session may set is read from `ctx.settings` in the handler or
+command that uses it (see [Per-session settings](#per-session-settings)).
 
 ## The API: `register(chi)`
 
@@ -731,7 +734,7 @@ full label, `plugin.rb (bundle my-bundle)`.
 | `ctx.model` | the model the session runs on now: its resolved ref (`host:id`), right after `/model` too |
 | `ctx.model_key` | that model's memory overlay key (`<name>.<key>.md`, what `memory_write current_model_only` writes) |
 | `ctx.cost` | the session's spend so far, read now, as a frozen value: `total` (USD, reported + estimated, side requests included; 0.0 before any), `reported` (by providers, `usage.cost`), `estimated` (from `hosts.<name>.models` prices; a generation is one or the other, never both), `side` (recap, `/btw`, `ask_model`: their share of `total`) and `known?` (false while generations or side requests ran but none was reported or priced, so a limit on it can't be enforced; a session with some priced generations reads known, the unpriced ones counting 0). It includes the running turn's finished generations and what earlier workers of the session spent. Use its methods, not its class. Needs chi 0.83.0 |
-| `ctx.settings` | the bundle's settings, frozen |
+| `ctx.settings` | the bundle's settings, frozen: config.yml's `bundles: <bundle>:` with the session's own `--set` values laid over it ([Per-session settings](#per-session-settings)); the config alone until the session is bound (in `register` and `chi.ctx`) |
 | `ctx.data_dir` | `$XDG_STATE_HOME/samagotchi/plugins/<bundle>/`, created on first use. A session's own state goes in `sessions/<id>.json` or `sessions/<id>/` there: chi removes it when the session is deleted, discarded or pruned |
 | `ctx.log` | `ctx.log.info(:event, key: value)`: debug-log records tagged `plugins`, with `bundle=<bundle>` |
 | `ctx.messages` | the conversation, as a frozen copy, without the system prompt. While a turn runs, a session worker's (attached, web) adds that turn so far: its prompt, the model's text and the lines merged into it (no tool calls or thinking); the REPL's is the conversation before that turn |
@@ -754,6 +757,19 @@ full label, `plugin.rb (bundle my-bundle)`.
 
 The Engine itself is never handed to a plugin.
 
+### Per-session settings
+
+A bundle's settings are config.yml's, for every session. A setting a session may have of its own (a child's cap,
+say) is one the manifest lists in `session_settings:`; `chi --set BUNDLE.KEY=VALUE` and `chi send --new --set …`
+then give it to a new session, saved with it (a respawn, a fork and a continued link keep it; a delegate child
+doesn't). chi refuses a bundle that isn't installed (or whose plugin doesn't load) and a key the manifest doesn't
+list, so a typo isn't saved. Values are typed simply: an integer (`3`, `-1`) or a decimal (`2.5`) is a number,
+`true` is true, `false` and `off` are false, and anything else stays the text as given (`010`, `0x10`, `3:30`,
+`No`, `null`); `POST /api/sessions` `bundle_settings` types its strings the same way and keeps JSON numbers and
+booleans. `ctx.settings` is the config's section with the session's values laid over it (one level: a session's
+`cap` replaces the config's `cap`). Read such a key from `ctx.settings` where it is used, not in
+`initialize(settings)`: that runs once at load, before any session, and gets the config only.
+
 ## Cards
 
 A card is a small framed message with buttons: a title, a body and
@@ -1147,6 +1163,7 @@ bundle.sessions.on(:children) { |all:| [] }              # ctx.sessions, scripte
 bundle.http.stub(:post, "http://127.0.0.1:9000/classify", json: { label: "safe" })   # ctx.http, never the network
 bundle.set(running: false)                               # the session's values: cwd:, messages:, cancelled: …
 bundle.set(cost: 2.5)                                    # ctx.cost: reported USD, or { reported:, estimated:, side:, known: }
+bundle.set(session_settings: { "cap" => 1 })             # the session's --set values (Bundle.load takes session_settings: too)
 bundle.shutdown
 ```
 
@@ -1173,6 +1190,11 @@ bundle.shutdown
 - **`ctx.cost`** is zero and known unless the test sets it: `bundle.set(cost: 2.5)` (reported USD), a Hash of the
   parts (`reported:`, `estimated:`, `side:`, `known:`; `total` is reported + estimated) or a callable giving either,
   called at each read (a counting lambda shows whether the bundle read it).
+- **`session_settings:`** (on `Bundle.load` and `bundle.set`) are the session's own `--set` values for the bundle,
+  keys its manifest lists in `session_settings:` (another raises `ArgumentError`, as chi refuses it). `ctx.settings`
+  lays them over `settings:` through chi's own `Context#settings`; the plugin's `initialize(settings)` gets
+  `settings:` only. `bundle.set(session_settings:)` moves the session to a new id (`test-session-2`, or the
+  `session_id:` given beside it): chi never changes them within a session, and builds `ctx.settings` once per id.
 - **A hook that raises fails the call** (`Testing::HookFailed`, with the hook's error) where chi would log it and
   go on; `bundle.lenient { … }` collects them in `bundle.errors` instead.
 - **Sandbox.** A test runs with temp config, state, data and cache homes (config.yml, memories, `ctx.data_dir`, the
@@ -1574,8 +1596,10 @@ bundles:
   Continue raises it to $6.00.` with **Continue** (another cap's worth: $3 → $6 → $9, as many steps as it takes to
   pass the spend, saved for the session) and **Stop** (the turn stops, `canceled` with `stopped_by: cost-cap`, and a
   card shows the spend, reported, estimated and side). With no one to ask (`--non-interactive`) it stops.
-- **The cap of a session:** the one `/cap` or a Continue set for it, else `child:` for a delegate child, else
-  `default:`. Delegates and continued links each have their own cap; there is no family cap.
+- **The cap of a session:** the one `/cap` or a Continue set for it, else its own `cap:` (`chi --set
+  cost-cap.cap=3`, `chi send --new --set cost-cap.cap=3`; `--set cost-cap.cap=off`, `0` or a negative number for none), else `child:` for a
+  delegate child, else `default:`. Delegates and continued links each have their own cap (a continued link keeps
+  the `--set` cap, not a `/cap` or Continue); there is no family cap.
 - **A host it can't watch:** a model that reports no cost and has no configured price (a local server, a free
   model that reports 0) reads unknown: one notice, `the $3.00 cap can't be enforced: <model> reports no cost and has
   no price`, and it never stops for an unknown cost. A session with some priced generations counts the unpriced
@@ -1589,7 +1613,9 @@ bundles:
   spend is allowed: the next generation asks.
 - `/cap off` (or `/cap 0`): no cap for this session, over the config's `default:`.
 
-A parent agent starts a session with a cap by sending `/cap N` as its first message (`chi send --new -m '/cap 3'`).
+A parent agent starts a session with a cap of its own with `--set` (`chi send --new --set cost-cap.cap=3 -m "task"`;
+`cost-cap.cap` is the bundle's one session setting), or by sending `/cap N` as a first message
+(`chi send --new -m '/cap 3'`).
 At the cap, `chi send --wait` exits 3 with a question of kind `hook` (header "Cost cap"); `chi answer ID --question
 Q --option Continue` (or `--option 1`) goes on, `--option Stop` stops the turn ([sub-agent.md](sub-agent.md)). A
 parent may Continue: nothing restricts it, as with the step limit. A background delegate child at its cap waits on

data/docs/sessions.md

@@ -209,7 +209,8 @@ chi send --new --continues last:3fa2 -m "new day"      # the next link of 3fa2's
 - Exit codes with `--wait`: 0 answered; 3 the turn waits for an answer from you (a question, a hook's question, a guardrail approval, or the step-limit question: see [chi as a sub-agent](sub-agent.md#the-step-limit)), and the session keeps waiting: stderr gets the whole question (`waiting for an answer (approval): …`, its text, the numbered options, whether free text is allowed) and how to answer it (`chi answer ID --question QID --option N`, or `chi --attach ID`, the web); 4 `--timeout S` passed with the turn still running (it goes on; wait again); 1 the turn ended without a reply (canceled, failed or empty), the worker failed or vanished, or the session was stopped; 130 on Ctrl-C, which leaves the turn running (`still running: chi --attach ID`). There is no default timeout.
 - `--format json` (with `--wait`) prints one JSON object on stdout however the wait ends, for a script or a parent agent (see [chi as a sub-agent](sub-agent.md)): `{"status":"answered","session_id":…,"text":…}`; `{"status":"question",…,"question":{"id","kind","header","text","options","multi_select","allow_freeform","approval"},"answer_with":"chi answer ID --question QID --option N"}`, where `kind` is `question` (the model's), `hook` or `approval` (with the tool, command, cwd, rule, reason and offered scopes); `{"status":"running",…,"detail":…}` (exit 4, and on Ctrl-C); and `failed`, `canceled`, `no_answer`, `error`, `worker_gone` or `stopped` with a `detail` line (exit 1); `failed` adds `error_kind` and `retryable`, `canceled` adds `cancel_reason` and `stopped_by`, when known. A failure before the wait (no such session, a busy one) is `error` too. A usage error (exit 2) prints no JSON.
 - `--wait ID` with no message (no `-m`, nothing piped) sends nothing: it waits for the session's next reply and prints and exits as above. With a turn running, that turn's reply (its `interrupted_turn` mark names it), not a turn's queued behind it; with the step-limit question standing, the reply of the turn its Continue runs; with an idle session whose last turn already ended, that ended turn is the answer: its reply, or its end when it left no reply — a turn that finished in the gap between waits is reported, not waited for. With none of those (or a worker whose `bridge.json` lacks `turn_ids`), the next reply of any turn. A running session is fine (that is the point), so after exit 3, 4 or 130 an agent waits again this way while the user answers in the web or `chi --attach`; the question pending when it starts doesn't count again. An idle session with no worker waits until something wakes one. With `--new`, or two ids, it is a usage error (exit 2).
-- `--continues ID` (with `--new`) starts the next link of that session's chain instead (see *Session chains*): in its folder, on its model (or the one `--model` names), LLM context, thinking level and toolkit, so `--dir`, `--llm-context*`, `--thinking`, `--toolkit`, `--tool` and `--no-tool` are refused beside it; `ID` may be a prefix or `last:ID`, the chain's latest link. Without a message the new link starts idle; `--wait` then has nothing to wait for (a usage error). It prints `<full id>  started (continues 3fa2c1d0)`, with `; 2 delegates moved` inside the parentheses when open delegates moved to it; a refusal (continued already, naming the next link; an open delegate that can't move; a turn running) is `chi send: refused: …`, exit 1, and a `--model` it can't start on is `chi send: could not start a session: …`, exit 1, nothing archived. A fallback to the default model (below) prints `chi send: warning: …`.
+- `--set BUNDLE.KEY=VALUE` (with `--new`, repeatable) gives the new session a bundle setting of its own, as `chi --set` does (see *Bundle settings* below): `chi send --new --set cost-cap.cap=3 -m "…"` starts it with a $3 cap. A bundle or key the installed bundles don't offer is a usage error (exit 2), as is `--set` without `--new`.
+- `--continues ID` (with `--new`) starts the next link of that session's chain instead (see *Session chains*): in its folder, on its model (or the one `--model` names), LLM context, thinking level, toolkit and bundle settings, so `--dir`, `--llm-context*`, `--thinking`, `--toolkit`, `--tool`, `--no-tool` and `--set` are refused beside it; `ID` may be a prefix or `last:ID`, the chain's latest link. Without a message the new link starts idle; `--wait` then has nothing to wait for (a usage error). It prints `<full id>  started (continues 3fa2c1d0)`, with `; 2 delegates moved` inside the parentheses when open delegates moved to it; a refusal (continued already, naming the next link; an open delegate that can't move; a turn running) is `chi send: refused: …`, exit 1, and a `--model` it can't start on is `chi send: could not start a session: …`, exit 1, nothing archived. A fallback to the default model (below) prints `chi send: warning: …`.
 - The 16 KiB cap applies: `git diff | chi send --new …` on a big diff is refused; name the branch in the message instead and let the session read it.
 - A session nobody attaches to stalls at its first question or guardrail ask until someone answers it (`chi answer`, the web, `chi --attach`), and its worker stays up meanwhile: it doesn't idle-exit while a question waits (`chi sessions list` shows it as `waiting`; `chi sessions stop ID` frees it). Otherwise it idle-exits after `session.idle_exit_minutes` like any worker. These are ordinary sessions: delete them like any other.
 
@@ -243,6 +244,16 @@ declares every tool (full). The file stores only the name: a kit's tools and pro
 `/toolkit` changes it, saved at once, from the next turn's start. See
 [Toolkits](configuration.md#toolkits).
 
+## Bundle settings
+
+A session file's `bundle_settings` (`{"cost-cap": {"cap": 3}}`, `{}` for none and for a session from before them)
+holds the bundle settings it was created with: `chi --set BUNDLE.KEY=VALUE`, `chi send --new --set …`, or `POST
+/api/sessions` `bundle_settings` (an object of the same shape, checked the same way; `400 invalid_bundle_settings`
+otherwise). They never change after: a respawned or woken worker reads the same, and a continue (`continue →`,
+`chi send --new --continues`) and a fork (`ctx.sessions.fork`) copy them, as they copy the toolkit. A delegate
+child starts without (a bundle has its own setting for children, such as cost-cap's `child:`). A bundle's plugin
+reads them in `ctx.settings`, over config.yml's `bundles:` ([Per-session settings](plugins.md#per-session-settings)).
+
 ## 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; 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 above 64 KB (`DelegateWait.cut`); a reply longer than `max_tool_output_chars` keeps its start and its end (the conclusion), with a gap line naming that `output/` file, where the whole reply is (`ToolOutputCut`'s `:head_tail_ref`; see [Tool output guardrails](internals/tool-guardrails.md#the-runners-cut-max_tool_output_chars)). Nothing of the child's trace enters the parent's context. Nothing is hidden: a child shows in `chi sessions list` (`↳ <parent>`), the web (folded into its parent's card on the strip and in all sessions, whose `▸ N delegates` chip lists the delegates at any depth, see Web UI above; a card of its own with a `↳` chip when its parent isn't listed; `delegated by` in its info bar; the parent's info bar carries a `⑂ N` chip counting its delegates, with how many run, wait, are done, failed, stopped or idle in the tooltip and the waiting ones named in the attention colour; a click opens all sessions), the terminal's status row (a parent's `⑂ 2 running · 1 waiting`, see [Status Line](cli.md#status-line)) 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.

data/docs/sub-agent.md

@@ -36,6 +36,10 @@ chi answer ID --question QID (--option N|LABEL)... [--text T] [--timeout S] [--f
 chi answer ID --question QID --dismiss [--timeout S] [--format json]
 ```
 
+A child with a bundle setting of its own, such as a $ cap (the [cost-cap bundle](plugins.md#the-cost-cap-bundle)):
+`chi send --new --wait --format json --set cost-cap.cap=3 -m "task"`. At the cap the wait exits 3 with the cost-cap
+question; `chi answer ID --question QID --option Continue` (or `Stop`) answers it.
+
 `chi answer` waits after answering, the same way `chi send --wait` does, so the
 next question comes back as exit 3 again. What it waits for is the answered
 turn: the turn that asked (or, for the step-limit question, the turn it

data/lib/samagotchi/bundle_session_settings.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "version"
+
+module Samagotchi
+  # A session's own bundle settings (chi --set BUNDLE.KEY=VALUE, chi send
+  # --new --set, POST /api/sessions bundle_settings): {bundle => {key =>
+  # value}}, string keys, scalar values (.typed). A bundle offers the keys a
+  # session may set in its manifest's session_settings: (recorded at install,
+  # InstalledBundle#session_settings); any other bundle or key is refused, so
+  # a typo isn't saved. The session keeps them (Session#bundle_settings,
+  # SessionSetup) and Plugin::Context#settings lays them over config.yml's
+  # bundles: <name>:.
+  module BundleSessionSettings
+    # A refused --set (or request field): the message says why.
+    class Error < ArgumentError; end
+
+    # A bundle name (MemoryBundle::Manifest::BUNDLE_NAME) and a setting key.
+    BUNDLE = /\A[A-Za-z0-9][A-Za-z0-9_-]*\z/
+    KEY = /\A[A-Za-z0-9_][A-Za-z0-9_-]*\z/
+    # The values a setting may take.
+    SCALARS = [String, Integer, Float, TrueClass, FalseClass].freeze
+    REQUEST_SHAPE = "bundle_settings is an object of bundle => {key => scalar}"
+    # What .typed reads as a number: no leading zero, no exponent, no _.
+    INTEGER = /\A-?(?:0|[1-9]\d*)\z/
+    DECIMAL = /\A-?(?:0|[1-9]\d*)\.\d+\z/
+    # The shipped bundles' sources (a stale record's hint reads them).
+    SHIPPED_DIR = File.expand_path("bundles", __dir__)
+
+    # The installed bundles a session may set settings of: +offered+ the
+    # keys of each bundle whose plugin loads ({name => keys}), +notes+ what
+    # a refusal adds for a bundle ({name => text}): why its plugin doesn't
+    # load, or how to refresh a record from before session_settings.
+    Availability = Data.define(:offered, :notes)
+
+    module_function
+
+    # --set's values as typed, in order: a later one of the same key wins.
+    # @param args [Array<String>] "BUNDLE.KEY=VALUE" each
+    # @return [Hash{String => Hash{String => Object}}] frozen
+    # @raise [Error] a value of another shape
+    def parse(args)
+      settings = {}
+      Array(args).each do |arg|
+        target, sep, raw = arg.to_s.partition("=")
+        bundle, *keys = target.split(".", -1)
+        if sep.empty? || keys.empty? || !BUNDLE.match?(bundle.to_s) || keys.any? { |key| !KEY.match?(key) }
+          raise Error, "--set takes BUNDLE.KEY=VALUE, not #{arg}"
+        end
+        raise Error, "--set #{arg}: one key under the bundle (BUNDLE.KEY), no nested path" if keys.size > 1
+        raise Error, "--set #{arg}: give a value" if raw.strip.empty?
+
+        (settings[bundle] ||= {})[keys.first] = typed(raw)
+      end
+      deep_freeze(settings)
+    end
+
+    # +settings+ when every bundle is installed and offers each key.
+    # @param bundles [Hash{String => Array<String>}] the installed bundles'
+    #   offered keys (.offered)
+    # @param notes [Hash{String => String}] Availability#notes
+    # @param flag [String] what a refusal names ("--set", a request field)
+    # @return [Hash] +settings+
+    # @raise [Error]
+    def check!(settings, bundles: offered, notes: {}, flag: "--set")
+      settings.each do |bundle, values|
+        keys = bundles[bundle]
+        note = notes[bundle]
+        values.each_key do |key|
+          where = "#{flag} #{bundle}.#{key}"
+          raise Error, "#{where}: #{note || "no installed bundle #{bundle} (#{takers(bundles)})"}" if keys.nil?
+          raise Error, "#{where}: #{bundle} takes no session settings#{" #{note}" if note}" if keys.empty?
+          raise Error, "#{where}: #{bundle} takes #{keys.join(", ")}" unless keys.include?(key)
+        end
+      end
+      settings
+    end
+
+    # --set's values parsed and checked (.parse, .check!) against the
+    # installed bundles (.availability).
+    def from_flags(args, available: availability)
+      check!(parse(args), bundles: available.offered, notes: available.notes)
+    end
+
+    # A value as --set (and a request's string) gives it: an integer
+    # ("3", "-1"), a decimal ("2.5"), true, false or off (false); any other
+    # string stays as given ("010", "0x10", "3:30", "No", "null"). A value
+    # that isn't a String (a JSON number or boolean) is kept.
+    def typed(value)
+      return value unless value.is_a?(String)
+
+      case value
+      when INTEGER then Integer(value, 10)
+      when DECIMAL then Float(value)
+      when "true" then true
+      when "false", "off" then false
+      else value
+      end
+    end
+
+    # POST /api/sessions bundle_settings: nil for none, else an object of
+    # objects of scalars (a string typed as --set's, .typed), checked like
+    # --set; an empty bundle entry is dropped.
+    # @param bundles [Hash, nil] the offered keys (.availability's by default)
+    # @return [Hash] frozen
+    # @raise [Error]
+    def from_request(raw, bundles: nil)
+      return {} if raw.nil?
+      raise Error, REQUEST_SHAPE unless raw.is_a?(Hash) && raw.all? { |_, values| scalar_map?(values) }
+
+      settings = normalize(raw.transform_values { |values| values.transform_values { |value| typed(value) } })
+      return settings if settings.empty?
+
+      available = bundles ? Availability.new(offered: bundles, notes: {}) : availability
+      check!(settings, bundles: available.offered, notes: available.notes, flag: "bundle_settings")
+    end
+
+    # Each installed bundle's offered keys, by name (Availability#offered).
+    # @return [Hash{String => Array<String>}]
+    def offered(dir: nil) = availability(dir: dir).offered
+
+    # The installed bundles a session may set settings of: a record that
+    # doesn't read is left out, and so is one whose plugin doesn't load as
+    # chi's loader decides (Plugin::Loader#unloadable_reason: requires_chi,
+    # the file, its sha256), with a note saying why. A record with no
+    # session_settings whose shipped bundle lists some (installed before
+    # them) gets a note on refreshing it.
+    # @return [Availability]
+    def availability(dir: nil, shipped_dir: SHIPPED_DIR)
+      require_relative "memory_bundle/provenance"
+      require_relative "memory_bundle/manifest"
+      dir ||= MemoryBundle::Provenance.bundles_dir
+      offered = {}
+      notes = {}
+      MemoryBundle::Provenance.each_installed(dir: dir) do |name, bundle|
+        next if bundle.error?
+
+        if (reason = unloadable(dir, name, bundle))
+          notes[name] = "#{name} is installed but its plugin doesn't load: #{reason}"
+          next
+        end
+        offered[name] = bundle.session_settings
+        if bundle.session_settings.empty? && shipped_settings?(shipped_dir, name)
+          notes[name] = "(run `chi update` or `chi bundle upgrade #{name}` to refresh it)"
+        end
+      end
+      Availability.new(offered: offered, notes: notes)
+    end
+
+    # A session file's value, read tolerantly: the bundles that map to
+    # settings, the scalar ones of those, string keys, frozen; {} for
+    # anything else.
+    # @return [Hash{String => Hash{String => Object}}]
+    def normalize(raw)
+      return {}.freeze unless raw.is_a?(Hash)
+
+      deep_freeze(raw.each_with_object({}) do |(bundle, values), acc|
+        next unless values.is_a?(Hash)
+
+        kept = values.each_with_object({}) do |(key, value), scalars|
+          scalars[key.to_s] = value if SCALARS.any? { |kind| value.is_a?(kind) }
+        end
+        acc[bundle.to_s] = kept unless kept.empty?
+      end)
+    end
+
+    # Why +bundle+'s plugin doesn't load (as Plugin::Loader checks it), nil
+    # when it does or has none.
+    def unloadable(dir, name, bundle)
+      return nil unless bundle.plugin
+
+      failure = MemoryBundle::Manifest.requires_chi_failure(bundle.requires_chi, Samagotchi::VERSION)
+      return failure if failure
+
+      file = File.join(dir, name, "plugin", bundle.plugin.file.to_s)
+      return "the file is missing" unless File.file?(file)
+
+      expected = MemoryBundle::Provenance.recorded_sha(bundle.plugin.sha256)
+      return "no sha256 recorded for it (reinstall the bundle)" if expected.empty?
+
+      actual = MemoryBundle::Provenance.file_sha(file)
+      "its sha256 differs from the installed one (edited after install? reinstall the bundle)" unless actual == expected
+    end
+
+    # Whether chi ships a bundle +name+ whose manifest lists session_settings.
+    def shipped_settings?(shipped_dir, name)
+      path = File.join(shipped_dir, name, "manifest.yml")
+      return false unless File.file?(path)
+
+      raw = YAML.safe_load_file(path)
+      raw.is_a?(Hash) && raw["session_settings"].is_a?(Array) && !raw["session_settings"].empty?
+    rescue StandardError
+      false
+    end
+
+    def scalar_map?(values)
+      values.is_a?(Hash) && values.values.all? { |value| SCALARS.any? { |kind| value.is_a?(kind) } }
+    end
+
+    def takers(bundles)
+      names = bundles.reject { |_, keys| keys.empty? }.keys.sort
+      names.empty? ? "no installed bundle takes --set" : "bundles that take --set: #{names.join(", ")}"
+    end
+
+    def deep_freeze(settings)
+      settings.to_h { |bundle, values| [bundle.dup.freeze, values.to_h { |k, v| [k.dup.freeze, v.frozen? ? v : v.dup.freeze] }.freeze] }.freeze
+    end
+
+    private_class_method :unloadable, :shipped_settings?, :scalar_map?, :takers, :deep_freeze
+  end
+end

data/lib/samagotchi/bundles/cost-cap/manifest.yml

@@ -1,11 +1,13 @@
 ---
 name: cost-cap
-version: 0.1.0
+version: 0.1.1
 scope: system
 description: "A per-session $ cap: at the cap the turn pauses on Continue (another cap's worth) / Stop, a warning at 80% goes to the user only; /cap shows or sets it"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:bc6683af0063b90d6a3d7c2796bccf446043dfb1b3f07c04bd54d22d26199e1d
+  sha256: sha256:2ea7f76af1ea1c1b0a9a8b0b4b11d6e85a4a816fae224ef5b220cfd20fb48f42
 # ctx.cost is new in chi 0.83.0
 requires_chi: ">= 0.83.0"
+# chi --set cost-cap.cap=3: a session's own cap (ctx.settings["cap"])
+session_settings: [cap]

data/lib/samagotchi/bundles/cost-cap/plugin.rb

@@ -10,13 +10,16 @@
 #
 # Settings (config.yml, bundles: cost-cap:), read at each use from
 # ctx.settings, never at load:
+#   cap: 3.00       this session's own cap, set with chi --set cost-cap.cap=3
+#                   (session_settings: in the manifest); 0/off: none
 #   default: 5.00   USD cap for a session with none set; absent/0/off: none
 #   child: 2.00     for delegate children (ctx.delegate?); absent: default
 #   warn_at: 0.8    the share of the cap that warns; 0/off: no warning
 #
 # State: <data_dir>/sessions/<session id>.json, {"cap": 3.0, "step": 3.0},
 # written by /cap and by Continue; "cap": null (or false) is off for the
-# session, over the config. Without a file the cap comes from the settings.
+# session, over the config. Without a file the cap comes from the settings:
+# cap:, else child: for a delegate, else default:.
 # The cap is resolved once per session id (ctx.delegate? parses the session
 # file) and kept until /cap or Continue writes a new one.
 require "json"
@@ -164,8 +167,9 @@ class Plugin
 
   def breakdown(cost) = "#{money(cost.total)} (#{parts(cost)})"
 
-  # The session's cap and step now: the state file's, else child: for a
-  # delegate, else default:. Cached per session id.
+  # The session's cap and step now: the state file's, else the session's
+  # own cap: (--set), else child: for a delegate, else default:. Cached per
+  # session id.
   def resolve(ctx)
     session = ctx.session_id
     cached = @mutex.synchronize { @resolved }
@@ -189,9 +193,12 @@ class Plugin
 
   def configured(ctx)
     settings = ctx.settings
-    return { cap: nil, step: nil } unless settings.key?("default") || settings.key?("child")
+    return { cap: nil, step: nil } unless %w[cap default child].any? { |key| settings.key?(key) }
 
-    key = settings.key?("child") && ctx.delegate? ? "child" : "default"
+    key = if settings.key?("cap") then "cap"
+          elsif settings.key?("child") && ctx.delegate? then "child"
+          else "default"
+          end
     cap = self.class.amount(settings[key])
     { cap: cap, step: cap }
   end

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

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

data/lib/samagotchi/memory_bundle/builder.rb

@@ -202,7 +202,7 @@ module Samagotchi
         parts.scripts.each_value { |src| FileUtils.cp(src, File.join(staging, "scripts", File.basename(src))) }
       end
 
-      # manifest.yml for the staged bundle: requires_chi, needs and the
+      # manifest.yml for the staged bundle: requires_chi, needs, session_settings and the
       # file descriptions come from the installed bundle's record, the
       # trust_level from the CLI else the record.
       def write_manifest(staging, name, version, files_map, parts)
@@ -223,7 +223,8 @@ module Samagotchi
           needs: record&.needs,
           scripts: parts.scripts.transform_values { |src| "sha256:#{Digest::SHA256.hexdigest(File.binread(src))}" },
           context_providers: parts.context_providers,
-          file_descriptions: file_descriptions(record, files_map)
+          file_descriptions: file_descriptions(record, files_map),
+          session_settings: record&.session_settings || []
         )
       end
 

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -20,13 +20,15 @@ module Samagotchi
     #               the lists as recorded (nil when absent): Manifest.parse_needs
     #               and ContextProviders.parse_list check them
     #   includes    a profile's recorded members, nil for a plain bundle
+    #   session_settings
+    #               the keys a session may set (chi --set), [] when none
     #   error       why manifest.json couldn't be read (the rest empty), else nil
     class InstalledBundle < Data.define(:name, :version, :scope, :source, :installed_at, :trust_level, :source_commit,
                                         :requires_chi, :files, :hooks, :guardrails, :scripts, :plugin, :needs,
-                                        :includes, :context_providers, :error)
+                                        :includes, :context_providers, :session_settings, :error)
       OPTIONAL = { version: nil, scope: nil, source: nil, installed_at: nil, trust_level: nil, source_commit: nil,
                    requires_chi: nil, files: {}, hooks: {}, guardrails: {}, scripts: {}, plugin: nil, needs: nil,
-                   includes: nil, context_providers: nil, error: nil }.freeze
+                   includes: nil, context_providers: nil, session_settings: [], error: nil }.freeze
 
       def initialize(name:, **fields)
         super(name: name, **OPTIONAL, **fields)
@@ -57,7 +59,8 @@ module Samagotchi
             guardrails: mapping(h["guardrails"]) { |meta| sha(meta) },
             scripts: mapping(h["scripts"]) { |meta| sha(meta) },
             plugin: PluginRef.parse(h["plugin"]), needs: h["needs"], context_providers: h["context_providers"],
-            includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil)
+            includes: h["includes"].is_a?(Array) ? h["includes"].map(&:to_s) : nil,
+            session_settings: h["session_settings"].is_a?(Array) ? h["session_settings"].map(&:to_s) : [])
       end
 
       def self.string(value) = value&.to_s

data/lib/samagotchi/memory_bundle/installer.rb

@@ -420,7 +420,8 @@ module Samagotchi
           conflicts: @conflicts.keys,
           scripts_files: installed.script_files,
           context_providers: @manifest.context_providers,
-          file_descriptions: @manifest.file_descriptions
+          file_descriptions: @manifest.file_descriptions,
+          session_settings: @manifest.session_settings
         )
       end
 

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -41,6 +41,9 @@ module Samagotchi
     #       cmd: '{ruby} {bundle_dir}/scripts/pr_context.rb {url}'
     #       why: GitHub PR      #   optional
     #       every_seconds: 300  #   optional
+    #   session_settings: [cap] # optional — the settings a session may set
+    #                          #   (chi --set cost-cap.cap=3), read by the
+    #                          #   plugin from ctx.settings at call time
     #   includes: [a, b]       # optional — a profile (meta bundle): the
     #                          #   shipped bundles it installs; its dir holds
     #                          #   only manifest.yml (MemoryBundle::Profile)
@@ -60,7 +63,7 @@ module Samagotchi
       # the description a mapping gave, for the files that have one; hooks:
       # name → BundleHook.
       attr_reader :name, :version, :scope, :description, :files, :file_descriptions, :hooks, :trust_level, :plugin, :requires_chi, :needs, :includes,
-                  :scripts, :context_providers
+                  :scripts, :context_providers, :session_settings
 
       def initialize(path:)
         @path = path
@@ -84,6 +87,7 @@ module Samagotchi
         @scripts = parse_scripts(raw["scripts"])
         @context_providers = parse_context_providers(raw["context_providers"])
         @includes = parse_includes(raw["includes"])
+        @session_settings = self.class.parse_session_settings(raw["session_settings"])
       end
 
       # A profile: it installs the bundles in includes instead of files.
@@ -136,7 +140,8 @@ module Samagotchi
       # Writes a fresh manifest.yml from computed checksums at `dir`.
       # +file_descriptions+ (name → text) writes those files as mappings.
       def self.write(dir:, name:, version:, files:, scope: nil, description: "", hooks: nil, trust_level: nil,
-                     plugin: nil, requires_chi: nil, needs: nil, scripts: {}, context_providers: [], file_descriptions: {})
+                     plugin: nil, requires_chi: nil, needs: nil, scripts: {}, context_providers: [], file_descriptions: {},
+                     session_settings: [])
         FileUtils.mkdir_p(dir)
         manifest = {
           "name" => name,
@@ -159,9 +164,26 @@ module Samagotchi
         manifest["needs"] = needs.map { |n| n.transform_keys(&:to_s).compact } unless needs.empty?
         manifest["scripts"] = scripts.transform_keys(&:to_s) unless scripts.empty?
         manifest["context_providers"] = context_providers.map(&:to_h) unless context_providers.empty?
+        manifest["session_settings"] = Array(session_settings).map(&:to_s) unless Array(session_settings).empty?
         File.write(File.join(dir, "manifest.yml"), YAML.dump(manifest))
       end
 
+      # A setting key a session may set (BundleSessionSettings::KEY).
+      SESSION_SETTING = /\A[A-Za-z0-9_][A-Za-z0-9_-]*\z/
+
+      # session_settings: → the keys, [] when absent; anything but a list of
+      # plain key names is a ValidationError.
+      def self.parse_session_settings(raw)
+        return [] if raw.nil?
+
+        keys = raw.is_a?(Array) ? raw : nil
+        unless keys&.all? { |key| (key.is_a?(String) || key.is_a?(Symbol)) && key.to_s.match?(SESSION_SETTING) }
+          raise ValidationError, "session_settings: a list of setting names (#{raw.inspect})"
+        end
+
+        keys.map(&:to_s).uniq
+      end
+
       # needs: → [{command:, why:, hint:}] (why/hint a String or nil), [] when
       # absent. Takes the manifest's string-keyed YAML or the symbol-keyed
       # form provenance stores. Duplicates merge (the first one's why/hint

data/lib/samagotchi/memory_bundle/provenance.rb

@@ -141,7 +141,7 @@ module Samagotchi
       # @param context_providers [Array<ContextProviders::Provider>]
       def write(files:, scope:, version:, source_path:, hooks: {}, trust_level: nil, source_commit: nil, hooks_files: {},
                 guardrails_files: {}, plugin_file: nil, requires_chi: nil, needs: nil, conflicts: [], includes: nil,
-                scripts_files: {}, context_providers: [], file_descriptions: {})
+                scripts_files: {}, context_providers: [], file_descriptions: {}, session_settings: [])
         FileUtils.mkdir_p(@bundle_dir)
         bases_dir = File.join(@bundle_dir, "bases")
         FileUtils.mkdir_p(bases_dir)
@@ -239,6 +239,7 @@ module Samagotchi
           end
         end
         manifest_data["context_providers"] = context_providers.map(&:to_h) unless context_providers.empty?
+        manifest_data["session_settings"] = Array(session_settings).map(&:to_s) unless Array(session_settings).empty?
 
         write_manifest(manifest_data)
       end

data/lib/samagotchi/plugin/context.rb

@@ -97,8 +97,24 @@ module Samagotchi
       # @return [String] the bundle the plugin came with
       attr_reader :bundle
 
-      # @return [Hash] config.yml `bundles: <bundle>:` (string keys), frozen
-      attr_reader :settings
+      # config.yml `bundles: <bundle>:` with the session's own values for
+      # the bundle laid over it (chi --set BUNDLE.KEY=VALUE, through the
+      # Host's setup: SessionSetup#bundle_settings), string keys, frozen.
+      # Plugin init and chi.ctx run before the session is bound: with no
+      # session id yet it is the config alone, and it is built again once
+      # per session id (the session's values never change after it starts).
+      # A plugin's initialize(settings) gets the config only: a value a
+      # session may set is read here, at call time.
+      # @return [Hash]
+      def settings
+        id = session_id
+        cached = @session_settings
+        return cached.last if cached && cached.first == id
+
+        merged = id ? overlay(@settings, session_values) : @settings
+        @session_settings = [id, merged].freeze
+        merged
+      end
 
       # @return [Logger]
       attr_reader :log
@@ -419,6 +435,20 @@ module Samagotchi
         nil
       end
 
+      # The session's own values for this bundle ({} without any, or when
+      # the Host can't tell them).
+      def session_values
+        values = @host.setup&.call&.bundle_settings
+        values.is_a?(Hash) ? values.fetch(@bundle, {}) : {}
+      rescue StandardError => e
+        @log.warn("session_settings_unread", error: "#{e.class}: #{e.message}")
+        {}
+      end
+
+      def overlay(config, values)
+        values.empty? ? config : deep_freeze(config.merge(values))
+      end
+
       def deep_freeze(value)
         case value
         when Hash then value.to_h { |k, v| [deep_freeze(k), deep_freeze(v)] }.freeze

data/lib/samagotchi/send_command.rb

@@ -7,6 +7,7 @@ require_relative "session"
 require_relative "session_commands"
 require_relative "session_inbox"
 require_relative "session_manager"
+require_relative "bundle_session_settings"
 require_relative "session_chain"
 require_relative "context_quote"
 require_relative "reply_wait"
@@ -39,7 +40,7 @@ module Samagotchi
 
     USAGE = <<~TEXT
       Usage: chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...
-             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [-m TEXT] [--image PATH]...
+             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [--set BUNDLE.KEY=VALUE]... [-m TEXT] [--image PATH]...
              chi send --new --continues (ID|PREFIX|last:ID) [--model M] [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --queue --wait [--timeout S] [--format json] [-m TEXT] ID
@@ -65,8 +66,9 @@ module Samagotchi
                     (--new) start the next link of that session's chain:
                     in its folder, on its model (or --model's; one whose
                     host is gone falls back to the default, with a
-                    warning), LLM context, thinking level and toolkit,
-                    with a note carrying its recap; it is archived.
+                    warning), LLM context, thinking level, toolkit and
+                    bundle settings, with a note carrying its recap; it
+                    is archived.
                     last:ID names the chain's latest link.
                     Without -m the new session waits idle. Refused for a
                     session continued already (naming the next link) or
@@ -84,6 +86,12 @@ module Samagotchi
                     (full, lean, child, a config or bundle one; default
                     config's toolkit.default), and tools declared on top
                     of it or left out (repeatable, a comma list too)
+        --set BUNDLE.KEY=VALUE
+                    (--new) a bundle setting for this session, over
+                    config.yml's bundles: (repeatable; a key its bundle's
+                    manifest lists in session_settings:; 3, 2.5, true,
+                    false and off are typed, the rest is text:
+                    --set cost-cap.cap=3)
         --wait      wait for the answer and print it (one session); the
                     other lines go to stderr. Exit 3: it waits for an
                     answer from you: the question, its options and the
@@ -141,6 +149,7 @@ module Samagotchi
       f.value "--toolkit"
       f.value "--tool", key: :tools, repeat: true
       f.value "--no-tool", key: :no_tools, repeat: true
+      f.value "--set", key: :sets, repeat: true
       f.value "--image", key: :images, repeat: true
       f.switch "--wait"
       f.switch "--cut"
@@ -284,6 +293,7 @@ module Samagotchi
       %i[dir model continues thinking toolkit].each { |key| return usage_error("--#{key} needs --new") if options[key] }
       TOOLKIT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") unless Array(options[key]).empty? }
       LLM_CONTEXT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") if options[key] }
+      return usage_error("--set needs --new") unless Array(options[:sets]).empty?
       return usage_error("give session ids") if options[:ids].empty?
 
       options
@@ -302,10 +312,11 @@ module Samagotchi
       if options[:continues]
         taken = [("--dir" if options[:dir])] +
                 LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] } + [("--thinking" if options[:thinking])] +
-                [("--toolkit" if options[:toolkit])] + TOOLKIT_FLAGS.filter_map { |key, flag| flag unless Array(options[key]).empty? }
+                [("--toolkit" if options[:toolkit])] + TOOLKIT_FLAGS.filter_map { |key, flag| flag unless Array(options[key]).empty? } +
+                [("--set" unless Array(options[:sets]).empty?)]
         unless taken.compact.empty?
-          return usage_error("--continues takes the previous session's folder, LLM context, thinking level and " \
-                             "toolkit; " \
+          return usage_error("--continues takes the previous session's folder, LLM context, thinking level, " \
+                             "toolkit and bundle settings; " \
                              "leave out #{taken.compact.join(", ")}")
         end
       end
@@ -327,6 +338,11 @@ module Samagotchi
       end
       toolkit = Toolkit.from_flags(name: options[:toolkit], add: options[:tools], remove: options[:no_tools])
       options[:toolkit_value] = toolkit if toolkit
+      begin
+        options[:bundle_settings] = BundleSessionSettings.from_flags(options[:sets]) unless Array(options[:sets]).empty?
+      rescue BundleSessionSettings::Error => e
+        return usage_error(e.message)
+      end
 
       if options[:dir]
         options[:dir] = File.expand_path(options[:dir])
@@ -376,7 +392,8 @@ module Samagotchi
                                                           model_name: options[:model],
                                                           setup: SessionSetup.new(llm_context: options[:llm_context],
                                                                                   thinking: options[:thinking],
-                                                                                  toolkit: options[:toolkit_value]),
+                                                                                  toolkit: options[:toolkit_value],
+                                                                                  bundle_settings: options[:bundle_settings] || {}),
                                                           state_dir: @state_dir)
                   end
       rescue SessionContinue::Refused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e

data/lib/samagotchi/session.rb

@@ -208,6 +208,18 @@ module Samagotchi
       @toolkit = value.is_a?(Toolkit) ? value : Toolkit.from_file(value)
     end
 
+    # The session's own bundle settings (chi --set BUNDLE.KEY=VALUE):
+    # {bundle => {key => value}}, frozen, {} for none and for a session from
+    # before them. Given when it was created and never changed; a respawn,
+    # a continue and a fork keep them (SessionSetup.of), a delegate child
+    # doesn't. Plugin::Context#settings lays them over config.yml's.
+    attr_reader :bundle_settings
+
+    # @param value [Hash, nil] the session file's form too
+    def bundle_settings=(value)
+      @bundle_settings = BundleSessionSettings.normalize(value)
+    end
+
     # The hook that stopped the last turn (stop_turn, or a cut with no retry
     # left), e.g. "loop-guard"; nil when it ended otherwise.
     def stopped_by
@@ -242,7 +254,7 @@ module Samagotchi
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
                    continues: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [],
-                   toolkit: nil, interrupted_turn: nil)
+                   toolkit: nil, bundle_settings: {}, interrupted_turn: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -272,6 +284,7 @@ module Samagotchi
       self.reasoning_history = reasoning_history
       self.appended_prompt_files = appended_prompt_files
       self.toolkit = toolkit
+      self.bundle_settings = bundle_settings
       self.interrupted_turn = interrupted_turn
       @turn_checkpoint = nil
       @archived = false
@@ -369,6 +382,7 @@ module Samagotchi
         reasoning_history: setup.reasoning_history,
         appended_prompt_files: setup.appended_prompt_files,
         toolkit: setup.toolkit,
+        bundle_settings: setup.bundle_settings,
         continues: continues
       )
     end
@@ -434,6 +448,7 @@ module Samagotchi
       "reasoning_history" => nil,
       "appended_prompt_files" => [],
       "toolkit" => nil,
+      "bundle_settings" => {},
       "interrupted_turn" => nil
     }.freeze
 

data/lib/samagotchi/session_setup.rb

@@ -4,6 +4,7 @@ require_relative "llm_context_override"
 require_relative "reasoning_history"
 require_relative "thinking"
 require_relative "toolkit"
+require_relative "bundle_session_settings"
 
 module Samagotchi
   # A session's own settings that come before its model's, carried as one
@@ -15,20 +16,26 @@ module Samagotchi
   # +appended_prompt_files+ the absolute paths chi --append-system-prompt
   # named (their text goes into the system prompt; [] with none),
   # +toolkit+ a Toolkit or nil (SessionManager.spawn_session gives the
-  # session config's toolkit.default then).
+  # session config's toolkit.default then), +bundle_settings+ the bundle
+  # settings chi --set gave ({bundle => {key => value}}, frozen; {} with
+  # none), which Plugin::Context#settings lays over config.yml's.
   #
   # It doesn't save itself: the session keeps each setting in its own field
   # and file key, and resolves it on its own. A delegate child starts
   # without one (but the toolkit its delegate call named); a continue and a
   # fork copy their session's (.of).
-  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files, :toolkit) do
-    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [], toolkit: nil)
+  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files, :toolkit,
+                             :bundle_settings) do
+    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [], toolkit: nil,
+                   bundle_settings: {})
       super(llm_context: llm_context, thinking: thinking, reasoning_history: reasoning_history,
-            appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze, toolkit: toolkit)
+            appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze, toolkit: toolkit,
+            bundle_settings: BundleSessionSettings.normalize(bundle_settings))
     end
 
     def empty?
-      llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty? && toolkit.nil?
+      llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty? && toolkit.nil? &&
+        bundle_settings.empty?
     end
 
     # A session's own setup, for a session that starts from it. Its
@@ -40,7 +47,8 @@ module Samagotchi
       return new if session.nil?
 
       new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history,
-          appended_prompt_files: session.appended_prompt_files, toolkit: Toolkit.of(session.toolkit))
+          appended_prompt_files: session.appended_prompt_files, toolkit: Toolkit.of(session.toolkit),
+          bundle_settings: session.bundle_settings)
     end
   end
 end

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -50,7 +50,9 @@ module Samagotchi
       #   session's toolkit (config's toolkit.default without); an existing
       #   session keeps its own
       # @param toolkit_flags [Array<String>] which of those were given, for
-      #   the line an existing session's run prints
+      #   the line an existing session's run prints (--set too)
+      # @param bundle_settings [Hash] --set's values (BundleSessionSettings):
+      #   a new session's setup carries them; an existing session keeps its own
       # @param state_dir [String, nil] where the sessions are (the default
       #   state dir by default): the worker's, for the attached loop too
       # @return [Symbol] :detached, :closed when the worker went away,
@@ -58,11 +60,12 @@ module Samagotchi
       #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
               memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
-              toolkit_flags: [], state_dir: nil)
+              toolkit_flags: [], bundle_settings: {}, state_dir: nil)
         state_dir ||= Session.default_state_dir
         client = connect(attach: attach, shared: shared, resume: resume, model: model, state_dir: state_dir,
                          memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking,
-                         appended_prompt_files: appended_prompt_files, toolkit: toolkit, toolkit_flags: toolkit_flags)
+                         appended_prompt_files: appended_prompt_files, toolkit: toolkit, toolkit_flags: toolkit_flags,
+                         bundle_settings: bundle_settings)
         commands = []
         commands << "/model #{model}" if model && (attach || resume)
         commands << LLMContextOverride.command_line(llm_context) if (attach || resume) && !llm_context.empty?
@@ -131,7 +134,7 @@ module Samagotchi
       # @raise [Error]
       def connect(attach: nil, shared: false, resume: nil, model: nil, state_dir: nil, wait: BRIDGE_WAIT,
                   memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
-                  toolkit_flags: [], err: $stderr)
+                  toolkit_flags: [], bundle_settings: {}, err: $stderr)
         sd = state_dir || Session.default_state_dir
         if attach || resume
           warn_memory_flags_ignored(attach || resume, memories, muted_memories, err, appended_prompt_files: appended_prompt_files,
@@ -153,7 +156,7 @@ module Samagotchi
                                                  setup: SessionSetup.new(llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
                                                                          thinking: Thinking.session_level(thinking),
                                                                          appended_prompt_files: appended_prompt_files,
-                                                                         toolkit: toolkit))
+                                                                         toolkit: toolkit, bundle_settings: bundle_settings))
                   end
         client = BridgeClient.wait_for(session.id, session_dir: Session.session_dir(session.id, state_dir: sd), timeout: wait)
         client || raise(Error, "the worker for session #{session.id} did not start its Bridge in time")

data/lib/samagotchi/terminal_ui.rb

@@ -100,12 +100,16 @@ module Samagotchi
     # @param toolkit [Toolkit, nil] --toolkit/--tool/--no-tool: a new
     #   session's toolkit (config's toolkit.default without); a resumed one
     #   keeps its own, with a line naming +toolkit_flags+ (the flags given)
+    # @param bundle_settings [Hash] --set's values (BundleSessionSettings):
+    #   a new session's own; a resumed one keeps its own (--set is in
+    #   +toolkit_flags+ then)
     def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
                    spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil,
-                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [])
+                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], bundle_settings: {})
       @scratch        = scratch
       @toolkit        = toolkit
       @toolkit_flags  = toolkit_flags
+      @bundle_settings = bundle_settings
       @thinking_word  = thinking
       @prompt         = prompt
       @llm_context_words = llm_context
@@ -274,7 +278,8 @@ module Samagotchi
         preloaded_memory_names: @requested_memories,
         muted_memory_names: @muted_memory_names,
         scratch: @scratch,
-        setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files, toolkit: @toolkit || Toolkit.configured)
+        setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files, toolkit: @toolkit || Toolkit.configured,
+                                bundle_settings: @bundle_settings)
       ))
       # --llm-context*: the session's own values, over a resumed one's.
       # Saved at once on a resumed one: leaving before a turn keeps them.

data/lib/samagotchi/testing/bundle.rb

@@ -11,6 +11,7 @@ require_relative "../peer_sources"
 require_relative "../toolkit"
 require_relative "../guardrails/gate"
 require_relative "../memory_bundle/manifest"
+require_relative "../session_setup"
 require_relative "sandbox"
 require_relative "recorder"
 require_relative "host"
@@ -74,11 +75,15 @@ module Samagotchi
         # @param dir [String] the bundle's folder (its manifest.yml)
         # @param settings [Hash] config.yml `bundles: <name>:`
         # @param host [Hash] session values (Recorder::DEFAULTS' keys)
+        # @param session_settings [Hash] the session's own values for the
+        #   bundle (chi --set), keys its manifest lists in session_settings:;
+        #   ctx.settings lays them over +settings+ (Plugin::Context#settings),
+        #   initialize(settings) doesn't see them
         # @param sandbox [Sandbox, nil] default Sandbox.current, else one of
         #   its own, left at #shutdown
         # @return [Bundle]
-        def load(dir, settings: {}, host: {}, sandbox: nil)
-          new(dir, settings: settings, host: host, sandbox: sandbox).tap(&:load!)
+        def load(dir, settings: {}, host: {}, session_settings: {}, sandbox: nil)
+          new(dir, settings: settings, host: host, session_settings: session_settings, sandbox: sandbox).tap(&:load!)
         end
 
         # A bundle chi ships (lib/samagotchi/bundles/<name>), as #load.
@@ -118,14 +123,16 @@ module Samagotchi
       # @return [Integer] how often chi was told the tools changed
       attr_reader :tools_changes
 
-      def initialize(dir, settings: {}, host: {}, sandbox: nil)
+      def initialize(dir, settings: {}, host: {}, session_settings: {}, sandbox: nil)
         @dir = File.expand_path(dir)
         @manifest = MemoryBundle::Manifest.read(dir: @dir)
         @name = @manifest.name
         @settings = stringify(settings || {})
+        @session_moves = 1
+        own = session_settings.nil? || session_settings.empty? ? {} : { setup: setup_with(session_settings, host[:setup]) }
         @own_sandbox = sandbox.nil? && Sandbox.current.nil?
         @sandbox = sandbox || Sandbox.current || Sandbox.enter
-        @recorder = Recorder.new(cwd: @sandbox.work_dir, **host)
+        @recorder = Recorder.new(cwd: @sandbox.work_dir, **host, **own)
         @sessions = Sessions.new
         @http = FakeHttp.new
         @inits = []
@@ -309,7 +316,16 @@ module Samagotchi
       end
 
       # Change the session's values (cwd:, messages:, running: …).
-      def set(**values)
+      # +session_settings+ changes the session's own values for the bundle
+      # (as Bundle.load's) and moves it to a new session id
+      # ("test-session-2", or the session_id: given beside it): chi never
+      # changes them within a session, and ctx.settings is built once per
+      # session id.
+      def set(session_settings: nil, **values)
+        unless session_settings.nil?
+          values[:setup] = setup_with(session_settings, @recorder[:setup])
+          values[:session_id] ||= "#{@recorder[:session_id] || "test-session"}-#{@session_moves += 1}"
+        end
         @recorder.set(**values)
         self
       end
@@ -363,6 +379,16 @@ module Samagotchi
         result
       end
 
+      # +setup+ (the recorder's, nil for none) with +session_settings+ as
+      # this bundle's own values, checked against the manifest's
+      # session_settings: as chi --set checks them.
+      # @raise [ArgumentError] a key the manifest doesn't list
+      def setup_with(session_settings, setup)
+        values = { @name => stringify(session_settings) }
+        BundleSessionSettings.check!(values, bundles: { @name => @manifest.session_settings }, flag: "session_settings")
+        (setup || SessionSetup.new).with(bundle_settings: values)
+      end
+
       def stringify(value)
         case value
         when Hash then value.to_h { |key, item| [key.to_s, stringify(item)] }

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -649,6 +649,15 @@ module Samagotchi
         thinking, error = request_thinking(body["thinking"])
         return error if error
 
+        # bundle_settings: the session's own bundle settings (chi --set:
+        # {bundle => {key => scalar}}), checked against the installed
+        # bundles the same way.
+        begin
+          bundle_settings = BundleSessionSettings.from_request(body["bundle_settings"])
+        rescue BundleSessionSettings::Error => e
+          return error_response(400, "invalid_bundle_settings", e.message)
+        end
+
         folder = dir ? { working_directory: dir } : {}
         # model: the model the session starts on (the start page's picker,
         # spelled as GET /api/models lists it); blank means the default.
@@ -659,7 +668,7 @@ module Samagotchi
         # until that turn is saved.
         preview = idle ? body["preview"].to_s.strip : ""
         folder[:title] = preview unless preview.empty?
-        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking)
+        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking, bundle_settings: bundle_settings)
         folder[:setup] = setup unless setup.empty?
         begin
           session = @manager.spawn_session(prompt: idle ? nil : prompt.to_s, state_dir: @state_dir, **folder)
@@ -679,7 +688,7 @@ module Samagotchi
       # POST /api/sessions with continues: <id, prefix or last:id>: the next
       # link of that session's chain (SessionManager.continue_session), in its
       # folder and with its own setup (SessionSetup: llm_context, thinking
-      # and reasoning_history levels), so dir, llm_context and thinking are
+      # and reasoning_history levels, bundle settings), so dir, llm_context, thinking and bundle_settings are
       # refused beside it (a create takes no reasoning_history). It runs on
       # model (or model_name) when given, else on the previous link's: one
       # whose host is gone falls back to the default, and the 201's
@@ -694,9 +703,9 @@ module Samagotchi
         unless given.is_a?(String) && !given.strip.empty?
           return error_response(400, "invalid_continues", "continues is a session id")
         end
-        if (fields = %w[dir llm_context thinking].select { |key| body.key?(key) }).any?
+        if (fields = %w[dir llm_context thinking bundle_settings].select { |key| body.key?(key) }).any?
           return error_response(400, "invalid_continues",
-                                "continues takes the previous session's folder, llm_context and thinking; " \
+                                "continues takes the previous session's folder, llm_context, thinking and bundle_settings; " \
                                 "leave out #{fields.join(", ")}")
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.83.0
+  version: 0.84.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -180,6 +180,7 @@ files:
 - lib/samagotchi/broadcast_command.rb
 - lib/samagotchi/bundle_command.rb
 - lib/samagotchi/bundle_needs.rb
+- lib/samagotchi/bundle_session_settings.rb
 - lib/samagotchi/bundles/agents-md/manifest.yml
 - lib/samagotchi/bundles/agents-md/plugin.rb
 - lib/samagotchi/bundles/btw/manifest.yml