samagotchi 0.107.0 → 0.108.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58e0f763c1974428c1144b884f63a9529fe5b1a973b1443e44b0a4e1a3f3cf48
-  data.tar.gz: 6c6a8a429e01a837329065239819bf69568e1455425bcf60e1badae8208553be
+  metadata.gz: 3f63eb88d80157a6b77f733031284c1a4e376528356f8d099ffe356b4cd7e6c1
+  data.tar.gz: eab92f98b12468b5c882e5ee80524fdf151a1b479fd232ea54f8318bf952c2e3
 SHA512:
-  metadata.gz: b0fe1b18a4b7defe96fc787ab753e9cfbf6c62eebddac74d05d74b972439b87737a9b5e6192c1d026dc2add3702b1659be6846ebaa894bd87e65dc5ccdffd823
-  data.tar.gz: 7a74e55c15487d3ccdac35ecaaec567b5feefab39312712b2ed07befdbfd9def1b5e4685170cc28550fd89f47eca839e5aa06a3c4128ae426e89962f69f0c1db
+  metadata.gz: c5df88fe266c32153072be45890e6c12f54bcab0492d367cabc0f0066e6dec41bfc8d54e800f08c610979c3ec66131f7082dbc8691ea3854498ce603f553ffec
+  data.tar.gz: e324e458bc5801eec9bc0f170ab5b839fbc4633ca33ce026566cac121deed90b53149a1052a9ec4607f67a7e3d284b4201c08309b5e8eeb1181bd1ff3ec65e31

data/CHANGELOG.md

@@ -8,6 +8,41 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.108.0] - 2026-10-24
+
+### Added
+
+- A project's memories copied from another machine or path (their folder keyed by the old path's hash) are no
+  longer missing without a word: when this project's folder is missing or empty and one of the same name with
+  another hash exists, chi warns at session start (`memory>`) and under a project `memory_read` miss, naming both
+  folders and the `mv` that fixes it. See docs/memory.md (Moving memories to another machine).
+
+### Changed
+
+- `chi send --wait` and `chi answer` left with the turn still running (`--timeout`, Ctrl-C) offer the command that waits
+  again: `chi send --wait --turn T ID`, or `chi send --wait ID` when the turn's id isn't known (with the attach that
+  shows it); under `--remote NAME` both carry it.
+- `chi send --wait` into a running turn is refused with what to do next: `--queue` runs the message after it,
+  `chi send --wait ID` waits for it, `chi --attach ID` shows it (under `--remote NAME` the attach, no longer "open it
+  in chi web").
+
+### Fixed
+
+- `chi -p … --non-interactive` prints the load warnings (a guardrail or plugin that failed to load, the orphaned
+  project memory folder) on stderr as `<label>> …` lines; it used to drop them.
+- cost-cap 0.2.3, work-cap 0.1.3: a session's state file that doesn't read (not JSON) no longer drops its `/cap` or
+  `/workcap` cap silently: it is logged and you get one notice naming the file and the cap used instead (the
+  config's), and the next `/cap`, `/workcap` or Continue that writes over it says so instead of replacing it silently.
+- `chi send --wait -m` to an idle session (and `--new --wait`) waits for its message's own turn: a worker that dies
+  in that turn ends the wait `canceled` (`worker_stopped`) once the next worker settles it, instead of sitting to
+  the timeout; the `turn_id` it reports was already that turn's.
+- A `delegate` follow-up's wait (or delegate report) to an idle child no longer takes the child's previous turn's
+  reply for its own when it looks just as the follow-up's own turn starts.
+- A scheduled job that dies of an error outside Ruby's StandardError (a stack overflow, a job calling `exit`) no
+  longer cuts chi's shutdown short: the rest of it (plugin tasks, MCP servers) still stops.
+
+Update with `chi update` (the system bundle 0.108.0, the cost-cap bundle 0.2.3, the work-cap bundle 0.1.3), then restart `chi web`.
+
 ## [0.107.0] - 2026-10-24
 
 ### Added
@@ -4130,7 +4165,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.107.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.108.0...HEAD
+[0.108.0]: https://github.com/dm1try/samagotchi/compare/v0.107.0...v0.108.0
 [0.107.0]: https://github.com/dm1try/samagotchi/compare/v0.106.0...v0.107.0
 [0.106.0]: https://github.com/dm1try/samagotchi/compare/v0.105.0...v0.106.0
 [0.105.0]: https://github.com/dm1try/samagotchi/compare/v0.104.0...v0.105.0

data/docs/architecture.md

@@ -201,7 +201,8 @@ These are the Engine's raw events. The worker's SSE projection omits `call` from
 `:tool_call_started` and `result` from `:turn_completed`; the answer remains in
 `turn_summary.output`.
 
-A turn started with `origin:` carries it on each of these (and `:turn_failed`).
+A turn started with `origin:` (a `TurnOrigin`, or its Hash) carries it on each of these (and `:turn_failed`), as
+the Hash `{client_id:, enqueued_id:, author:}` with only the fields set (`TurnOrigin#to_h`).
 
 Every event is a `Hash` with a `:type` symbol key; the sink must not raise (the Engine
 rescues sink errors). A new UI (web, API) supplies its own `on_event` and
@@ -695,7 +696,7 @@ A map of the parts the overview above doesn't name (paths under `lib/samagotchi/
 | LLM context strategies | `llm_context_strategy.rb`, `llm_context_view.rb`, `llm_context_stale.rb`, `llm_context_forget.rb` | What a request sends of the history (none, stale, forget) ([internals/llm-context-forget.md](internals/llm-context-forget.md)). |
 | Session chains | `session_continue.rb` (`SessionContinue`), `session_chain.rb` (`SessionChain`) | A session that continues an earlier one. `SessionChain.opener_for` gives the text web `continue →` prefills in the new link: the previous link's own first typed message when that link continues one itself, else nil (the 201's `opener`; not saved) ([sessions.md](sessions.md)). |
 | Review sessions | `review_start.rb` (`ReviewStart`), `session_review.rb` (`SessionReview`, the session's `review` field), `review_command.rb` (`ReviewCommand`, `chi review`), `review_apply.rb` (`ReviewApply`) | A session made to be shared: idle, its subjects project files checked by `Guardrails::ReviewPaths`, a fork of a working session from its recap (`--from`); Apply quotes a participant's review turn into the owner's composer ([sessions.md](sessions.md#review-sessions), [internals/participants.md](internals/participants.md)). |
-| Participants | `participants.rb` (`Participants`, the `participants.json` sidecar), `share_command.rb` (`ShareCommand`, `chi share`), `session_participants.rb`, `participants_watch.rb`, `web/grants.rb` (`Web::Grants`), `web/principal.rb` (`Web::Principal`), `web/participant_access.rb` (`Web::ParticipantAccess`), `web/participant_review.rb` + `web/participant_view.rb` (`Web::ParticipantReview`, `Web::ParticipantView`), `web/participant_stream_filter.rb`, `guardrails/review_boundary.rb` + `guardrails/review_paths.rb` | The people or agents an owner invites to review one session through chi web: their grants and gate, what they read, their read-only review turns ([internals/participants.md](internals/participants.md), [guardrails.md](guardrails.md)). |
+| Participants | `participants.rb` (`Participants`, the `participants.json` sidecar), `share_command.rb` (`ShareCommand`, `chi share`), `session_participants.rb`, `participants_watch.rb`, `web/grants.rb` (`Web::Grants`), `web/principal.rb` (`Web::Principal`), `web/participant_access.rb` (`Web::ParticipantAccess`: the participant's gate and routes), `web/participants_admin.rb` (`Web::ParticipantsAdmin`: the owner's invite, list, revoke, cap and Apply routes), `web/participant_review.rb` + `web/participant_view.rb` (`Web::ParticipantReview`, `Web::ParticipantView`), `web/participant_stream_filter.rb`, `guardrails/review_boundary.rb` + `guardrails/review_paths.rb` | The people or agents an owner invites to review one session through chi web: their grants and gate, what they read, their read-only review turns ([internals/participants.md](internals/participants.md), [guardrails.md](guardrails.md)). |
 | Analytics | `analytics_file.rb` (`AnalyticsFile`), `session_metrics/totals.rb` (`SessionMetrics::Totals`), `session_metrics/model_segment.rb` (`SessionMetrics::ModelSegment`) | A session's `analytics.json` (`SessionMetrics#persist`); the sums over its turn records (`Totals`: tokens, cost, speeds, kept as running counters) and their split per model after a `/model` switch (`ModelSegment`: a run of turns on one model, the `model_segments` rows); `session_metrics/cost.rb` (`SessionMetrics::Cost`): the spend `ctx.cost` reads; `session_metrics/usage.rb` (`SessionMetrics::Usage`): the work `ctx.usage` reads. `session_metrics/side_totals.rb` (`SessionMetrics::SideTotals`) and `side_usage.rb` (`SideUsage`): the side requests' sums, apart from the turns'. |
 | Images / vision | `image_store.rb` (`ImageStore`), `vision_support.rb`, `vision_context.rb` | Stored prompt images and whether a model takes them. |
 | Toolkits | `toolkit.rb` (`Toolkit`), `toolkit_binding.rb` (`ToolkitBinding`, the Engine's seam), `toolkit_command.rb` (`/toolkit`), `tools/registry.rb` (`Registry#toolkit`, `#left_out_names`), `web/public/toolkit_chip.js` | Which registered tools a session's prompts declare: saved in the session, resolved at a turn's start (`Engine#apply_toolkit!`), named in the prompt's not-loaded line, a kit's prompt text after the appended files; `chi.toolkit` and `ctx.use_toolkit` for plugins ([configuration.md](configuration.md#toolkits)). |

data/docs/internals/engine.md

@@ -424,7 +424,7 @@ The turn as the Engine sees it (the KernelLoop has its own `Turn` struct):
 Turn = Struct.new(:session, :prompt, :continue, :on_event, :controller, :origin, :started_at, :messages, :ended,
                   :settings, :id, :limit, :resumed, :resume_from) do
   def resumed? = resumed ? true : false                           # a step-limit Continue
-  def tag(event) = origin ? event.merge(origin: origin) : event   # boundary events carry the origin
+  def tag(event) = origin ? event.merge(origin: origin.to_h) : event   # boundary events carry the origin's wire Hash
   def elapsed = ...                                               # seconds since started_at
 end
 ```
@@ -519,11 +519,22 @@ Turn events (the main ones; `Events` in `events.rb` keeps the shared sets):
 | `:turn_failed` | an error | `{error_class, message, duration_ms, error_kind?, retryable?, host?, summary?}` |
 | `:answer_display` | after the after_turn hooks (observers only, not the sink) | `{display, refs?}` (display a string, or nil; refs the count of the answer's refs, only when a hook attached some) |
 
-The boundary events (`:turn_started`, `:turn_completed`, `:turn_canceled`, `:turn_failed`) also carry `origin`
-when the turn was queued with one: `{client_id:, enqueued_id:}`, plus `author:` when someone other than the session's
-owner wrote it (its input file's `author`, stamped by chi web from the request's `Web::Principal`). An owner's turn
-has no `author` anywhere: not in its input file, its origin or the session. `GuardrailWiring#begin_turn` gets the
-origin, and `#turn_author` reads its author for the gate's checks.
+A turn's origin is a `TurnOrigin` (`lib/samagotchi/turn_origin.rb`, a `Data.define` of `client_id`, `enqueued_id`
+and `author`): `SessionInbox.read_input` makes it from an input file's own fields, the wakes, reports and reminders
+make theirs, and `Engine#run_turn`, the Worker and `GuardrailWiring` pass it on. Its readers say what callers ask
+(`#participant?`, `#participant_author`, `#participant_id`, `#source` = `ClientId.origin`, `#human?` =
+`ClientId.human?`). At a boundary it is turned once: `#to_h` writes the wire Hash (only the fields set, as before),
+`TurnOrigin.from` reads a Hash back (symbol or string keys; nil for none). In-process an origin is never nil:
+`TurnOrigin.of` gives `TurnOrigin::NONE` (no sender: an owner's turn with no client) for nil or `{}`, and NONE is
+`run_turn(origin:)`'s default (a Hash is still read as one). NONE has no wire form (`#empty?`; `#wire` is nil, or
+`#to_h` for any other origin), so the events and the hooks' `context` carry no origin for it, as before.
+`LastTurn#author` stays the session file's string; `LastTurn#participant_author` reads it as
+`TurnOrigin#participant_author` does. The boundary events (`:turn_started`, `:turn_completed`, `:turn_canceled`, `:turn_failed`) also carry
+`origin` when the turn was queued with one: `{client_id:, enqueued_id:}`, plus `author:` when someone other than
+the session's owner wrote it (its input file's `author`, stamped by chi web from the request's `Web::Principal`).
+An owner's turn has no `author` anywhere: not in its input file, its origin or the session. `GuardrailWiring#begin_turn`
+gets the origin, and `#turn_author` reads its participant author for the gate's checks; the guardrails `Context`
+(the hooks' `context`) keeps the wire Hash.
 
 Where a participant's author (`"p:<id>"`; `Steer.participant_author?`: any author but none or `"owner"`) goes:
 

data/docs/internals/participants.md

@@ -135,8 +135,8 @@ lock), and its ack and `:turn_enqueued` say `queue`; the worker's drain takes no
 turn (`Worker#pending_input_drain`, for a file the Bridge never saw), so each runs as the owner's own turn after it.
 The web's delivery line says so (`participantTurn`: Enter queues, no cut), the TUI prints its queued note, `chi send`
 says `(queued: runs after the current turn)` and its `--wait` waits for that turn (`WaitTarget.message`). The owner's
-own turns steer as before. A step-limit Continue of a participant's turn (the owner answers it) continues as theirs: its origin keeps
-their author (`ContinueOffer#run_continue_turn`), so it runs inside the boundary and on their spend; once their link ended or their cap is reached, the owner's Continue
+own turns steer as before. A step-limit Continue of a participant's turn (the owner answers it) continues as theirs: its origin (a `TurnOrigin`,
+`#participant?`; see engine.md) keeps their author (`ContinueOffer#run_continue_turn`), so it runs inside the boundary and on their spend; once their link ended or their cap is reached, the owner's Continue
 ends the offer as a Stop instead (`ContinueOffer#refuse_continue`: decision `refused`, a notice, `not_continued`), so
 nothing waits on it. The step-limit Continue offer of the owner's turn is the
 owner's to answer: while one stands, the worker **holds** a participant's input file (`Worker#run_input_files`,
@@ -306,6 +306,9 @@ the owner sees the text before it runs (docs/guardrails.md, the review boundary)
 
 ## The owner's routes
 
+`Web::ParticipantsAdmin` (`web/participants_admin.rb`, mixed into `App` beside `ParticipantAccess`, the participant's own
+gate and routes) answers these.
+
 | Route | Body / params | Answer | Refusals |
 |---|---|---|---|
 | `GET /api/sessions/:id/participants` | | 200 `{participants: [grant], warning}`, every state; `warning`: the share warning for a session that isn't a review session (`ReviewStart.share_warning`, null for one), shown before the panel's Invite with Start a review of it | |

data/docs/internals/working-set.md

@@ -52,7 +52,8 @@ is left out. So is a failed run (`LLMContextStale`'s rule: an `Error` after the
   add op `edit`.
 - `memory_read` gives one memory per name (`Tools::MemoryRead.parse_names`; an empty name, the index listing, gives
   none). A partial read ("a,b" where b is missing: the found bodies, then `Error: memory not found: b`) keeps the
-  found names only, and its tokens are split evenly among them.
+  found names only, and its tokens are split evenly among them. The names come off that line alone
+  (`WorkingSet::MISSING`): an orphaned-folder hint may follow it on the next line.
 - `memory_write` gives the memory `call[:path]`, op `write`. A `remove: true` write stays in the set.
 - `web_fetch` gives the URL with its whitespace collapsed.
 

data/docs/memory.md

@@ -21,6 +21,26 @@ Tool behavior:
 - `chi memory ls` and `chi memory rm NAME` are the user's side of the same (see [Listing and removing from the shell](#listing-and-removing-from-the-shell)).
 - `write`/`edit` that change a `*.md` right in a scope dir refresh its managed `index.md` line (date, bytes; the description is kept), as `memory_write` does. A memory created with `write` gets a line with no description; any other `.md` written there gets a line too. Model overlays (`<name>.<key>.md` next to `<name>.md`), files in another project's folder and files changed by `execute` are left out.
 
+## Moving memories to another machine
+
+A project's folder is keyed by its root's absolute path (`<basename>_<8 hex of MD5(root)>`), so project
+memories copied to a machine (or a path) where the repository lives elsewhere sit in a folder chi no
+longer reads. Rename the folder to the new key, or move memories with a bundle zip (see
+[What a bundle owns](#what-a-bundle-owns)).
+
+Inside a git repository, when this project's folder is missing or holds no `*.md` while the projects
+dir has a folder of the same basename with another hash, chi says so, naming both folders and the
+`mv` that fixes it (a name match can't prove it's the same project, so nothing is renamed for you):
+
+- at session start, a `memory>` load warning (a `:guardrail_warning` with label `memory`; the attached
+  TUI, the REPL, `--non-interactive` and the web show it; a UI that attaches later gets it from the
+  worker's cards), once per worker or REPL process, so a respawn or resume says it again;
+- under a `memory_read` miss that looked in project scope (`scope: "project"` or none), and under the
+  project index read, on a `Hint:` line after `Error: memory not found: …`. A system-scope read never
+  gets it.
+
+Neither enters the system prompt.
+
 ## Listing and removing from the shell
 
 `chi memory ls [--scope project|system] [--format text|json]` lists the

data/docs/plugins.md

@@ -1708,7 +1708,10 @@ parent may Continue: nothing restricts it, as with the step limit. A background
 its own card and doesn't wake its parent ([sessions.md](sessions.md#delegating)).
 
 The state is one file per session, `<data_dir>/sessions/<session id>.json` (`{"cap": 3.0, "step": 3.0}`), removed
-with the session.
+with the session. A file that is there but doesn't read (not JSON, or not a mapping) is logged
+(`costcap_state_unreadable`) and gets one notice, `cost-cap: <path> doesn't read, its /cap cap is ignored; using
+default: ($5.00)`: the settings' cap is used, never a silent drop; the next `/cap` or Continue rewrites it, logged
+(`costcap_state_replaced`) and said (`cost-cap: <path> didn't read; replaced with the new cap`).
 
 Its sibling for work instead of money, tool calls and active minutes across the session's turns, is
 [the work-cap bundle](#the-work-cap-bundle): the cap a local model (no cost) can have.
@@ -1766,7 +1769,11 @@ bundles:
 - `/workcap off` (or `/workcap 0`): no work cap for this session, over the config.
 
 The state is one file per session, `<data_dir>/sessions/<session id>.json` (`{"tool_calls": {"cap": 800, "step":
-400}}`, a meter's `"cap": null` for off).
+400}}`, a meter's `"cap": null` for off). A file that is there but doesn't read (not JSON, or not a mapping) is
+logged (`workcap_state_unreadable`) and gets one notice, `work-cap: <path> doesn't read, its /workcap caps are
+ignored; using default.tool_calls: (400)`: the settings' caps are used, never a silent drop; the next `/workcap` or
+Continue rewrites it, logged (`workcap_state_replaced`) and said (`work-cap: <path> didn't read; replaced with the
+new cap`).
 
 ## The check-in bundle
 

data/docs/releasing.md

@@ -25,7 +25,8 @@ can run the whole release; the user approves the notes before the tag and the
     marked bundle's `requires_chi` to `">= X.Y.Z"` and drops the marker;
     `release:check` fails while a marker is left. chi itself ignores the key,
     and `bundles:check` notes it (and fails a marker that isn't `true` or a
-    one-line string). `release:bump` touches no other `requires_chi`;
+    one-line string). `release:bump` touches no other `requires_chi` but a
+    profile's (next point);
   - a new `ctx.*` / `chi.*` call a plugin may make gets its release's version in `Plugin::Api::SINCE` once
     released (`chi bundle check`'s `requires-chi-floor` reads it); an unreleased one waits there as a comment;
   - a new shipped bundle joins a profile (`includes:` in `core` or `dev`; a
@@ -33,9 +34,11 @@ can run the whole release; the user approves the notes before the tag and the
     goes up: `chi update` then installs only the new bundle for those who
     have the profile;
   - a profile's `requires_chi` is its members' highest: a member's raised
-    floor (by hand, or by `release:bump` for a `requires_chi_next` marker)
-    raises its profile's too, with the profile's version (`bundles:check`
-    notes a profile below a member);
+    floor raises its profile's too, with the profile's version. `release:bump`
+    does both for a profile its `requires_chi_next` raises leave below a
+    member (a patch bump of the profile's version, once per release); a floor raised by hand
+    needs the profile raised by hand (`bundles:check` notes a profile below a
+    member);
   - the release notes say "run `chi update`" and name the bundles whose
     version moved (what changed in each), not per-bundle upgrade steps.
 - Pre-1.0: config and commands may change in a minor version (0.2 → 0.3); a
@@ -67,7 +70,7 @@ as the GitHub release body.
 | `rake lint` / `rake lint:fix` | RuboCop over the repo (must report no offenses; CI runs it) / its safe autocorrect (`rubocop -a`). |
 | `rake gem:validate`, `gem:build`, `gem:install`, `gem:clean` | Check the gemspec; build the gem into `pkg/`; build and install it locally; remove the built gems. |
 | `rake release:draft_changelog` | A draft Unreleased section from the commit subjects since the last tag, grouped. Stdout only. |
-| `rake release:bump[X.Y.Z]` | VERSION, the system manifest, Gemfile.lock, CHANGELOG, and `requires_chi: ">= X.Y.Z"` for each bundle marked `requires_chi_next` (the marker dropped). No commit. |
+| `rake release:bump[X.Y.Z]` | VERSION, the system manifest, Gemfile.lock, CHANGELOG, and `requires_chi: ">= X.Y.Z"` for each bundle marked `requires_chi_next` (the marker dropped), then a profile left below a member's `requires_chi` raised to it, with a patch bump of its version (none when it moved since the last tag) and named in the CHANGELOG's "Update with `chi update`" line. No commit. |
 | `rake release:check` | Clean tracked tree, VERSION == system bundle, a CHANGELOG section, no `requires_chi_next` left, `bundles:check`, `rake lint` (RuboCop) + `npm run lint` (the web frontend's ESLint), rspec (both roots: `spec` and the bundles' own `spec/`) + `rake bundles:specs` + npm test, `gem build`, then a clean install into a temp GEM_HOME that runs `chi --version`, `chi self` and `chi bundle list` with a temp HOME. Needs the network (gem dependencies). |
 | `rake release:notes[X.Y.Z]` | Prints the CHANGELOG section (default: the current VERSION). |
 
@@ -85,7 +88,9 @@ The agent does each step and stops where the user has to say yes.
 3. **The user approves the notes and the version.** Show them the section.
 4. **Bump.** `bundle exec rake "release:bump[X.Y.Z]"`, review `git diff`: it
    names the bundles whose `requires_chi` it raised (their `requires_chi_next`
-   markers are gone).
+   markers are gone) and the profiles it raised with them (a patch bump of
+   each one's version, none for a profile already bumped since the last tag),
+   which it names in the CHANGELOG's "Update with `chi update`" line.
 5. **Check.** Commit first (the check wants a clean tree), then run it:
    `git commit -am "Release X.Y.Z"` and `bundle exec rake release:check`.
    Fix anything it finds in new commits and run it again.

data/docs/sessions.md

@@ -29,7 +29,7 @@ A session is deleted if **expired by age OR overflow by count** (unless `keep_st
 
 **A worker outlives whoever started it:** a spawned worker leaves its spawner's process tree (it is forked again, in a session of its own, and reparented to init), so closing the terminal of a `chi web`, or a tool tearing down a background `chi send --wait` and its children, no longer takes the worker and its turn with it.
 
-**A worker killed mid-turn:** while a turn runs, its worker keeps it on disk (`TurnCheckpoint`): the session file has the turn so far (the prompt from the turn's start, then the finished tool steps and lines merged into it) and `interrupted_turn: {id, started_at, at, iteration, enqueued_id}` (`enqueued_id`: the input the turn runs, so any process can tell which turn is running; a continue turn carries its offer turn's), written as the turn starts, at the loop's first iteration boundary and then at most every 10 s (`updated_at` moves with it). The turn's end saves the real messages without the mark. A worker that died without ending its turn (SIGKILL, a crash of the process) leaves the mark, and loses what came after its last written boundary: at most the last 10 s of steps, plus the step in flight. Each checkpoint write also saves the turn's metrics so far to `analytics.json` (tokens, speeds, timings, its finished tool calls), as the record a killed turn leaves: canceled, `cancellation_reason: worker_stopped`; the turn's own end writes over it. The next worker to start for the session (a `chi send`, `--resume`, `--attach`, the web), or a `--no-shared` REPL resuming it, settles the turn before anything else (`TurnCheckpoint.settle`, log `interrupted_turn_settled`): a note `the previous turn was cancelled (worker-stopped) after Ns` goes at the tail, the status goes idle and the mark goes; `last_turn` stays the previous turn's (a new one saved before the turn a `chi send --wait` woke the worker for would end that wait at once); the dead turn's end is recorded under its `enqueued_id` instead, in `<id>/input/settled/<enqueued_id>` (a `last_turn` record: canceled, `cancel_reason: worker_stopped`), which only a wait for that very turn reads (`chi send --queue --wait`, `chi send --wait ID --turn`, a continue's wait): it ends `canceled` with `cancel_reason: worker_stopped`, detail "its worker exited mid-turn", instead of timing out. A reply the turn wrote before its worker died is still its answer. The session shows the turn's prompt and steps with that note; the dead turn is not run again, and the model reads on its next turn that it was cut.
+**A worker killed mid-turn:** while a turn runs, its worker keeps it on disk (`TurnCheckpoint`): the session file has the turn so far (the prompt from the turn's start, then the finished tool steps and lines merged into it) and `interrupted_turn: {id, started_at, at, iteration, enqueued_id}` (`enqueued_id`: the input the turn runs, so any process can tell which turn is running; a continue turn carries its offer turn's), written as the turn starts, at the loop's first iteration boundary and then at most every 10 s (`updated_at` moves with it). The turn's end saves the real messages without the mark. A worker that died without ending its turn (SIGKILL, a crash of the process) leaves the mark, and loses what came after its last written boundary: at most the last 10 s of steps, plus the step in flight. Each checkpoint write also saves the turn's metrics so far to `analytics.json` (tokens, speeds, timings, its finished tool calls), as the record a killed turn leaves: canceled, `cancellation_reason: worker_stopped`; the turn's own end writes over it. The next worker to start for the session (a `chi send`, `--resume`, `--attach`, the web), or a `--no-shared` REPL resuming it, settles the turn before anything else (`TurnCheckpoint.settle`, log `interrupted_turn_settled`): a note `the previous turn was cancelled (worker-stopped) after Ns` goes at the tail, the status goes idle and the mark goes; `last_turn` stays the previous turn's (a new one saved before the turn a `chi send --wait` woke the worker for would end that wait at once); the dead turn's end is recorded under its `enqueued_id` instead, in `<id>/input/settled/<enqueued_id>` (a `last_turn` record: canceled, `cancel_reason: worker_stopped`), which only a wait for that very turn reads (`chi send --queue --wait`, a `chi send --wait -m` to an idle session or `--new`, `chi send --wait ID --turn`, a continue's wait): it ends `canceled` with `cancel_reason: worker_stopped`, detail "its worker exited mid-turn", instead of timing out. A reply the turn wrote before its worker died is still its answer. The session shows the turn's prompt and steps with that note; the dead turn is not run again, and the model reads on its next turn that it was cut.
 
 **Stopping a worker:** `chi sessions stop ID` marks the session stopped (an empty `<id>/stopped` file, not a session.json field, which a worker saving at that moment would write over; a resume removes it), sends its worker TERM and waits (up to 10 s) until the worker has let go of `owner.lock`. A running turn is canceled over the Bridge first, with reason `session_stopped` (the turn's line ends "(session stopped)", its note says `cancelled (session-stopped)`, and a command it was running says "stopped as the session was stopped"; a bare signal to the worker makes it "stopped by a signal to chi"; an older worker takes the reason as `manual`); the TERM stops whatever still runs as a Stop with reason `signal` and saves it (a spawned worker traps TERM, HUP and INT: `WorkerSignals`; a turn not ended within 3 s, 0.5 s after a stop or a second signal, is cut and the session saved as it was), and a stopped worker still saves its kept turn, since the marker, not the saved status, says stopped. Any TERM, HUP or INT does the same to a worker outside a stop: it leaves (log `worker stop reason=signal`) and the next send wakes a new one, so a `chi --resume ID` right after spawns a fresh worker. That is also how to restart a worker still running an older chi, which the attached terminal reports when a command or a question dismiss gets a 404, and the web when an answer, a dismiss, a command or a cancel does (`501 not_supported`; `BridgeClient.stale_worker_message`). A command this chi has that the older worker doesn't (`/llm-context`, the web's `llm ctx` chip, against a 0.39.0 worker) says the same, not `not a session command` (`SessionCommands.builtin_name`); a typo keeps its `400 unknown_command`. The web's `POST /api/sessions/:id/stop` waits the same way, for 2 s (the page's Stop shows the stop at once), or for the body's `wait` up to the same 10 s (`SessionManager::STOP_WAIT`): `chi --remote NAME sessions stop` sends it, so it waits as long as here. A command sent during a turn that waits for its end (`/model X`, `!cmd`; see *Typing during a turn* in [cli.md](cli.md)) and hasn't run when the worker leaves (a stop, a crash) is answered `command_ran {status: "dropped"}`, so no UI keeps showing it waiting.
 
@@ -223,8 +223,8 @@ chi send --new --continues last:3fa2 -m "new day"      # the next link of 3fa2's
   (`SAMAGOTCHI_THINKING_LEVEL=low chi send --new …`) only reaches the worker this call spawns: when the session's
   worker is woken later (by `chi web`, a delivery) without that env, the level is gone. Use `--thinking`.
 - `--new` prints `<full id>  started` on stdout. With `--wait` that line (and the `sent` line for an existing session) goes to stderr, so stdout is exactly the answer: the reply of the turn the message started, in full. It is the worker's `output/` file, the same one `delegate` reads; a turn that ends with only tool calls and no text has none.
-- `--wait` takes one session: `--new` or one id. A session with a running turn is refused (`busy: a turn is running; wait or attach`, exit 1): the message would merge into it, and its reply would come back as the answer. `--queue --wait` is the way in: the message runs as a turn of its own after the running one, and the wait is for that turn alone (the ack's `enqueued_id` names its reply file and its `last_turn`), so the running turn's reply and end, and a question it asks meanwhile, are not the answer (it keeps waiting through them; its `--timeout` still applies); a question its own turn asks is (exit 3). Two queued waits each get their own turn's answer. A session waiting for an answer is still refused. `--format json` adds `delivery`: `queue`, or `next_step` when the running turn ended before the message went in (it then ran at once, and the answer is still its own).
-- 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.
+- `--wait` takes one session: `--new` or one id. A session with a running turn is refused (`busy: a turn is running; --queue runs the message after it, chi send --wait ID waits for it, chi --attach ID shows it`, exit 1): the message would merge into it, and its reply would come back as the answer. To an idle session (or with `--new`) the wait is for the message's own turn (the ack's `enqueued_id`; one merged into a turn that started at that moment gets that turn's reply). `--queue --wait` is the way in: the message runs as a turn of its own after the running one, and the wait is for that turn alone (the ack's `enqueued_id` names its reply file and its `last_turn`), so the running turn's reply and end, and a question it asks meanwhile, are not the answer (it keeps waiting through them; its `--timeout` still applies); a question its own turn asks is (exit 3). Two queued waits each get their own turn's answer. A session waiting for an answer is still refused. `--format json` adds `delivery`: `queue`, or `next_step` when the running turn ended before the message went in (it then ran at once, and the answer is still its own).
+- 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 send --wait --turn T ID` for a turn whose id is known, else `chi send --wait ID waits again; chi --attach ID shows it`, as after a `--timeout`). 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`, `removed` (a `--queue --wait` message taken back before it ran), `no_answer`, `error`, `worker_gone` or `stopped` with a `detail` line (exit 1); `failed` adds `error_kind` and `retryable`, `canceled` adds `cancel_reason` (`worker_stopped`: the turn waited for died with its worker and the next worker settled it) 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).
 - `--set KEY=VALUE` (with `--new`, repeatable) gives the new session a setting of its own, as `chi --set` does (see *Session settings* below): a core key a session may set (`--set recap.enabled=false`) or a bundle's `BUNDLE.KEY` (`chi send --new --set cost-cap.cap=3 -m "…"` starts it with a $3 cap). A key no session sets (`guardrails.mode`), a bundle or key the installed bundles don't offer, or a value of another type than the key takes (`recap.enabled=maybe`, `cost-cap.cap=five`) is a usage error (exit 2), as is `--set` without `--new`.

data/docs/sub-agent.md

@@ -72,7 +72,7 @@ Exit codes, both commands:
 | 3 | `waiting_for_owner` | (a participant's wait, `chi --remote NAME send --wait` with their link's token) their review turn waits on the session's owner: a question or an approval it raised, or the owner's step-limit Continue; wait again |
 | 4 | `running` | `--timeout` passed; the turn goes on, wait again |
 | 1 | `refused` | (a participant's wait) their queued review turn was refused before it ran: `cancel_reason` `revoked` (their link was revoked or expired) or `cap_reached` (they spent their cap); no turn ran for it |
-| 1 | `failed`, `canceled`, `limit`, `removed`, `no_answer`, `error`, `worker_gone`, `stopped` | `detail` says what happened (`limit`: the turn ran out of steps and nobody can be asked, e.g. an older worker; `chi send ID -m '/continue yes'` continues it, except under `guardrails.parent_answers: hard`, where a parent's `/continue yes` is refused as its `chi answer --option Continue` is; `removed`: the `--queue` message waited for was taken back before it ran, no turn ran for it). `failed` adds `error_kind` (the provider error's kind: `credits`, `credits_held`, `rate_limited`, `server`, `auth`, `connection`, …) and `retryable` when known; `canceled` adds `cancel_reason` (`user`: a Stop in the web; `session_stopped`: a session stop, `chi sessions stop` or the web's; `worker_stopped`: the `--queue` turn waited for died with its worker (detail "its worker exited mid-turn"), settled by the next one; `hook`; `ctrl_c`; `manual`) and `stopped_by` (the hook that stopped it, e.g. `loop-guard`) when known |
+| 1 | `failed`, `canceled`, `limit`, `removed`, `no_answer`, `error`, `worker_gone`, `stopped` | `detail` says what happened (`limit`: the turn ran out of steps and nobody can be asked, e.g. an older worker; `chi send ID -m '/continue yes'` continues it, except under `guardrails.parent_answers: hard`, where a parent's `/continue yes` is refused as its `chi answer --option Continue` is; `removed`: the `--queue` message waited for was taken back before it ran, no turn ran for it). `failed` adds `error_kind` (the provider error's kind: `credits`, `credits_held`, `rate_limited`, `server`, `auth`, `connection`, …) and `retryable` when known; `canceled` adds `cancel_reason` (`user`: a Stop in the web; `session_stopped`: a session stop, `chi sessions stop` or the web's; `worker_stopped`: the turn waited for (a `--queue` message's, or a message's to an idle session) died with its worker (detail "its worker exited mid-turn"), settled by the next one; `hook`; `ctrl_c`; `manual`) and `stopped_by` (the hook that stopped it, e.g. `loop-guard`) when known |
 | 2 | (no JSON) | usage error, or an option the question doesn't offer |
 | 130 | `running` | Ctrl-C; the turn goes on |
 

data/docs/testing.md

@@ -223,7 +223,11 @@ docs or source as text (its `RULES`: add one when a full run catches what the na
 file's layer (any `terminal_ui/*.rb` → `spec/terminal_ui_golden_spec.rb`; `turn_flow.rb` and `turn_note.rb`, whose
 words the REPL prints, pick it by a rule), then the other name matches (a spec named after several changed files first, e.g. `engine_toolkit_spec.rb` for `engine.rb` and
 `toolkit.rb`; then one beside the file, so `plugin/context.rb` picks `spec/samagotchi/plugin/*context*` before
-`spec/guardrails/context_spec.rb`), then the specs that name a changed file's class. The default range is the merge-base with main (or origin/main) plus uncommitted and untracked files.
+`spec/guardrails/context_spec.rb`), then the specs that name a method the change touches (the innermost `def` around a
+changed line, read with Prism; one `git grep` for up to 12 names; names under 4 characters, `initialize`, `to_s`,
+`call`… and `Object`'s or `Enumerable`'s methods skip), then the specs that name a changed file's class. The method tier
+needs Prism 1.0 or later: Ruby 3.4+ ships it, a 3.3 install has it only beside rubocop or minitest 6; below that it is
+skipped, which `--why` says. A method named in too many specs to list (a hub) gets a line under `--why` only. The default range is the merge-base with main (or origin/main) plus uncommitted and untracked files.
 The Ruby specs go to stdout; the node tests to run (`npm test` targets), "web changed: also run npm run e2e" (with `npm run lint` too when a frontend module changed) and a
 hint for a hub class (named in too many specs to list) go to stderr, and so do the `timing:` hints, from the lines a
 changed spec adds (`git diff -U0` against the base; an untracked spec, all its lines): a `Thread.new`, `.start`,

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -5,6 +5,7 @@ require_relative "../kernel_loop"
 require_relative "../steer"
 require_relative "../tool_output_cut"
 require_relative "../tool_row_fields"
+require_relative "../turn_origin"
 require_relative "turn_notice"
 
 module Samagotchi
@@ -70,7 +71,7 @@ module Samagotchi
       # Whether the turn in progress is a participant's review turn (its
       # author): the owner's input queues behind it then (Bridge's POST /turn).
       def participant_turn?
-        @mutex.synchronize { !@turn.nil? && Steer.participant_author?(@turn[:author] || @turn.dig(:origin, :author)) }
+        @mutex.synchronize { !@turn.nil? && Steer.participant_author?(@turn[:author] || TurnOrigin.from(@turn[:origin])&.author) }
       end
 
       # The turn in progress as conversation messages, for a plugin's
@@ -382,7 +383,7 @@ module Samagotchi
       end
 
       def dequeue(origins)
-        ids = origins.filter_map { |origin| origin.is_a?(Hash) ? origin[:enqueued_id] : nil }
+        ids = origins.filter_map { |origin| TurnOrigin.from(origin)&.enqueued_id }
         @queued.reject! { |entry| ids.include?(entry[:enqueued_id]) } unless ids.empty?
       end
     end

data/lib/samagotchi/bridge.rb

@@ -22,6 +22,7 @@ require_relative "engine"
 require_relative "session_commands"
 require_relative "queued_command"
 require_relative "steer"
+require_relative "turn_origin"
 require_relative "participants"
 require_relative "image_store"
 require_relative "log"
@@ -1032,14 +1033,14 @@ module Samagotchi
     # +author+'s turns running or waiting: the running turn when it is
     # theirs, and their queued ones. Read with the event log held.
     def pending_turns(author)
-      running = Steer.sender_author(@accumulator.current_turn&.dig(:origin, :author)) == author ? 1 : 0
+      running = TurnOrigin.of(@accumulator.current_turn&.dig(:origin)).participant_author == author ? 1 : 0
       running + @accumulator.queued.count { |row| row[:author] == author }
     end
 
     # 403 not_permitted for a participant's +what+ (a command, a shell
     # line), with its audit line.
     def participant_refused(sid, author, what)
-      Participants.log(sid, :refused, state_dir: File.dirname(session_dir), participant: author.delete_prefix("p:"), what: what,
+      Participants.log(sid, :refused, state_dir: File.dirname(session_dir), participant: Steer.participant_id(author), what: what,
                                       reason: "not_permitted")
       [{}, 403, { error: "not_permitted", detail: Participants::NOT_PERMITTED }]
     end

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

@@ -1,12 +1,12 @@
 ---
 name: cost-cap
-version: 0.2.1
+version: 0.2.3
 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:28d632cd19117ef359acc6aa1c621081c14c018772b7fe1efd6284e346fea135
+  sha256: sha256:57362669f6b499fb70103a11eb6582e261b69103f51ee1ac36496a04717f5d9b
 # ctx.cost is new in chi 0.83.0; ask_user's effects: in the next chi
 requires_chi: ">= 0.92.0"
 # session_settings: as a mapping of keys to types is new

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

@@ -44,6 +44,7 @@ class Plugin
     @warned = nil          # [session id, cap] the share warning was given for
     @unknown_warned = nil  # the session id the "can't be enforced" notice was given for
     @unread_warned = nil   # the session id the "isn't a number" notice was given for
+    @corrupt_warned = nil  # the session id the "state file doesn't read" notice was given for
   end
 
   def register(chi)
@@ -104,6 +105,7 @@ class Plugin
   def check(ctx)
     resolved = resolve(ctx)
     unreadable(ctx, resolved)
+    corrupt(ctx, resolved)
     cap = resolved[:cap]
     return unless cap
 
@@ -140,10 +142,23 @@ class Plugin
     return if bad.nil? || bad.empty? || !first_time?(:@unread_warned, resolved[:session])
 
     named = bad.map { |key, value| "#{key}: #{value.inspect}" }.join(" and ")
-    used = resolved[:cap] ? "using #{resolved[:key]}: (#{money(resolved[:cap])})" : "no cap"
-    ctx.notify("cost-cap: #{named} #{bad.size == 1 ? "isn't" : "aren't"} a number or off; #{used}", level: :warn)
+    ctx.notify("cost-cap: #{named} #{bad.size == 1 ? "isn't" : "aren't"} a number or off; #{using(resolved)}",
+               level: :warn)
   end
 
+  # Once per session: a state file that is there but doesn't read (not
+  # JSON, or not a mapping) holds no /cap cap, so the settings' is used;
+  # said rather than a /cap cap silently gone.
+  def corrupt(ctx, resolved)
+    path = resolved[:corrupt]
+    return unless path && first_time?(:@corrupt_warned, resolved[:session])
+
+    ctx.notify("cost-cap: #{path} doesn't read, its /cap cap is ignored; #{using(resolved)}", level: :warn)
+  end
+
+  # "using default: ($5.00)", or "no cap".
+  def using(resolved) = resolved[:cap] ? "using #{resolved[:key]}: (#{money(resolved[:cap])})" : "no cap"
+
   def at_cap(ctx, resolved, cost)
     cap = resolved[:cap]
     raised = raised_cap(cap, resolved[:step] || cap, cost.total)
@@ -222,20 +237,29 @@ class Plugin
     cached = @mutex.synchronize { @resolved }
     return cached if cached && cached[:session] == session
 
-    resolved = { session: session, **(state(ctx, session) || configured(ctx)) }
+    saved, corrupt = state(ctx, session)
+    resolved = { session: session, **(saved || configured(ctx)), corrupt: corrupt }
     @mutex.synchronize { @resolved = resolved }
   end
 
+  # The state file's cap and step ({cap:, step:}), nil without one (or
+  # one without a "cap"), and the file's path when it is there but
+  # doesn't read (logged; the user is told by #corrupt), else nil.
   def state(ctx, session)
-    return nil unless session
+    return [nil, nil] unless session
 
-    saved = JSON.parse(File.read(state_path(ctx, session)))
-    return nil unless saved.is_a?(Hash) && saved.key?("cap")
+    path = state_path(ctx, session)
+    saved = JSON.parse(File.read(path))
+    raise JSON::ParserError, "not a JSON object" unless saved.is_a?(Hash)
+    return [nil, nil] unless saved.key?("cap")
 
     cap = self.class.amount(saved["cap"])
-    { cap: cap, step: self.class.amount(saved["step"]) || cap }
-  rescue Errno::ENOENT, JSON::ParserError
-    nil
+    [{ cap: cap, step: self.class.amount(saved["step"]) || cap }, nil]
+  rescue Errno::ENOENT
+    [nil, nil]
+  rescue JSON::ParserError => e
+    ctx.log.warn(:costcap_state_unreadable, path: path, error: e.message.to_s[0, 200])
+    [nil, path]
   end
 
   # The first of cap:, child: (a delegate's) and default: that is set and
@@ -259,14 +283,32 @@ class Plugin
     share.is_a?(Numeric) && share.positive? ? share : nil
   end
 
+  # A state file there that doesn't read (#state) is written over: logged
+  # and said, never a silent replace.
   def save(ctx, session, data)
     path = state_path(ctx, session)
     FileUtils.mkdir_p(File.dirname(path))
+    replacing = unreadable_file?(path)
     Samagotchi::AtomicFile.write(path, "#{JSON.generate(data)}\n")
+    replaced(ctx, path) if replacing
     cap = self.class.amount(data["cap"])
     @mutex.synchronize { @resolved = { session: session, cap: cap, step: self.class.amount(data["step"]) || cap } }
   end
 
+  # Whether +path+ is there but doesn't read (not JSON, or not a mapping).
+  def unreadable_file?(path)
+    !JSON.parse(File.read(path)).is_a?(Hash)
+  rescue Errno::ENOENT
+    false
+  rescue JSON::ParserError
+    true
+  end
+
+  def replaced(ctx, path)
+    ctx.log.warn(:costcap_state_replaced, path: path)
+    ctx.notify("cost-cap: #{path} didn't read; replaced with the new cap", level: :warn)
+  end
+
   def state_path(ctx, session) = File.join(ctx.data_dir, "sessions", "#{session.gsub(/[^A-Za-z0-9_.-]/, "_")}.json")
 
   def money(value) = self.class.money(value)

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.107.0
+version: 0.108.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
   self_map.md: sha256:df3f8da539a9f5812f79e089c2c8b9894da6124a89654f292160046a6bb060da
   config_modification_protocol.md: sha256:ff4efccf2bdde453fc4e6741df8c18f78da78e353f6b1a5a64d0e7a631aea258
-  memory_guide.md: sha256:c48eea744db69e4f3e9bb415e9a03a8c78bbcaa1205ad3b1fb157a079f92d22e
+  memory_guide.md: sha256:dfb3982cf281bf7920d018ea65b68b5755f86d8bd1e03bab9db42393a94ec7e0
   delegated.md: sha256:a0d6ddcd4a8be06526d964898611775fd251cfd9d145a9d16afaccaa503597bd

data/lib/samagotchi/bundles/system/memory_guide.md

@@ -26,7 +26,7 @@ This memory teaches you (the agent) how to use Samagotchi memories — persisten
 - `name: "entry", scope: "system"|"project"` — scoped read.
 - `name: "a, b, c"` — comma-separated, concatenated with `\n\n---\n\n`.
 - `name: ""` (optionally with `scope`) — reads the index. Empty name with no scope returns both indexes concatenated (`Project memories:` / `System memories:`). Use this at start to discover what exists.
-- Returns `Error: memory not found: …` on miss — treat as missing, not fatal.
+- Returns `Error: memory not found: …` on miss — treat as missing, not fatal. A `Hint:` line after it means this project's memory folder looks orphaned (moved from another path); tell the user the folders it names, don't rename them yourself.
 
 ### `memory_write` — write/update entries
 

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

@@ -1,12 +1,12 @@
 ---
 name: work-cap
-version: 0.1.1
+version: 0.1.3
 scope: system
 description: "A per-session work cap (tool calls, active minutes) across turns: at a cap the turn pauses on Continue (another cap's worth) / Stop with the session's totals, a warning at 80% goes to the user only; /workcap shows or sets it"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:f4ce7ea7f5801490a29e232c41c7bca2007c140d21f1a78bbfb60e6b6fd4f64b
+  sha256: sha256:3c93baec9ec20e147803311e1eb16d699dc169b52680374c1e6ff865a82204ee
 # ask_user's effects: are in chi 0.92.0; ctx.usage is new in the next chi
 requires_chi: ">= 0.100.0"
 # chi --set work-cap.tool_calls=400 / work-cap.minutes=60: the session's own caps, a number or off