samagotchi 0.62.0 → 0.63.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68aeb876a7c4c04d7f2f5de4290a1c6089df3acd181bce7380ccb6bde9ef9de8
-  data.tar.gz: ed308c360b3942d9f3d08233762396493a018585103e50661dd17ea4bb0d123c
+  metadata.gz: 20b05cd0da6dfdd621eba3b2add37f00b2abe96c2e3950d8ddd066bdf3078424
+  data.tar.gz: ecf5784f9f82c8a8c9e813185570d326a3f4d9ad3a404033f53abf1b62a20902
 SHA512:
-  metadata.gz: 8a3ecca6a15d1c2d0e4acf5531491116139b3423ca0e6fe2b4ad558f5c99b332b50672a700437f9d37c1397d9ed92e527b843e6577b11198906ff75ab16b4ecd
-  data.tar.gz: 949538fdd97549e09bd215353cbdf9dccbe42a21806b965ff828db5b708521791e939abd2d2cb93892c23660abbfabd3106bb492412eb505f52cc0cd742d6d99
+  metadata.gz: 302c8ccf54cc947c9165fe8e30f4d32b4054ee02a1e2d62cbb7d7942a30574af58af84a7eafc5b2daf24a8f167e98024e2798fcacccf597b919435019d498613
+  data.tar.gz: b6ac96ff05fb4e52a5705b55de3fa505054860b154cd6622c4badc232c6284bc5e80d57ffc94b13a7eae1384557acd5b697b630a0ed21be1a8e85d99610b3d04

data/CHANGELOG.md

@@ -8,6 +8,37 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.63.0] - 2026-10-13
+
+### Added
+
+- The claude-peer bundle (in the dev profile): pair a chi session with a Claude Code session you work with, and
+  the `claude_send` tool sends Claude a part of the work (a plan step, a diff, a finding) to validate, as context or
+  with a question; Claude's answer comes back as the `claude-review` context. `/claude validate|context <text>` and
+  `/claude last` send without the model, `/claude` shows whether a Claude is paired, and `/claude install-skill`
+  installs Claude's `chi-peer` skill, which pairs ("pair with chi <id>"). See docs/plugins.md, "The claude-peer
+  bundle".
+- Plugins: `ctx.context.list` gives each source's last `summary:` too. See docs/plugins.md, "Attached context".
+
+### Fixed
+
+- Attached context: a source added with `chi context add NAME --push` now wakes an idle session when its first
+  push asks to (`"wake": true`); before, only later pushes could.
+- Plugins: `ctx.context.list` returns `[]` for a new session whose file isn't saved yet (a plugin command before
+  the first turn) instead of raising "Session not found".
+- An after_turn hook's file refs on the answer (`event[:refs]`) must be under the session's folder, as a plugin
+  tool row's are: a file elsewhere is refused (and logged), and a stored one is dropped when the answer is shown.
+- loop-guard (0.3.8): the card for a turn it stopped prints under the blocked call's row in the terminal, not
+  before it.
+- Attached TUI: joining a session whose last turn was images alone (sent from the web) names each image once, not
+  twice.
+- Attached TUI: text you had typed when the step-limit question opened comes back at the prompt once you answer
+  it, instead of being lost.
+- `chi -p … --non-interactive` says so on stderr and exits 1 when the iteration limit cuts the turn short, instead
+  of exiting 0 with the partial text as if it were the answer.
+- `chi --no-shared --resume` drops a question the session's last worker saved and died with, as an attached resume
+  does, instead of keeping it in the session file.
+
 ## [0.62.0] - 2026-10-13
 
 ### Added
@@ -2719,7 +2750,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.62.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.63.0...HEAD
+[0.63.0]: https://github.com/dm1try/samagotchi/compare/v0.62.0...v0.63.0
 [0.62.0]: https://github.com/dm1try/samagotchi/compare/v0.61.0...v0.62.0
 [0.61.0]: https://github.com/dm1try/samagotchi/compare/v0.60.0...v0.61.0
 [0.60.0]: https://github.com/dm1try/samagotchi/compare/v0.59.0...v0.60.0

data/README.md

@@ -150,7 +150,10 @@ task to a child session that runs in parallel and reports back only its final
 reply (a normal session: `chi --attach <id>` steers it). With the `coordinator`
 bundle (in `dev`), `/coordinate <goal>` has chi split the work into tasks, each
 in a child session in its own git worktree, check each report and ask you
-before each merge; `/children` shows the children and their state.
+before each merge; `/children` shows the children and their state. With the
+`claude-peer` bundle (in `dev`), chi sends a part of its work to a Claude Code
+session you pair it with, to validate or as context, and Claude answers back
+into chi (`/claude`).
 
 `chi send` is the other half: the text goes in as your message, the same as
 typing it in the attached terminal or the web composer, and a turn runs. Piped

data/bin/chi

@@ -386,8 +386,9 @@ begin
     scratch: scratch
   ).run
   # `chi -p X </dev/null`: the turn failed (nothing was sent again); -p
-  # --non-interactive: the turn ended with no answer, or Ctrl-C cancelled it.
-  exit 1 if %i[turn_failed empty_answer].include?(ended)
+  # --non-interactive: the turn ended with no answer or at the iteration
+  # limit, or Ctrl-C cancelled it.
+  exit 1 if %i[turn_failed empty_answer iteration_limit].include?(ended)
   exit Samagotchi::CLI::Exit::INTERRUPTED if ended == :interrupted
 rescue Samagotchi::TerminalUI::SessionBusy, Samagotchi::TerminalUI::SessionNotFound, Samagotchi::ModelProfile::MissingModel => e
   warn "Error: #{e.message}"

data/docs/cli.md

@@ -250,7 +250,10 @@ Notes:
   retry lines and hooks' notices as they come, the after_turn hooks' ones
   (source-links' `sources:`) after the answer; and the error of a failed turn,
   then `chi: the session is kept with your prompt; continue it with: chi
-  --resume ID` (exit 1). Ctrl-C saves the session with the prompt and a
+  --resume ID` (exit 1). A turn the iteration limit (`turn.max_iterations`)
+  cut short prints what the model wrote so far, then `chi: the iteration limit
+  (N) was reached before the turn finished; continue it with: chi --resume ID`
+  on stderr (exit 1). Ctrl-C saves the session with the prompt and a
   cancel note and exits 130.
   Nobody can answer there: an approval is denied, and a question the model
   asks (`ask_user_question`) is dismissed at once (one line on stderr), never

data/docs/configuration.md

@@ -1350,7 +1350,7 @@ column says so, a `--kebab-name` flag. The maps (`hosts:`, `models:`,
 | `memory.index_warn_tokens` | `2500` | yes | The tokens one scope's memory index (project or system; sent with every prompt) may hold before a `memory_write`, `write` or `edit` that takes it over gets a note asking the model to tighten long index descriptions; `0`: no note. Estimated as characters / `context.chars_per_token`. `memory:` is its own section, not the `memories:` preload list. See [Memory](memory.md). |
 | `context.status_thresholds` | `20,40,60,80` | yes | Percentages that put the estimate into a bucket; the rise into a guidance bucket (from the second up) leaves the model its own `[CONTEXT: …]` line, and the bucket decides the guidance. |
 | `context.every_seconds` | `300` | | How often an attached context source's command runs when it has no `--every` (seconds, at least 30). See [Attached context](context.md). |
-| `context.wake` | `true` | yes | A source whose update says `wake: true` may start a turn in a live, idle session (one per source per 10 minutes, within `session.max_wakes`); `false`: updates wait as notes for the next turn. See [Waking](context.md#waking). |
+| `context.wake` | `true` | yes | A source whose update says `wake: true` may start a turn in a live, idle session (one per source per 10 minutes, within `session.max_wakes`); so may a session's pushed source's first push. `false`: updates wait as notes for the next turn. See [Waking](context.md#waking). |
 | `thinking.turn_preamble` | `true` | yes | Ask a `qwen36` model to open its thinking with a short `TURN:` line (the step label). |
 | `reasoning_history` | `turn` | | Which of its reasoning a chat host's model gets back: `drop`, `turn`, `all`; environment only (`SAMAGOTCHI_REASONING_HISTORY`), below a session's own level (`/reasoning-history`), above the `models:`/`hosts:` entries. See "Reasoning history". |
 | `thinking.level` | `default` | `--thinking` | `off`, `low`, `medium`, `high` or `default` for every model; the flag and env outrank the `models:`/`hosts:` entries, the file's value doesn't; a session's own level outranks them all, and `--thinking` sets it on a session run (on `chi web` it sets this). See "Thinking". |

data/docs/context.md

@@ -123,6 +123,11 @@ chi context add clip --push --project
 pbpaste | chi context push clip --project
 ```
 
+A Claude Code session can be a pushed source too: the
+[claude-peer bundle](plugins.md#the-claude-peer-bundle)'s `pair` script attaches
+`claude-inbox` (Claude's inbox socket as the hint) and `claude-review`, where
+Claude pushes its answers as JSON with `wake: true`.
+
 ### A stream: chat, a log, a feed
 
 A source's text is a snapshot, not a log: each run replaces it. For
@@ -233,6 +238,10 @@ you're away from the terminal. All of these must hold:
 - the source asked (`"wake": true`; a plain-text source never does), in
   any change since the session last heard of it: a later change that doesn't
   ask doesn't take the wake back;
+- it's a change, not the source's first text, except for a session's pushed
+  source (`chi context add NAME --push`, attached empty): its first push can
+  wake too. A command or URL source's first fetch runs as you attach it, and a
+  project source's first text may predate the session, so neither wakes;
 - `context.wake` is on (default `true`);
 - the session's worker is up and idle: no turn running, nothing queued, no
   question or continue offer waiting, not just started;
@@ -242,15 +251,16 @@ you're away from the terminal. All of these must hold:
 - the source hasn't woken the session in the last 10 minutes.
 
 Otherwise the change arrives as a note, as above. The turn starts with the
-update note, whose last line becomes:
+update note, or, for a session's pushed source, its attached note, whose last
+line becomes:
 
 > chi started this turn because the source changed; your user didn't write anything. Tell your user in a sentence or two what changed and what it may mean for their work. Don't run commands, change files or reply on the source for it: wait for your user to ask.
 
 Every UI labels the turn `context <name> changed`, and the web's
 notifications count it as a finished turn however short.
 
-A wake turn that fails goes back to before it and keeps the update as a
-plain note; the model reads `[SYSTEM: the previous turn failed before any
+A wake turn that fails goes back to before it and keeps its note as a
+plain one; the model reads `[SYSTEM: the previous turn failed before any
 answer: … The wake turn for the change in attached context <name> was not
 answered; chi starts no other wake turn until the user writes.]`.
 

data/docs/hooks.md

@@ -301,9 +301,12 @@ end
   keywords only (String or Symbol keys inside `target` and `actions`).
   - `match`: the text in the answer the ref stands for (at most 500 characters).
   - `kind`: a short lowercase word. `"file"` takes `target: {path:, line:, end_line:}`
-    (the lines optional); a relative path is resolved against the session's
-    folder, an absolute one is kept as given. Any other kind (`"issue"`,
-    `"commit"`, …) takes `target: {id:}`.
+    (the lines optional); the path is absolute or relative to the session's
+    folder, and must be **under** it (its own spelling or its real path:
+    `/tmp/x` or `/private/tmp/x`), as a plugin tool row's file refs
+    ([plugins.md](plugins.md)): a file elsewhere is refused. It is kept under
+    the folder's real path. Any other kind (`"issue"`, `"commit"`, …) takes
+    `target: {id:}`.
   - `label`: what a UI shows for it (optional, at most 200 characters).
   - `actions`: links a UI offers on top of the kind's own, each
     `{id:, label:, url:}`; http(s) URLs only, without userinfo (`user:pass@`),

data/docs/memory.md

@@ -270,7 +270,7 @@ profiles, meta bundles that install a set of them:
 | profile | bundles |
 |---|---|
 | `core` | loop-guard, check-in, guardrails, slow-commands, agents-md: the recommended safety set |
-| `dev` | known-names, mcp, btw, skills, source-links, github-pr, coordinator |
+| `dev` | known-names, mcp, btw, skills, source-links, github-pr, coordinator, claude-peer |
 
 `chi bootstrap` installs `core` and, on a terminal, offers `dev`. An existing
 install gets neither by itself: `chi bundle install core` (or `dev`).

data/docs/plugins.md

@@ -722,7 +722,7 @@ ctx.sessions.stop(id)      # one of this session's own children
 ```ruby
 ctx.context.attach(url: "https://github.com/acme/app/pull/42", why: "branch feat/x has open PR #42")
 ctx.context.attach(name: "ci", cmd: "bin/ci-status", why: "this branch's CI", every_seconds: 120)
-ctx.context.list  # => [{name:, scope:, why:, hint:, fetched_at:, error:, provider:}]
+ctx.context.list  # => [{name:, scope:, why:, hint:, fetched_at:, error:, provider:, summary:}]
 ctx.context.decline(url: "https://github.com/acme/app/pull/42")    # => "pr-42"
 ctx.context.mark_offered("pr-42", "https://github.com/acme/app/pull/42", why: "branch feat/x has open PR #42")
 ctx.context.offered("pr-42")  # => #<data Offer name="pr-42", hint="https://…", why="branch…", at="2026-10-08T…Z">, or nil
@@ -756,7 +756,10 @@ gets a note when its text changes.
 - The source is the session's (not the project's), marked
   `added_by: plugin:<bundle>`. It is plugin code, so it isn't asked about as
   the agent's `chi context add --cmd` is.
-- `list` gives the session's sources, its own then its project's.
+- `list` gives the session's sources, its own then its project's (`[]` before
+  the session has an id or its file is saved: a command before the first turn). `hint` is the
+  one the last text gave (else the source's), `summary` that text's summary
+  (nil before any text; chi 0.63.0).
 - Two attaches of one source at once (a double click) both return its
   name.
 - `attach`, `decline` and `mark_offered` raise
@@ -1504,6 +1507,90 @@ by themselves there.
         reason: merging a child's branch
   ```
 
+## The claude-peer bundle
+
+```sh
+chi bundle install claude-peer    # in the dev profile
+```
+
+A live link between a chi session and a Claude Code session you already work
+with: chi sends it a part of the work (a plan step, a diff, a finding) to
+validate or as context, and Claude's answer comes back into chi. This is
+Claude with the context it has, not a fresh review run. Nothing runs until a
+Claude pairs; without one the bundle costs one tool declaration.
+
+- **Pairing is Claude's.** chi can't see Claude's inbox, so Claude attaches
+  two pushed sources to the chi session: `claude-inbox`, whose hint is its
+  per-session inbox socket (`CLAUDE_CODE_MESSAGING_SOCKET`, Claude Code
+  2.1.224 or later), and `claude-review`, where its answers come. You never
+  run that yourself:
+  1. `/claude install-skill` (once) shows a card with the target,
+     `$CLAUDE_CONFIG_DIR/skills/chi-peer/SKILL.md` (else `~/.claude/…`),
+     whether one is there and, when it differs, a short diff; its Install (or
+     Replace) button runs `/claude install-skill --yes`, which copies the
+     bundle's `scripts/chi-peer-SKILL.md` there with the installed
+     `scripts/pair` path written in. The copy happens inside chi, where no
+     guardrail sees it: the button is your consent. The card also offers the
+     Claude Code permission rule `Read(~/.local/state/samagotchi/plugins/claude-peer/**)`
+     (your state folder), so Claude isn't asked before reading a long part's
+     file; chi never writes Claude's settings.
+  2. In Claude Code you say "pair with chi <id or chi web URL>". The skill runs
+     `sh <bundle>/scripts/pair <id or URL>`, which attaches `claude-inbox` (the
+     socket as its hint, pushed as JSON so a re-pair after a Claude restart
+     refreshes it) and `claude-review`, and lists the session's context. A
+     re-pair keeps Claude's last answer.
+  3. Claude answers a validate or a question with a JSON push to
+     `claude-review` (`text`, `summary`, `wake: true`), which wakes chi, the
+     first answer too (on chi 0.62 the first one arrives as a note without
+     waking); the model reads it with `context_read claude-review`.
+- **The tool `claude_send(kind, title, text)`**, `kind` being `validate`,
+  `context` or `question`, writes one JSON line to that socket. The message
+  starts with a header, `chi <id> · <kind> · <title>`. A text up to 4,000
+  characters follows inline; a longer one goes to a file,
+  `$XDG_STATE_HOME/samagotchi/plugins/claude-peer/sessions/<id>/<HHMMSS>-<slug>.md`
+  (removed with the session), and the message names it (`payload: <path>`).
+  The tool is declared whether or not a Claude is paired, so pairing doesn't
+  change the prompt. Its errors say what to do: no `claude-inbox` (pair from
+  Claude), the socket gone or refusing (that Claude session ended or
+  restarted: pair again), a text over 200,000 characters.
+- **`/claude`** (an anytime command, so it works mid-turn) sends without
+  the model:
+  - `/claude` alone shows a card: paired or not, the socket and whether its
+    file is there (it goes when that Claude session ends), the last send, and
+    Claude's last answer (the `claude-review` summary).
+  - `/claude validate <text>` and `/claude context <text>` send the text as it
+    is, titled by its first line: paste a selection after them.
+  - `/claude last` sends the model's last completed answer as context. Mid-turn
+    it is the answer before the running turn, never the turn's partial text;
+    a cancelled or failed turn has no answer, so the one before it goes.
+- **The skill.** `skill_claude_peer` (system scope) tells the model to send
+  only when you ask, to pick the part rather than the session, not to wait
+  or poll, and how to read the `claude-review` answer (a validate ends with
+  `VERDICT: OK`, `CHANGES` or `UNSURE`).
+- **Asking first.** The tool has no `targets:`, so guardrails match it by name
+  only: to be asked before each send, add a rule ([Rules in
+  config.yml](guardrails.md#rules-in-configyml)):
+
+  ```yaml
+  guardrails:
+    rules:
+      - id: claude-send
+        tool: claude_send
+        verdict: ask
+        reason: sends session content to Claude Code
+  ```
+
+- **Limits.** The socket's format (`{"type":"user","message":{"role":"user","content":"…"}}`)
+  is undocumented: it was found in, and checked on, Claude Code 2.1.296. A
+  line Claude Code can't parse is dropped silently, so a Claude Code update
+  could break this without an error. No auth line is sent: it is optional on
+  macOS and Linux, and native Windows, which needs it, isn't supported.
+  Claude's `crossSessionInbound` setting decides what it does with a peer
+  message: an interactive auto-mode session delivers it; a session that
+  bypasses permissions holds it for approval (in `-p` it expires after 5
+  minutes). It is local only (a Unix socket), but it does hand session
+  content to another agent: only what the model or you picked.
+
 ## Shutdown
 
 When the REPL exits, or a session's worker exits (an idle exit, `/exit`, a

data/docs/releasing.md

@@ -13,7 +13,7 @@ can run the whole release; the user approves the notes before the tag and the
   and `rake release:check` enforce it). The system bundle upgrades itself when
   chi starts.
 - **Every other shipped bundle** (btw, check-in, guardrails, known-names,
-  loop-guard, mcp, skills, source-links, github-pr, coordinator, and the profiles core and dev) has its own semver in its
+  loop-guard, mcp, skills, source-links, github-pr, coordinator, claude-peer, and the profiles core and dev) has its own semver in its
   `manifest.yml` and, when it needs a newer chi, a `requires_chi:` line. They never upgrade by themselves: users run
   `chi update` (all of them, with the gem) or `chi bundle upgrade NAME`. So:
   - a change to a bundle's files bumps that bundle's `version:`

data/docs/sub-agent.md

@@ -13,6 +13,12 @@ worker keeps the turn paused. The parent answers with `chi answer`, from what it
 knows or after asking its own user, and chi goes on from there. The model gets
 the answer as its tool result, as if you had answered in the web.
 
+The other direction, chi sending a part of its work to a Claude Code session
+you already work with (to validate, as context, or with a question), is the
+[claude-peer bundle](plugins.md#the-claude-peer-bundle): Claude pairs with the
+chi session, chi's `claude_send` tool or `/claude` writes to Claude's inbox,
+and Claude's answer comes back as attached context.
+
 ## The commands
 
 ```sh

data/docs/testing.md

@@ -15,10 +15,13 @@ bug) or a broken spec: fix it, or disable that line with the reason (`# rubocop:
 No spec reads your own setup. The suite points `XDG_CONFIG_HOME` and `XDG_STATE_HOME` at temp folders,
 clears your `SAMAGOTCHI_*` environment, and keeps every spec off the network (WebMock).
 
-The web specs run in plain node. One that loads lit-html (`turn_view.js`, `thinking_chip.js`, `llm_context_chip.js`,
-`info_bar.js`, `lists_view.js`, `context_chips.js`, `families_view.js`, `chains.js`, `vendor/lit-html.js`) needs a DOM: `import "./dom_shim.js";` as its first import (happy-dom, a
-devDependency only, never shipped; about 0.3 s per spec file that loads it). The shim's `htmlOf(nodes)` and `canon(html)` compare markup
-without lit's marker comments. happy-dom 20 picks the wrong option of a `<select>` whose options lit inserted with
+The web specs run in plain node. One that loads lit-html, itself or through a module it imports (`turn_view.js`,
+`turn_html.js`, `card.js`, `copy.js`, `images.js`, `scope.js`, `command_view.js`, `diff_view.js`, `read_view.js`,
+`question_cards.js`, `stream_handlers.js`, the chips, `info_bar.js`, `lists_view.js`, `context_chips.js`, `families_view.js`,
+`chains.js`, `vendor/lit-html.js`) needs a DOM: `import "./dom_shim.js";` as its first import (happy-dom, a devDependency only,
+never shipped; about 0.3 s per spec file that loads it; lit reads `document` as it loads). The shim's `markupOf(template)`,
+`htmlOf(nodes)` and `canon(html)` compare markup without lit's marker comments; the DOM writes text with only `&`, `<`, `>`
+escaped (a `"` in text stays `"`) and an attribute with `&` and `"` escaped. happy-dom 20 picks the wrong option of a `<select>` whose options lit inserted with
 `?selected`: read the option marked `selected` (`option[selected]`), not `select.value`; the browser follows the mark.
 A select bound with `.value` instead reads right in both, but lit sets it before the options exist on a first render:
 `llm_context_chip.js`'s `renderForm` draws twice then. Assert a kept node with `assert.ok(a === b)`: a failing

data/lib/samagotchi/answer_refs.rb

@@ -3,6 +3,7 @@
 require "json"
 require_relative "log"
 require_relative "ref"
+require_relative "row_refs"
 
 module Samagotchi
   # One ref on the answer: the text it stands for (+match+, what the page
@@ -27,30 +28,20 @@ module Samagotchi
     MAX_MATCH = 500
 
     # A hook's {match:, kind:, target:, label:, actions:}, or a stored
-    # entry (String or Symbol keys, nested ones too). A file ref's relative
-    # path is resolved against +cwd+, so the stored path is absolute; with
-    # no +cwd+ it is refused. An absolute path stays as given.
+    # entry (String or Symbol keys, nested ones too). A file ref is held to
+    # the session's folder as a plugin row's is (RowRefs.inside, plan D7):
+    # +roots+ is RowRefs.roots of it; a relative path is resolved against
+    # it (+relative+; a stored one was stored absolute, so it is dropped),
+    # a path outside it refused, and the path kept under its real
+    # spelling. With no folder (no +roots+), an absolute path stays.
     # @raise [ArgumentError] anything invalid
-    def self.from(value, cwd: nil)
+    def self.from(value, roots: [], relative: true)
       raise ArgumentError, "a ref is a Hash {match:, kind:, target:, label:, actions:}" unless value.is_a?(Hash)
 
       value = value.transform_keys(&:to_sym)
       ref = Ref.new(kind: value[:kind], target: value[:target], label: value[:label], actions: value[:actions] || [])
-      new(match: value[:match], ref: absolute(ref, cwd))
+      new(match: value[:match], ref: RowRefs.inside(ref, roots, relative))
     end
-
-    def self.absolute(ref, cwd)
-      return ref unless ref.kind == Ref::FILE
-
-      path = ref.target[:path]
-      return ref if File.absolute_path?(path)
-      raise ArgumentError, "relative path, no session folder" if cwd.to_s.empty?
-
-      # absolute_path, not expand_path: a leading ~ is a name, never a home.
-      Ref.new(kind: ref.kind, target: ref.target.merge(path: File.absolute_path(path, cwd.to_s)), label: ref.label,
-              actions: ref.actions)
-    end
-    private_class_method :absolute
   end
 
   # The refs after_turn hooks attach to a turn's answer (event[:refs]),
@@ -71,12 +62,13 @@ module Samagotchi
     # Stored refs (+raw+, as read from session.json or a snapshot), each
     # rebuilt and checked again, the caps applied; what isn't valid any
     # more is dropped. Never raises: a reload must show the conversation.
-    # A relative file path is dropped (there is no folder to resolve it).
+    # A relative file path is dropped (it was stored absolute), and with
+    # +cwd+ (the session's folder) a file outside it.
     # @return [Array<Hash>] the refs to send ({match:, kind:, target:, …})
-    def self.for_display(raw)
+    def self.for_display(raw, cwd: nil)
       return [] if raw.nil?
 
-      kept = new([{ role: "model", KEY => raw }], cwd: nil).to_a
+      kept = new([{ role: "model", KEY => raw }], cwd: cwd).to_a
       dropped = raw.is_a?(Array) ? raw.length - kept.length : 1
       Log.debug(:web, "display_refs_dropped", count: dropped) if dropped.positive?
       kept
@@ -92,7 +84,7 @@ module Samagotchi
     def initialize(messages, cwd:)
       last = Array(messages).last
       @target = last if last.is_a?(Hash) && (last[:role] || last["role"]).to_s == "model"
-      @cwd = cwd
+      @roots = RowRefs.roots(cwd)
       @refs = []
       @seen = {}
       @bytes = 2 # the list's []
@@ -149,7 +141,7 @@ module Samagotchi
       unknown = value.keys - KEYS
       return reject(hook, "has unknown keys #{unknown.map(&:to_s).inspect}") unless unknown.empty?
 
-      entry = AnswerRef.from(value, cwd: @cwd).to_h
+      entry = AnswerRef.from(value, roots: @roots).to_h
       return true if @seen.key?(entry)
       return over_cap(hook, "#{MAX_REFS} refs") if @refs.length >= MAX_REFS
 
@@ -163,11 +155,11 @@ module Samagotchi
     end
 
     # A stored entry back in the list, checked again (a relative path is
-    # dropped: it was stored absolute). Duplicates and what is over the
-    # caps go quietly.
+    # dropped: it was stored absolute; so is a file outside the folder).
+    # Duplicates and what is over the caps go quietly.
     # @return [Boolean] kept
     def keep(raw)
-      entry = AnswerRef.from(raw, cwd: nil).to_h
+      entry = AnswerRef.from(raw, roots: @roots, relative: false).to_h
       return false if @seen.key?(entry) || @refs.length >= MAX_REFS
 
       size = JSON.generate(entry).bytesize + (@refs.empty? ? 0 : 1)

data/lib/samagotchi/bridge.rb

@@ -180,6 +180,25 @@ module Samagotchi
       raise e
     end
 
+    # Raised on a connection thread whose request would queue something
+    # (a turn, a command, an exit) after #close_intake: the connection
+    # closes unanswered, as #stop's kill of a request still waiting did.
+    class IntakeClosed < StandardError; end
+
+    # With the event log held (the worker leaving: Worker#leave_idle,
+    # #leave_on_request): no connection is accepted and no request queues
+    # a turn, a command or an exit from here on. #stop, called once the log
+    # is let go, does the rest: a request that waited on the log then ends
+    # at once instead of holding #stop for its REQUEST_GRACE_SECONDS.
+    def close_intake
+      @mutex.synchronize { @stopped = true }
+      begin
+        @server&.close
+      rescue StandardError
+        nil
+      end
+    end
+
     # Stop the acceptor, release the socket and remove the sidecar, so clients
     # don't have to find it stale. Does not stop the owning turn. Joins the
     # acceptor thread so the process can exit cleanly (Ruby waits for a thread
@@ -394,7 +413,7 @@ module Samagotchi
         log_request(method, request[:path], started)
         break if close_after_request?(headers)
       end
-    rescue Errno::EPIPE, Errno::ECONNRESET, IOError
+    rescue Errno::EPIPE, Errno::ECONNRESET, IOError, IntakeClosed
       nil
     rescue StandardError => e
       # The thread doesn't report (report_on_exception = false): log it.
@@ -728,6 +747,7 @@ module Samagotchi
       # A card's action: the UIs leave its line out (the card is the echo).
       command = QueuedCommand.mint(line, client_id: client_id, card: card)
       queued = @engine.synchronize_events do
+        raise IntakeClosed if stopped?
         next false if expired?("command_expired", deadline, sid: session_id, client_id: command.client_id)
 
         queue_command_locked(command)
@@ -777,6 +797,7 @@ module Samagotchi
       return BAD_DEADLINE unless deadline_valid?(deadline)
 
       reason = @engine.synchronize_events do
+        raise IntakeClosed if stopped?
         next :expired if expired?("exit_expired", deadline, sid: session_id, client_id: client_id)
 
         @on_exit_request.call(client_id, **options)
@@ -851,6 +872,7 @@ module Samagotchi
       # this turn's :turn_started (or merge it mid-turn) before
       # :turn_enqueued, and a failed write announces nothing.
       enqueued = @engine.synchronize_events do
+        raise IntakeClosed if stopped?
         next :expired if expired?("turn_expired", deadline, sid: sid, client_id: client_id)
 
         enqueue_turn(prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,

data/lib/samagotchi/bundles/claude-peer/manifest.yml

@@ -0,0 +1,22 @@
+---
+name: claude-peer
+version: 0.1.0
+scope: system
+description: "Pair this session with a Claude Code session you work with: the claude_send tool and /claude send it a part of the work (a plan step, a diff, a finding) to validate or as context, and Claude's answer comes back as the claude-review context; /claude install-skill installs Claude's chi-peer skill, which pairs"
+trust_level: reviewed
+files:
+  skill_claude_peer.md:
+    sha256: sha256:dff0175d0370f43920daf5ecbb81315fdd2c7d8063a33fbefc75c7d0e7312993
+    description: "Send a part of the work to the paired Claude Code session (claude_send): only when the user asks; validate, context or question; Claude's answer comes as the claude-review context"
+plugin:
+  file: plugin.rb
+  sha256: sha256:bf5a95eb125ba4831466e177295bdaba1f625e255b027cea1e59992310d8300e
+scripts:
+  pair: sha256:033f1fc6a644950b57e71865253526a0a487bb4c9fd5a61bb89d031b65f40417
+  chi-peer-SKILL.md: sha256:f35f726b1a86091ff69d289e8dd58794ac6f44879a63630fcc88d69867c56e20
+# Two things need chi 0.63.0, and the bundle works without them on 0.62:
+# ctx.context.list's summary: (the /claude card's last answer; without it
+# the card shows no summary), and a pushed source's first wake: true push
+# waking the session (on 0.62 Claude's first answer arrives as a note
+# without waking; later ones wake).
+requires_chi: ">= 0.62.0"